Update trash files ehe

Backend/GALinterpreter.py

@@ -1,22 +1,58 @@
-from GALsemantic import (ProgramNode, VariableDeclarationNode, AssignmentNode, BinaryOpNode, FunctionDeclarationNode, 
-                          FunctionCallNode, IfStatementNode, ForLoopNode, WhileLoopNode, PrintNode, UnaryOpNode, 
-                          FertileDeclarationNode, ReturnNode,  SwitchNode, ContinueNode, BreakNode, ListNode, TaperNode, 
+# ============================================================================
+# GAL INTERPRETER - Tree-walking executor for the semantic AST
+# ============================================================================
+# This is the runtime engine of the GAL compiler. It walks the AST produced
+# by GALsemantic and executes each node directly. The interpreter does NOT
+# consume the ICG output — TAC is a parallel display layer; execution happens
+# here on the AST.
+#
+# Pipeline position:
+#   lex -> parse -> AST -> semantic -> ICG (display) -> THIS FILE (execute)
+#
+# Output is sent via self.socketio.emit('output', ...) which can be either
+# a real Socket.IO instance (live mode) or an OutputCollector (synchronous).
+# Input is collected via self.socketio.emit('input_required', ...) which
+# parks the interpreter until provide_input() is called.
+# ============================================================================
+
+# ============================================================================
+# IMPORTS - AST node classes from the semantic analyzer + concurrency
+# primitives for cooperative input-waiting.
+# ============================================================================
+from GALsemantic import (ProgramNode, VariableDeclarationNode, AssignmentNode, BinaryOpNode, FunctionDeclarationNode,
+                          FunctionCallNode, IfStatementNode, ForLoopNode, WhileLoopNode, PrintNode, UnaryOpNode,
+                          FertileDeclarationNode, ReturnNode,  SwitchNode, ContinueNode, BreakNode, ListNode, TaperNode,
                           TSNode, SoilNode, BloomNode, AppendNode, InsertNode, RemoveNode, CastNode, ListAccessNode, DoWhileLoopNode,
                           MemberAccessNode, BundleDefinitionNode, ArrayMemberAccessNode)
 
 import threading
 import sys
 
+# Allow deeply recursive GAL programs (e.g. recursive pollinate functions)
+# without hitting Python's default recursion limit (1000)
 sys.setrecursionlimit(10000)
 
 # Prefer eventlet's cooperative Event so wait_for_input yields to the
 # eventlet hub instead of blocking the entire event loop.
+# Falls back to threading.Event if eventlet isn't installed (e.g. in tests).
 try:
     import eventlet.event as _ev
     _USE_EVENTLET = True
 except ImportError:
     _USE_EVENTLET = False
 
+
+# ============================================================================
+# EXCEPTION CLASSES - Used to short-circuit AST traversal for special cases:
+#   - SemanticError      : A semantic-level error that escaped to runtime
+#   - ReturnValue        : reclaim <value> uses exception unwinding to bubble
+#                          a return value up through nested function calls
+#   - _CancelledError    : raised when the user starts a new run while an
+#                          old interpreter is still executing
+#   - InterpreterError   : standard runtime error (division by zero, etc.)
+#   - InterpreterInputRequest : raised when the program calls water() to
+#                               request input from the client
+# ============================================================================
 class SemanticError(Exception):
     def __init__(self, message,  line):
         super().__init__(message)
@@ -26,6 +62,7 @@ class SemanticError(Exception):
         return self.message
 
 class ReturnValue(Exception):
+    """Raised by 'reclaim <expr>;' to unwind out of a function with a value."""
     def __init__(self, value):
         self.value = value
 
@@ -34,6 +71,7 @@ class _CancelledError(Exception):
     pass
 
 class InterpreterError(Exception):
+    """All runtime errors raised by the interpreter inherit from this."""
     def __init__(self, message, line):
         super().__init__(message)
         if line is not None:
@@ -41,38 +79,67 @@ class InterpreterError(Exception):
 
         else:
             self.message = message
-    
+
     def __str__(self):
         return self.message
 
 class InterpreterInputRequest(Exception):
+    """Carries a prompt up the call stack when water() needs input."""
     def __init__(self, prompt, line):
         self.prompt = prompt
         self.line = line
 
+# ============================================================================
+# INTERPRETER CLASS - Tree-walks the AST and executes each node
+# ============================================================================
+# State organization:
+#   - self.scopes      : stack of scope dicts (innermost on top); enter_scope
+#                        pushes a fresh dict, exit_scope pops it
+#   - self.variables   : globals (visible from every scope)
+#   - self.functions   : pollinate definitions, keyed by function name
+#   - self.bundle_types: bundle (struct) layouts
+#   - self.loop_stack  : current loop nesting, used by prune/skip
+#   - self.break_flag  : 'prune' was hit, propagate up to nearest loop/switch
+#   - self.continue_flag: 'skip' was hit, propagate up to nearest loop
+#   - self.input_*     : channels for water() input arriving from the client
+#   - self.socketio    : adapter for output/input I/O (SessionEmitter or
+#                        OutputCollector — both expose .emit())
+# ============================================================================
 class Interpreter:
     def __init__(self, socketio=None):
-        self.output = []
-        self.loop_stack = []
-        self.break_flag = False
-        self.continue_flag = False
-        self.input_required = False
-        self.socketio = socketio
-        self.input_events = {}
-        self.input_values = {}
-        self.current_node = None
+        # ---- Output state ----
+        self.output = []                # legacy collector, kept for compat
+        self.socketio = socketio        # plant() uses this to emit 'output'
+
+        # ---- Control-flow flags (set by break/continue, cleared by loops) ----
+        self.loop_stack = []            # nested loop-type strings
+        self.break_flag = False         # set by 'prune'
+        self.continue_flag = False      # set by 'skip'
+
+        # ---- Input plumbing for water() ----
+        self.input_required = False     # True while waiting for the client
+        self.input_events = {}          # var_name -> Event (eventlet/threading)
+        self.input_values = {}          # var_name -> string typed by client
+
+        # ---- Diagnostics ----
+        self.current_node = None        # node being interpreted (for error msgs)
         self.current_parent = None
 
-        self.variables = {} 
-        self.global_variables = {}
-        self.functions = {}
-        self.scopes = [{}]
-        self.current_func_name = None
-        self.function_variables = {}
-        self.bundle_types = {}  # Stores bundle (struct) type definitions
-
-
-    ###### VARIABLE ######
+        # ---- Symbol tables ----
+        self.variables = {}             # global variables (visible everywhere)
+        self.global_variables = {}      # mirror used by declare_variable for dup-check
+        self.functions = {}             # pollinate definitions (name -> info)
+        self.scopes = [{}]              # scope stack; [0] is the global scope
+        self.current_func_name = None   # name of the function currently executing
+        self.function_variables = {}    # per-function locals (legacy, partially unused)
+        self.bundle_types = {}          # bundle (struct) layouts
+
+
+    # ========================================================================
+    # VARIABLE MANAGEMENT - declare / lookup / set
+    # Lookup walks the scope stack from innermost outward, then falls back to
+    # globals. This implements lexical scoping for the AST walker.
+    # ========================================================================
     def declare_variable(self, name, type_, value=None, is_list=False, is_fertile=False):
         scope = self.scopes[-1]
         current_func = self.current_func_name
@@ -119,9 +186,14 @@ class Interpreter:
         return f"Semantic Error: Variable '{name}' not declared in any scope."
 
 
-    ###### FUNCTION ######
+    # ========================================================================
+    # FUNCTION MANAGEMENT - declare / lookup
+    # GAL functions are first registered (when the parser walks pollinate
+    # declarations) and then invoked by name from eval_function_call.
+    # ========================================================================
     def declare_function(self, name, return_type, params, node=None):
         if name in self.functions:
+            # Returns an error string — caller decides whether to raise
             return f"Semantic Error: Function '{name}' already declared."
         self.functions[name] = {"return_type": return_type, "params": params, "node": node}
 
@@ -129,17 +201,24 @@ class Interpreter:
         if name in self.functions:
             return self.functions[name]
         return f"Semantic Error: Function '{name}' is not defined."
-    
 
-    ###### SCOPE ######
+
+    # ========================================================================
+    # SCOPE MANAGEMENT - enter / exit
+    # Each function call, block, and loop body pushes a fresh scope onto
+    # self.scopes. Variables declared inside go in the top dict and vanish
+    # when the scope is popped.
+    # ========================================================================
     def enter_scope(self):
         self.scopes.append({})
-        
+
 
     def exit_scope(self):
+        # Never pop the global scope (scopes[0])
         if len(self.scopes) > 1:
             self.scopes.pop()
-        
+
+        # Clear function-local cache if we're leaving a function call
         if self.current_func_name:
             current_func = self.current_func_name
 
@@ -147,8 +226,11 @@ class Interpreter:
                 self.function_variables[current_func].clear()
 
 
-
-    #INTERPRETER
+    # ========================================================================
+    # MAIN AST DISPATCH - The 'switch' that maps each AST-node class to its
+    # eval_* handler. This is the entry point of execution; server.py calls
+    # interp.interpret(ast) where ast is a ProgramNode.
+    # ========================================================================
     def interpret(self, node):
         if isinstance(node, ProgramNode):
             return self.eval_program(node)
@@ -242,13 +324,24 @@ class Interpreter:
         else:
             raise Exception(f"Unknown AST node type: {node.node_type}")
 
+    # ========================================================================
+    # PROGRAM ENTRY - Walks every top-level declaration (globals, fertile,
+    # bundle, pollinate functions) and then synthesizes a call to root().
+    # This implements GAL's rule that root() is always the entry point.
+    # ========================================================================
     def eval_program(self, node):
+        # 1. Process every top-level node (registers globals + functions)
         for child in node.children:
             self.interpret(child)
 
+        # 2. Now invoke root() — the program's entry point
         main_call = FunctionCallNode("root", [], node.line)
         return self.interpret(main_call)
 
+
+    # ========================================================================
+    # DECLARATIONS - variables, bundles, members, fertile (constants)
+    # ========================================================================
     def eval_variable_declaration(self, node):
         var_type = node.children[0].value
         var_name = node.children[1].value
@@ -386,6 +479,16 @@ class Interpreter:
         value = self.interpret(value_node)
         self.declare_variable(var_name, var_type, value, is_list=False,  is_fertile=True)
 
+
+    # ========================================================================
+    # ASSIGNMENT - The biggest dispatch in this file. Handles every shape:
+    #   x = expr;            (simple variable)
+    #   arr[i] = expr;       (single-dim list element)
+    #   arr[i][j] = expr;    (multi-dim list element)
+    #   bundle.member = expr;(struct member)
+    #   x += expr; etc.      (compound assignment operators)
+    # Type-checking against the variable's declared type happens here too.
+    # ========================================================================
     def eval_assignment(self, node):
         target_node = node.children[0]
         value_node = node.children[1]
@@ -565,6 +668,14 @@ class Interpreter:
             #print(f"\nUpdating variable '{var_name}' of type '{var_type}' with value: {value}")
 
 
+    # ========================================================================
+    # BINARY OPERATIONS - + - * / % ** == != < <= > >= && || `
+    # The biggest expression evaluator. Each operator branch coerces non-
+    # numeric operands (bool, str) into numeric form before computing, so
+    # mixed-type expressions don't crash. The `(backtick) operator handles
+    # vine concatenation specially (BEFORE _parse_literal) to preserve
+    # whitespace-only strings like " ".
+    # ========================================================================
     def eval_binary_op(self, node):
         left = self.interpret(node.children[0])
         right = self.interpret(node.children[1])
@@ -619,6 +730,17 @@ class Interpreter:
                     elif isinstance(right, str):
                         right = 1 if right != "" else 0
                 return left * right
+            elif operator == '**':
+                if not isinstance(left, (int, float)) and not isinstance(right, (int, float)):
+                    if isinstance(left, bool):
+                        left = 1 if left == True else 0
+                    elif isinstance(left, str):
+                        left = 1 if left != "" else 0
+                    if isinstance(right, bool):
+                        right = 1 if right == True else 0
+                    elif isinstance(right, str):
+                        right = 1 if right != "" else 0
+                return left ** right
             elif operator == '/':
                 if not isinstance(left, (int, float)) and not isinstance(right, (int, float)):
                     if isinstance(left, bool):
@@ -724,6 +846,12 @@ class Interpreter:
         except ZeroDivisionError:
             raise InterpreterError("Runtime Error: Division by zero", "")
 
+    # ========================================================================
+    # _PARSE_LITERAL - Converts a token's string value into the right Python
+    # type. Handles GAL's negative-number prefix '~' (e.g. '~5' -> -5), the
+    # boolean keywords sunshine/frost, and ints / floats / strings / chars.
+    # Called from inside eval_binary_op before doing arithmetic.
+    # ========================================================================
     def _parse_literal(self, value):
 
         if isinstance(value, str):
@@ -763,8 +891,13 @@ class Interpreter:
             return value 
     
 
+    # ========================================================================
+    # FUNCTION DECLARATION - Registers a 'pollinate' function so it can be
+    # called later. This walks the parameter list and saves the function
+    # body node for the actual call to interpret.
+    # ========================================================================
     def eval_function_declaration(self, node):
-        return_type = node.children[0].value 
+        return_type = node.children[0].value
         parameters_node = node.children[1]
         func_name = node.value
 
@@ -782,24 +915,41 @@ class Interpreter:
 
         return None
 
+    # ========================================================================
+    # BLOCK EXECUTION - Walks the children of a block { ... } in order,
+    # short-circuiting if a break (prune) or continue (skip) was triggered.
+    # ========================================================================
     def eval_block(self, block_node):
         for statement in block_node.children:
-            self.interpret(statement) 
+            self.interpret(statement)
+            # 'prune' was hit somewhere inside — stop executing this block
             if self.break_triggered():
                 return
+            # 'skip' was hit — also stop; the surrounding loop handles re-entry
             if self.continue_flag:
                 return
-            
-            
+
+
+    # ========================================================================
+    # OUTPUT - 'plant' primitive. Routes to socketio.emit so output is
+    # delivered to the right client (live mode) or collected (sync mode).
+    # ========================================================================
     def plant(self, value):
         """GAL output primitive."""
         self.socketio.emit('output', {'output': str(value)})
 
-    # Backward-compatible alias
+    # Backward-compatible alias kept for older internal callers
     def plant_out(self, num):
         self.socketio.emit('output', {'output': str(num)})
         self.output.append(str(num))
 
+
+    # ========================================================================
+    # PRINT STATEMENT - Implements plant("template", arg1, arg2, ...).
+    # If the first argument is a string with {} placeholders, it formats
+    # the rest into the template (Python str.format style). Otherwise
+    # arguments are joined with spaces (C printf style).
+    # ========================================================================
     def eval_print(self, node):
         if not node.children:
             return
@@ -849,11 +999,16 @@ class Interpreter:
 
         self.plant(str(evaluated_first))
 
+    # ========================================================================
+    # FORMATTED STRING - Strips outer quotes and converts escape sequences
+    # (\n, \t, \", \{, \}, \/, \\) into their real characters before the
+    # string is used as a plant() template.
+    # ========================================================================
     def eval_formatted_string(self, node):
         value = node.value
         if value.startswith('"') and value.endswith('"'):
             value = value[1:-1]
-        
+
         # Escape sequences
         value = value.replace(r'\\', '\\')
         value = value.replace(r'\n', '\n')
@@ -864,7 +1019,12 @@ class Interpreter:
         value = value.replace(r'\/', '/')
         return value
 
-        
+
+    # ========================================================================
+    # LIST ACCESS - arr[index] reads. Validates bounds and that the index
+    # is an integer. NOTE: indexing is 0-based in the implementation, even
+    # though the GAL spec describes 1-based arrays.
+    # ========================================================================
     def eval_list_access(self, node):
         # children[0] is ASTNode("ListName", list_name) where list_name is a string or ListAccessNode
         name_or_node = node.children[0].value
@@ -892,11 +1052,22 @@ class Interpreter:
         return list_value[index]
     
 
+    # ========================================================================
+    # RETURN ('reclaim') - Uses exception unwinding so the return value
+    # bubbles up cleanly through any number of nested blocks/loops/ifs.
+    # eval_function_call catches ReturnValue and uses its .value as the
+    # call's result.
+    # ========================================================================
     def eval_return(self, node):
         value = self.interpret(node.children[0]) if node.children else None
         raise ReturnValue(value)
-    
 
+
+    # ========================================================================
+    # FUNCTION CALL - Looks up the function, validates arg count, binds
+    # parameters into a fresh scope, and runs the body. ReturnValue is
+    # caught to extract 'reclaim'-returned values.
+    # ========================================================================
     def eval_function_call(self, node):
         function_name = node.value
         args = [self.interpret(arg.children[0]) for arg in node.children]
@@ -938,6 +1109,11 @@ class Interpreter:
             self.current_func_name = None
 
 
+    # ========================================================================
+    # LIST OPERATIONS - append, insert, remove
+    # These mutate the underlying Python list stored in the variable's value.
+    # Index validation matches eval_list_access (0-based bounds).
+    # ========================================================================
     def eval_append(self, node):
         list_name = node.parent.children[0].value
         list_info = self.lookup_variable(list_name)
@@ -986,6 +1162,12 @@ class Interpreter:
         removed = list_info["value"].pop(index)
         #print(f"Removed value {removed} from list '{list_name}': {list_info['value']}")
 
+    # ========================================================================
+    # UNARY OPERATIONS - x++, x--, ~x (negate), !x (logical not)
+    # Increment/decrement mutate the variable in place; ~ and ! return a
+    # new value without mutation. Works on both simple variables and
+    # list elements (arr[i]++).
+    # ========================================================================
     def eval_unaryop(self, node):
         if not isinstance(node.children[0], ListAccessNode):
             operand_node = node.children[0]
@@ -1062,6 +1244,10 @@ class Interpreter:
 
         raise InterpreterError(f"Unknown unary operator {node.value}", node.line)
     
+    # ========================================================================
+    # TYPE CAST - Converts a value to the named GAL type. Supports the five
+    # data types: seed, tree, leaf, branch, vine.
+    # ========================================================================
     def eval_cast(self, node):
         value = self.interpret(node.children[1])
         cast_type = node.children[0].value
@@ -1072,7 +1258,7 @@ class Interpreter:
             return float(value)
         elif cast_type == "leaf":
             if isinstance(value, int):
-                return chr(value)
+                return chr(value)        # int -> ASCII character
             return str(value)[0] if value else '\0'
         elif cast_type == "branch":
             return bool(value)
@@ -1081,6 +1267,15 @@ class Interpreter:
         else:
             raise InterpreterError(f"Unknown cast type: {cast_type}", node.line)
 
+
+    # ========================================================================
+    # STRING / LIST UTILITY HELPERS - taper, ts, soil, bloom
+    #   taper  : split a vine into a list of leaves (characters)
+    #   ts     : length of a list, vine, or leaf-array
+    #   soil   : lowercase a string
+    #   bloom  : uppercase a string
+    # These are GAL's built-in string/collection primitives.
+    # ========================================================================
     def eval_taper(self, node):
         var_name = node.children[0].value
         var_info = self.lookup_variable(var_name)
@@ -1113,6 +1308,12 @@ class Interpreter:
         var_info = self.lookup_variable(var_name)
         return var_info["value"].upper()
 
+    # ========================================================================
+    # CONDITIONAL: spring / bud / wither (if / else-if / else)
+    # GAL chains: spring (cond) {} bud (cond) {} bud (cond) {} wither {}
+    # We evaluate the spring condition, then bud chain, then wither default.
+    # The condition must be a boolean (branch type).
+    # ========================================================================
     def eval_if_statement(self, node):
         condition_result = self.interpret(node.children[0].children[0])
         self.enter_scope()
@@ -1159,10 +1360,16 @@ class Interpreter:
 
         return None
     
+    # ========================================================================
+    # LOOPS: cultivate (for), grow (while), tend (do-while)
+    # All three use the same MAX_LOOP_ITERATIONS guard (10000) to catch
+    # runaway loops during a demo. Each tracks break/continue flags so
+    # 'prune' exits the loop and 'skip' jumps to the next iteration.
+    # ========================================================================
     def eval_for_loop(self, node):
         self.enter_loop('for')
         self.enter_scope()
-        MAX_LOOP_ITERATIONS = 10000
+        MAX_LOOP_ITERATIONS = 10000              # Runaway-loop safety net
         LOOP_COUNTER = 0
 
         try:
@@ -1274,12 +1481,18 @@ class Interpreter:
             self.exit_loop()
 
     
+    # ========================================================================
+    # BREAK / CONTINUE - 'prune' and 'skip'
+    # These set flags that the surrounding block / loop checks each
+    # iteration. The loop_stack ensures break/continue can only be used
+    # inside a loop or switch.
+    # ========================================================================
     def eval_break(self, node):
         if self.loop_stack:
             self.trigger_break()
         else:
             raise InterpreterError("Runtime Error: Break statement used outside of a loop", node.line)
-        
+
     def trigger_break(self):
         self.break_flag = True
 
@@ -1287,6 +1500,7 @@ class Interpreter:
         return self.break_flag
 
     def enter_loop(self, loop_type):
+        # Push a new loop frame; reset break/continue so they don't carry over
         self.loop_stack.append(loop_type)
         self.break_flag = False
         self.continue_flag = False
@@ -1302,13 +1516,19 @@ class Interpreter:
             self.trigger_continue()
         else:
             raise InterpreterError("Runtime Error: Continue statement used outside of a loop", node.line)
-        
+
     def continue_triggered(self):
         return self.continue_flag
-    
+
     def trigger_continue(self):
         self.continue_flag = True
 
+
+    # ========================================================================
+    # SWITCH: harvest / variety / soil  (switch / case / default)
+    # Cases match the switch value. 'prune' inside a case exits the switch.
+    # 'soil' is the default case (executes if no variety matched).
+    # ========================================================================
     def eval_switch(self, node):
         self.enter_loop('switch')
         self.enter_scope()
@@ -1353,7 +1573,18 @@ class Interpreter:
             self.exit_scope()
 
 
+    # ========================================================================
+    # INPUT SYSTEM ('water')
+    # When water() runs, the interpreter:
+    #   1. emit_input_request   -> tells the client to show an input box
+    #   2. wait_for_input        -> parks on an Event (eventlet or threading)
+    #   3. (client emits 'capture_input' -> server calls provide_input)
+    #   4. provide_input         -> .send() / .set() unblocks the waiter
+    #   5. wait_for_input returns the typed string
+    #   6. eval_input parses and type-checks it (e.g. ~5 -> -5 for seed)
+    # ========================================================================
     def emit_input_request(self, var_name, prompt):
+        # Tell the client a water() prompt is needed
         self.socketio.emit('input_required', {'prompt': prompt, 'variable': var_name})
 
     # Method to capture input from the client
@@ -1394,7 +1625,14 @@ class Interpreter:
             self.input_events.pop(var_name, None)
             return value
 
-    # Modify the eval_input method to use the new input handling
+    # ========================================================================
+    # EVAL_INPUT - Implements 'water(...)'. Determines what type of value
+    # the receiving variable expects, prompts the user, then validates and
+    # converts the typed input to that type. Enforces strict GAL syntax:
+    #   - Negative numbers must use '~' (not '-')
+    #   - Booleans must be 'sunshine' or 'frost' (not 'true'/'false')
+    # Errors include a "did you mean" suggestion to guide the user.
+    # ========================================================================
     def eval_input(self, node):
         parent_node = node.parent
         if isinstance(parent_node, VariableDeclarationNode):

Backend/GALsemantic.py

@@ -1,6 +1,32 @@
+# ============================================================================
+# GAL SEMANTIC ANALYZER + AST BUILDER
+# ============================================================================
+# This file does THREE jobs:
+#   1. Defines all AST node classes (ProgramNode, FunctionDeclarationNode,
+#      etc.) that the rest of the compiler consumes.
+#   2. Provides the SymbolTable used to track declarations across scopes.
+#   3. Provides build_ast(tokens) which walks the token stream and
+#      constructs the AST — and ALSO performs many semantic checks during
+#      construction (undeclared variables, duplicate functions, type
+#      mismatches in expressions). A separate ASTValidator does an extra
+#      tree-walking pass for checks that need the full AST visible.
+#
+# Pipeline position:
+#   lex -> parse -> THIS FILE (build AST + check semantics) -> ICG -> run
+#
+# Two entry points:
+#   build_ast(tokens)      : called by Gal_Parser.parse_and_build
+#   validate_ast(ast, st)  : called by server.py for the final tree pass
+#   analyze_semantics(toks): legacy one-shot entry (lex+parse already done)
+# ============================================================================
+
 import re
 
-##### ERROR ######
+
+# ============================================================================
+# ERROR CLASS - Raised whenever the analyzer detects a semantic problem.
+# Includes the source line so the IDE can highlight the right location.
+# ============================================================================
 class SemanticError(Exception):
     def __init__(self, message,  line):
         super().__init__(message)
@@ -10,14 +36,28 @@ class SemanticError(Exception):
         return self.message
 
 
-##### SEMANTIC ANALYZER #####
+# ============================================================================
+# SEMANTIC ANALYZER (legacy placeholder)
+# This class is a vestige of an earlier design. The actual semantic checks
+# happen inside the parse_* functions below and inside ASTValidator at the
+# bottom of this file. Kept for backward compatibility.
+# ============================================================================
 class SemanticAnalyzer:
     def __init__(self, symbol_table):
         self.symbol_table = symbol_table
         self.visited_nodes = set()
 
 
-##### AST NODES #####
+# ============================================================================
+# AST NODE CLASSES
+# Each node has:
+#   - node_type   : a string label (e.g. "Program", "VariableDeclaration")
+#   - value       : the node's primary data (function name, operator, etc.)
+#   - children    : list of child ASTNodes
+#   - line        : source line for error reporting
+#   - parent      : back-pointer for traversals (set by add_child)
+# Subclasses below define convenient constructors for each AST shape.
+# ============================================================================
 class ASTNode:
     def __init__(self, node_type, value=None, line=None):
         self.node_type = node_type  # Type of node (e.g., 'VariableDeclaration', 'BinaryOp')
@@ -236,7 +276,13 @@ class BundleDefinitionNode(ASTNode):
         self.members = members  # dict: {member_name: member_type}
 
 
-###### SYMBOL TABLE ######
+# ============================================================================
+# SYMBOL TABLE - Tracks declarations during AST construction
+# Stores variables, functions, and bundle (struct) types. Maintains a
+# scope stack so the parser can detect 'undeclared' / 'redeclared' errors
+# during build_ast. After AST construction the table is passed to
+# ASTValidator for the second-pass checks (function arity, return types).
+# ============================================================================
 
 class SymbolTable:
     def __init__(self):
@@ -347,9 +393,17 @@ symbol_table = SymbolTable()
 semantic_analyzer = SemanticAnalyzer(symbol_table)
 context_stack = []
 
-#######################
-###### BUILD AST ######
-#######################
+# ============================================================================
+# BUILD AST - Main entry point for AST construction
+# ============================================================================
+# Walks the token stream produced by the lexer (after parser validation)
+# and constructs a tree of ASTNode objects. While walking it also performs
+# many semantic checks via the parse_* helpers below (undeclared variables,
+# duplicate functions, type mismatches in expressions, etc.).
+#
+# Called by Gal_Parser.parse_and_build right after LL(1) syntax validation.
+# Returns the root ProgramNode. Errors are raised as SemanticError.
+# ============================================================================
 
 def build_ast(tokens):
     """Constructs an AST from the token list after LL(1) parsing."""
@@ -423,7 +477,7 @@ def build_ast(tokens):
                     root.add_child(node)
 
             else: 
-                raise SemanticError(f"Syntax Error: Expected data type for function declaration after 'pollinate'.", tokens[index].line)
+                raise SemanticError(f"Semantic Error: Expected data type for function declaration after 'pollinate'.", tokens[index].line)
 
         elif token.value == "fertile":
             node, index = parse_fertile(tokens, index)
@@ -523,7 +577,7 @@ def parse_functionOrVariable(tokens, index):
             node, index = parse_variable(tokens, index, id_name, id_type) 
         
         else:
-            error = f"Syntax Error: Invalid function or variable declaration."
+            error = f"Semantic Error: Invalid function or variable declaration."
             raise SemanticError(error, line)
         
         node.line = line
@@ -590,6 +644,12 @@ def _all_paths_return(node):
 
     return False
 
+# ============================================================================
+# DECLARATION PARSERS - parse_function, parse_variable
+# These build the AST nodes for top-level declarations and register them
+# in the symbol table. parse_function handles both root() and pollinate
+# functions; parse_variable handles seed/tree/leaf/branch/vine declarations.
+# ============================================================================
 def parse_function(tokens, index, func_name, func_type):
     line = tokens[index].line
 
@@ -612,17 +672,17 @@ def parse_function(tokens, index, func_name, func_type):
         if tokens[index].type == "(":
             index += 1
             if tokens[index].type != ")":
-                raise SemanticError(f"Syntax Error: {func_name}() should not have parameters.", line)
+                raise SemanticError(f"Semantic Error: {func_name}() should not have parameters.", line)
             index += 1
         elif func_name == "root":
-            raise SemanticError("Syntax Error: Missing () for root function declaration.", line)
+            raise SemanticError("Semantic Error: Missing () for root function declaration.", line)
 
         params_node = ASTNode("Parameters")
         func_node = FunctionDeclarationNode(func_type, func_name, params_node)
 
     else:
         if tokens[index].type != "(":
-            error = f"Syntax Error: Missing () for function declaration."
+            error = f"Semantic Error: Missing () for function declaration."
             raise SemanticError(error, line)
 
         params_node = ASTNode("Parameters")
@@ -645,7 +705,7 @@ def parse_function(tokens, index, func_name, func_type):
                     if tokens[index].type == "[":
                         index += 1  # skip '['
                         if tokens[index].type != "]":
-                            raise SemanticError(f"Syntax Error: Expected ']' after '[' in array parameter.", line)
+                            raise SemanticError(f"Semantic Error: Expected ']' after '[' in array parameter.", line)
                         index += 1  # skip ']'
                         is_list = True
                         param_node.add_child(ASTNode("ArrayParam", "true"))
@@ -659,7 +719,7 @@ def parse_function(tokens, index, func_name, func_type):
                         index += 1
 
                 else:
-                    error = f"Syntax Error: Invalid parameter declaration."
+                    error = f"Semantic Error: Invalid parameter declaration."
                     raise SemanticError(error, line)
 
             elif tokens[index].type == "id" and tokens[index].value in symbol_table.bundle_types:
@@ -680,7 +740,7 @@ def parse_function(tokens, index, func_name, func_type):
                     if tokens[index].type == ",":
                         index += 1
                 else:
-                    error = f"Syntax Error: Invalid parameter declaration."
+                    error = f"Semantic Error: Invalid parameter declaration."
                     raise SemanticError(error, line)
 
             else:
@@ -710,16 +770,16 @@ def parse_function(tokens, index, func_name, func_type):
         # All functions (including root) must end with reclaim;
         if not has_any_return:
             if func_name == "root":
-                raise SemanticError(f"Syntax Error: root() must end with 'reclaim;'.", line)
+                raise SemanticError(f"Semantic Error: root() must end with 'reclaim;'.", line)
             elif func_type == "empty":
-                raise SemanticError(f"Syntax Error: Function '{func_name}' must end with 'reclaim;'.", line)
+                raise SemanticError(f"Semantic Error: Function '{func_name}' must end with 'reclaim;'.", line)
 
         index += 1
         func_node.add_child(block_node)
         symbol_table.exit_scope()
         symbol_table.current_func_name = None
     else:
-        error = f"Syntax Error: Function body must be enclosed in curly braces."
+        error = f"Semantic Error: Function body must be enclosed in curly braces."
         raise SemanticError(error, line)
 
     return func_node, index
@@ -769,7 +829,7 @@ def parse_variable(tokens, index, var_name, var_type):
                 water_line = tokens[index].line
                 index += 1  # skip 'water'
                 if tokens[index].type != "(":
-                    raise SemanticError(f"Syntax Error: Expected '(' after water.", water_line)
+                    raise SemanticError(f"Semantic Error: Expected '(' after water.", water_line)
                 index += 1  # skip '('
                 water_type = None
                 if tokens[index].value in {"seed", "tree", "leaf", "branch", "vine"}:
@@ -874,6 +934,13 @@ def _skip_semicolons(tokens, index):
     return index
 
 
+# ============================================================================
+# STATEMENT PARSER - The big dispatch
+# Walks one statement at a time inside a function body. Recognizes every
+# statement form: variable declaration, assignment, function call,
+# spring/bud/wither, grow/cultivate/tend, harvest, plant, water,
+# reclaim, prune, skip. Returns (ast_node, new_index).
+# ============================================================================
 def parse_statement(tokens, index, func_type = None):
     token = tokens[index]
 
@@ -1630,6 +1697,18 @@ def parse_expression_leaf(tokens, index):
     return left_node, index 
 
 
+# ============================================================================
+# EXPRESSION PARSER - Operator-precedence climbing
+# Standard precedence ladder built from these layered functions:
+#   parse_expression    : + - `      (lowest precedence)
+#   parse_term          : * / %
+#   parse_power         : **         (right-associative)
+#   parse_unary         : ~ ! ++ --
+#   parse_factor        : literals, identifiers, function calls,
+#                          parenthesized expressions     (highest)
+# Each layer calls the next-higher-precedence layer for its operands.
+# All return (ast_node, new_index, inferred_type).
+# ============================================================================
 def parse_expression(tokens, index):
     """Parses an expression with +, -, and ` (string concat).
     Returns (node, index, type_str)."""
@@ -1679,7 +1758,7 @@ def parse_expression(tokens, index):
 def parse_term(tokens, index):
     """Parses multiplication, division, and modulus with type checking.
     Returns (node, index, type_str)."""
-    left_node, index, left_type = parse_unary(tokens, index)
+    left_node, index, left_type = parse_power(tokens, index)
 
     while tokens[index].type in {"*", "/", "%"}:
         op = tokens[index].value
@@ -1702,7 +1781,7 @@ def parse_term(tokens, index):
                 )
 
         index += 1
-        right_node, index, right_type = parse_unary(tokens, index)
+        right_node, index, right_type = parse_power(tokens, index)
 
         # Validate right operand is numeric
         if right_type not in {"seed", "tree"}:
@@ -1732,6 +1811,36 @@ def parse_term(tokens, index):
 
     return left_node, index, left_type
 
+def parse_power(tokens, index):
+    """Parses right-associative exponentiation (**).
+    Returns (node, index, type_str)."""
+    left_node, index, left_type = parse_unary(tokens, index)
+
+    if tokens[index].type == "**":
+        op = tokens[index].value
+        token = tokens[index]
+
+        if left_type not in {"seed", "tree"}:
+            raise SemanticError(
+                f"Semantic Error: Cannot use '{op}' on type '{left_type}'. Expected 'seed' or 'tree'.",
+                token.line,
+            )
+
+        index += 1
+        right_node, index, right_type = parse_power(tokens, index)
+
+        if right_type not in {"seed", "tree"}:
+            raise SemanticError(
+                f"Semantic Error: Cannot use '{op}' on type '{right_type}'. Expected 'seed' or 'tree'.",
+                token.line,
+            )
+
+        left_node = BinaryOpNode(left_node, op, right_node, line=token.line)
+        if left_type == "tree" or right_type == "tree":
+            left_type = "tree"
+
+    return left_node, index, left_type
+
 def parse_unary(tokens, index):
     """Returns (node, index, type_str)."""
 
@@ -2228,7 +2337,7 @@ def parse_operand(tokens, index):
 
         if is_list and tokens[index + 1].type != "[":
             # Check if this is an array <op> array case (e.g., x = a + b)
-            if tokens[index + 1].type in {"+", "-", "*", "/", "%", "==", "!=", ">", "<", ">=", "<="}:
+            if tokens[index + 1].type in {"+", "-", "*", "/", "%", "**", "==", "!=", ">", "<", ">=", "<="}:
                 op_token = tokens[index + 1]
                 if index + 2 < len(tokens) and tokens[index + 2].type == "id":
                     rhs_info = symbol_table.lookup_variable(tokens[index + 2].value)
@@ -2818,6 +2927,12 @@ def parse_fertile(tokens, index):
 
     return FertileDeclarationNode(var_type, var_name, value_node, line=line), index
 
+# ============================================================================
+# CONTROL-FLOW PARSERS - parse_if / parse_for / parse_while / parse_do /
+# parse_switch. Each builds the matching AST node (IfStatementNode,
+# ForLoopNode, etc.) and recursively parses the body via parse_statement.
+# Conditions must evaluate to a branch (boolean) — checked here.
+# ============================================================================
 def parse_if(tokens, index, func_type):
     line = tokens[index].line
     index += 1  # Move past "spring"
@@ -3591,6 +3706,12 @@ def is_inside_loop_or_switch_stack():
     return any(ctx in {"WhileNode", "DoWhileNode", "SwitchNode", "ForNode"} for ctx in context_stack)
 
 
+# ============================================================================
+# analyze_semantics() - LEGACY ONE-SHOT ENTRY POINT
+# Older API that does build_ast in one call. The current pipeline uses
+# the two-step parse_and_build + validate_ast instead so the IDE can
+# distinguish 'syntax' from 'semantic' error stages.
+# ============================================================================
 def analyze_semantics(tokens):
     """
     Legacy API — builds AST from tokens and validates in one pass.
@@ -3870,6 +3991,11 @@ class ASTValidator:
             self._walk(child)
 
 
+# ============================================================================
+# validate_ast() - PUBLIC SEMANTIC-ANALYSIS ENTRY POINT
+# Used by server.py after parse_and_build succeeds. Wraps ASTValidator.
+# Returns a dict with success/errors/warnings/symbol_table/ast.
+# ============================================================================
 def validate_ast(ast, symbol_table_data):
     """Public API: validate an already-built AST.
 
@@ -3886,4 +4012,4 @@ def validate_ast(ast, symbol_table_data):
         dict with keys: success, errors, warnings, symbol_table, ast
     """
     validator = ASTValidator()
-    return validator.validate(ast, symbol_table_data)
+    return validator.validate(ast, symbol_table_data)

Backend/Gal_Parser.py

@@ -1,3 +1,20 @@
+# ============================================================================
+# GAL LL(1) PARSER - Table-driven syntax analysis + AST construction
+# ============================================================================
+# This is the syntax-analysis stage of the compiler. It consumes the token
+# stream from the lexer and validates it against the GAL grammar (defined
+# in cfg.py). The parser is LL(1) — it picks a production using one token
+# of lookahead via the precomputed PREDICT sets.
+#
+# Pipeline position:
+#   lex -> THIS FILE (parse + build AST) -> semantic -> ICG -> interpret
+#
+# The parser exposes two entry points:
+#   parse(tokens)            : syntax-only check, returns (success, errors)
+#   parse_and_build(tokens)  : syntax + AST construction (delegates to
+#                              GALsemantic.build_ast), returns dict with
+#                              ast/errors/symbol_table/error_stage
+# ============================================================================
 
 from __future__ import annotations
 
@@ -12,6 +29,11 @@ from GALsemantic import (
 )
 
 
+# ============================================================================
+# TOKEN VIEW HELPERS - The parser accepts tokens as either Token objects
+# or dicts (e.g. when reloaded from JSON). _TokView gives a uniform shape
+# so the parsing loop doesn't have to handle both cases.
+# ============================================================================
 @dataclass(frozen=True)
 class _TokView:
     """Lightweight view to normalize token access."""
@@ -24,12 +46,14 @@ class _TokView:
 def _as_tok(token: Any) -> _TokView:
     """Normalize token objects/dicts to a common view."""
     if isinstance(token, Mapping):
+        # Dict-shaped token (came from a JSON request body)
         return _TokView(
             type=str(token.get("type", "")),
             value=str(token.get("value", "")),
             line=int(token.get("line", 0) or 0),
             col=int(token.get("col", 0) or 0),
         )
+    # Token object (the lexer's normal output)
     return _TokView(
         type=str(getattr(token, "type", "")),
         value=str(getattr(token, "value", "")),
@@ -38,6 +62,9 @@ def _as_tok(token: Any) -> _TokView:
     )
 
 
+# ============================================================================
+# LL1Parser - The table-driven LL(1) parser
+# ============================================================================
 class LL1Parser:
     def __init__(
         self,
@@ -72,6 +99,13 @@ class LL1Parser:
         
         self.parsing_table: Dict[str, Dict[str, List[str]]] = self.construct_parsing_table()
 
+    # ========================================================================
+    # PARSING TABLE CONSTRUCTION
+    # Builds the LL(1) parsing table from the CFG + PREDICT sets.
+    # Layout: table[non_terminal][lookahead_token] = production_to_apply.
+    # Raises ValueError if the grammar isn't LL(1) (two productions claim
+    # the same lookahead) — this is the compile-time correctness check.
+    # ========================================================================
     def construct_parsing_table(self) -> Dict[str, Dict[str, List[str]]]:
         """Build LL(1) parsing table using provided PREDICT sets."""
         table: Dict[str, Dict[str, List[str]]] = {}
@@ -82,6 +116,8 @@ class LL1Parser:
                 key = (non_terminal, tuple(production))
                 terms = self.predict_sets.get(key, set())
                 for terminal in terms:
+                    # An LL(1) conflict means the grammar can't be parsed
+                    # with one token of lookahead — fix the grammar first.
                     if terminal in row and row[terminal] != production:
                         raise ValueError(
                             f"LL(1) conflict at {non_terminal} with lookahead {terminal}: "
@@ -91,6 +127,13 @@ class LL1Parser:
             table[non_terminal] = row
         return table
 
+
+    # ========================================================================
+    # TOKEN NORMALIZATION HELPERS - Bridge between lexer and grammar
+    # The lexer emits some token types that don't match the CFG terminal
+    # names (e.g. 'dbllit' from lexer vs 'dblit' in cfg.py). The alias map
+    # papers over those differences in one place.
+    # ========================================================================
     def _normalize_token_type(self, token_type: str) -> str:
         """Map lexer token types into the terminal names used by the CFG."""
         return self.token_type_alias.get(token_type, token_type)
@@ -129,6 +172,13 @@ class LL1Parser:
         'EOF': 'end of file',
     }
 
+    # ========================================================================
+    # ERROR-MESSAGE HELPERS
+    # When the parser hits a token that doesn't match any production, we
+    # build a friendly "Expected: X, Y, Z" string from the parsing-table
+    # row. _generate_helpful_error adds context-aware hints (e.g. "did you
+    # mean '==' instead of '='?").
+    # ========================================================================
     def _format_expected(self, expected: Set[str], non_terminal: Optional[str] = None) -> str:
         """Return a human-readable string listing the expected terminals.
 
@@ -157,6 +207,13 @@ class LL1Parser:
             return 'nothing'
         return f"Expected: {', '.join(parts)}"
 
+    # ========================================================================
+    # _GENERATE_HELPFUL_ERROR - The big one
+    # When a token doesn't match, this method inspects context (previous
+    # tokens, the non-terminal we're inside, common typos like '==='/' &&&')
+    # and produces a SPECIFIC error rather than a generic "Expected: ..."
+    # message. This is what makes GAL's error messages friendly.
+    # ========================================================================
     def _generate_helpful_error(
         self,
         non_terminal: str,
@@ -728,6 +785,15 @@ class LL1Parser:
         # Default message with helpful context
         return f"SYNTAX error line {line} col {col} Unexpected token '{token_value}'. {self._format_expected(expected, non_terminal)}"
 
+    # ========================================================================
+    # parse() - LL(1) SYNTAX VALIDATION (no AST built)
+    # The classic table-driven LL(1) algorithm: maintain a parse stack
+    # initialized with the start symbol, then for each input token either
+    # 'match' a terminal (pop stack + advance input) or 'expand' a
+    # non-terminal (look up table[NT][lookahead], push the production
+    # backwards onto the stack). Returns (success, error_messages_list).
+    # Used by /api/parse for syntax-only checking.
+    # ========================================================================
     def parse(self, tokens: Sequence[Any]) -> Tuple[bool, List[str]]:
         """Parse tokens according to the supplied CFG/PREDICT sets.
 
@@ -1394,8 +1460,15 @@ class LL1Parser:
         
         return True, []
 
-    # ── AST Construction ─────────────────────────────────────────────
-
+    # ========================================================================
+    # parse_and_build() - SYNTAX + AST CONSTRUCTION (full parser entry)
+    # First runs the LL(1) check; if it passes, delegates to
+    # GALsemantic.build_ast which walks the same token stream and
+    # constructs the AST. Some semantic errors (undeclared variables,
+    # duplicate functions) are caught during AST construction and reported
+    # with error_stage='semantic' so the IDE can label them correctly.
+    # Used by /api/semantic, /api/icg, /api/run, and Socket.IO 'run_code'.
+    # ========================================================================
     def parse_and_build(self, tokens: Sequence[Any]):
         """Validate syntax with LL(1) grammar, then build AST.
 

Backend/cfg.py

@@ -1,7 +1,26 @@
+# ============================================================================
+# GAL CONTEXT-FREE GRAMMAR + PARSE TABLE
+# ============================================================================
+# This file contains the grammar that defines GAL syntax and the helpers
+# that build the LL(1) parse table from it. Three artifacts are exported:
+#
+#   cfg           : Dict[non_terminal -> List[List[symbol]]] productions
+#   first_sets    : Dict[non_terminal -> Set[terminal]] FIRST sets
+#   predict_sets  : Dict[(non_terminal, production) -> Set[terminal]]
+#
+# The parser (Gal_Parser.LL1Parser) consumes these to drive its table-
+# driven LL(1) algorithm. λ (lambda) denotes the empty production.
+#
+# To add or change grammar rules:
+#   1. Edit the cfg dict at the bottom of this file
+#   2. Run this module — FIRST/FOLLOW/PREDICT are recomputed automatically
+#   3. The parser will detect any LL(1) conflict at startup
+# ============================================================================
+
 import sys
 from collections import defaultdict
 
-# Set UTF-8 encoding for Windows console
+# Set UTF-8 encoding for Windows console (so λ prints correctly during dev)
 if sys.platform == 'win32':
     try:
         sys.stdout.reconfigure(encoding='utf-8')
@@ -168,7 +187,7 @@ def compute_predict(cfg, first, follow):
             predict[key] = first_set
             # If production can derive epsilon, add FOLLOW(lhs)
             if epsilon in first_set:
-                predict[key] |= follow[lhs]
+                predict[key] |= follow[lhs] 
 
     return predict
 
@@ -703,7 +722,8 @@ cfg = {
     # 3. Relational (>, <, >=, <=, ==, !=)
     # 4. Arithmetic (+, -)
     # 5. Term (*, /, %)
-    # 6. Factor (literals, variables, function calls, parentheses)
+    # 6. Power (**)
+    # 7. Factor (literals, variables, function calls, parentheses)
     
     # Level 1: Logical OR (lowest precedence)
     # Example: a || b || c
@@ -769,17 +789,28 @@ cfg = {
     # Level 5: Term (multiplication/division/modulo)
     # Example: a * b / c % d
     "<term>": [
-        ["<factor>", "<term_next>"],
+        ["<power>", "<term_next>"],
     ],
 
     "<term_next>": [
-        ["*", "<factor>", "<term_next>"],  # Multiplication
-        ["/", "<factor>", "<term_next>"],  # Division
-        ["%", "<factor>", "<term_next>"],  # Modulo
+        ["*", "<power>", "<term_next>"],  # Multiplication
+        ["/", "<power>", "<term_next>"],  # Division
+        ["%", "<power>", "<term_next>"],  # Modulo
         [EPSILON],                          # End
     ],
 
-    # Level 6: Factor (highest precedence - literals, variables, etc.)
+    # Level 6: Power (right-associative exponentiation)
+    # Example: a ** b ** c
+    "<power>": [
+        ["<factor>", "<power_next>"],
+    ],
+
+    "<power_next>": [
+        ["**", "<power>"],  # Exponentiation
+        [EPSILON],           # End
+    ],
+
+    # Level 7: Factor (highest precedence - literals, variables, etc.)
     "<factor>": [
         ["(", "<paren_expr>"],           # Cast or parenthesized expression
         ["<unary_op>", "<factor>"],      # Unary operation (e.g., ~x, !flag)

Backend/icg.py

@@ -3,6 +3,17 @@
 # ============================================================================
 # Generates three-address code (TAC) from a GAL token stream.
 #
+# IMPORTANT: ICG output is DISPLAY-ONLY. The interpreter (GALinterpreter.py)
+# does NOT consume this output — it walks the AST directly. This module
+# exists so the IDE can show students what intermediate code their GAL
+# program would compile to. Pipeline position:
+#
+#   lex -> parse -> AST -> semantic -> THIS FILE (display) -> interpret(AST)
+#                                       \________________/
+#                                        parallel pass; not on runtime path
+#
+# Called from server.py /api/icg endpoint.
+#
 # The output is a list of TAC instructions (quad-like) that can be further
 # optimised or translated to target code.
 #
@@ -987,15 +998,25 @@ class ICGenerator:
 
     def _term(self) -> str:
         """<term> → <factor> <term_next>"""
-        left = self._factor()
+        left = self._power()
         while self._peek().type in ("*", "/", "%"):
             op = self._advance().type
-            right = self._factor()
+            right = self._power()
             tmp = self._new_temp()
             self._emit(op, left, right, tmp)
             left = tmp
         return left
 
+    def _power(self) -> str:
+        left = self._factor()
+        if self._peek().type == "**":
+            op = self._advance().type
+            right = self._power()
+            tmp = self._new_temp()
+            self._emit(op, left, right, tmp)
+            return tmp
+        return left
+
     def _factor(self) -> str:
         """<factor> → ( <expr> ) | <unary_op> <factor> | id ... | literal"""
         tok = self._peek()

Backend/lexer.py

@@ -323,140 +323,148 @@ class Lexer:
         - tokens: list of Token objects
         - errors: list of LexicalError objects
         """
-        tokens = []  # List to store all tokens found
-        line = 1     # Current line number (for token tracking)
-        errors = []  # List to store all lexical errors found
-        pos = self.pos.copy()  # Initialize pos for EOF handling (avoids crash on empty source)
-        
-        # Main loop: process each character until end of file
-        while self.current_char != None:
-            
+        tokens = []                                                  # accumulator: every recognized Token is appended here
+        line = 1                                                     # running line number (1-indexed for user-facing errors)
+        errors = []                                                  # accumulator: every LexicalError encountered is appended here
+        pos = self.pos.copy()                                        # snapshot of current pos; reused as fallback for EOF token at end
+
+        # Main loop: drive the FSM one character at a time until source is exhausted (current_char becomes None).
+        while self.current_char != None:                             # None sentinel = end of source_code reached
+
             # =====================================================================
             # KEYWORD & IDENTIFIER RECOGNITION
-            # Check if current character starts a keyword or identifier (letter)
+            # Hand-written transition diagram: each branch matches one keyword.
+            # If no keyword path completes, the trailing "else" falls through to
+            # generic identifier scanning at the bottom of this if-block.
             # =====================================================================
-            if self.current_char in ALPHA:
-                ident_str = ''      # String to build the identifier/keyword
-                pos = self.pos.copy()  # Save position for error reporting
-                
+            if self.current_char in ALPHA:                           # only letters can start a keyword/identifier (digits cannot)
+                ident_str = ''                                       # buffer that will hold the lexeme as we walk it character-by-character
+                pos = self.pos.copy()                                # capture starting position so error/Token carries the *first* char's line/col
+
                 # --- Letter B: 'branch', 'bud', 'bundle' ---
-                if self.current_char == "b":
-                    ident_str += self.current_char
-                    self.advance()
-                    if self.current_char == "r": # branch
-                        ident_str += self.current_char
-                        self.advance()
-                        if self.current_char == "a":
-                            ident_str += self.current_char
-                            self.advance()
-                            if self.current_char == "n":
-                                ident_str += self.current_char
-                                self.advance()
-                                if self.current_char == "c":
-                                    ident_str += self.current_char
-                                    self.advance()
-                                    if self.current_char == "h":
-                                        ident_str += self.current_char
-                                        self.advance()
-                                        # Branch keyword recognized - emit token
+                if self.current_char == "b":                         # FSM root for words starting with 'b'
+                    ident_str += self.current_char                   # buffer the 'b'
+                    self.advance()                                   # consume it; current_char now points to the 2nd letter
+                    if self.current_char == "r":                     # 'b'+'r' → potentially "branch"
+                        ident_str += self.current_char               # buffer the 'r'
+                        self.advance()                               # consume 'r'; look at 3rd letter
+                        if self.current_char == "a":                 # 'br'+'a' → still on track for "branch"
+                            ident_str += self.current_char           # buffer the 'a'
+                            self.advance()                           # consume 'a'
+                            if self.current_char == "n":             # 'bra'+'n'
+                                ident_str += self.current_char       # buffer the 'n'
+                                self.advance()                       # consume 'n'
+                                if self.current_char == "c":         # 'bran'+'c'
+                                    ident_str += self.current_char   # buffer the 'c'
+                                    self.advance()                   # consume 'c'
+                                    if self.current_char == "h":     # 'branc'+'h' → full keyword spelled out
+                                        ident_str += self.current_char  # buffer the trailing 'h'
+                                        self.advance()               # consume 'h'; current_char is now whatever comes AFTER "branch"
+                                        # Maximal-munch check: only emit BRANCH token if the next char is a legal delimiter.
+                                        # Otherwise "branchx" must become an identifier, not keyword+identifier.
                                         if self.current_char is None or self.current_char in space_delim or self.current_char == ';':
-                                            tokens.append(Token(TT_RW_BRANCH, ident_str, line, pos.col))
-                                            continue
-                                        elif self.current_char not in ALPHANUM:
-                                            tokens.append(Token(TT_RW_BRANCH, ident_str, line, pos.col))
-                                            continue
-                    elif self.current_char == "u":
-                        ident_str += self.current_char
-                        self.advance()
-                        if self.current_char == "d": # bud
-                            ident_str += self.current_char
-                            self.advance()
+                                            tokens.append(Token(TT_RW_BRANCH, ident_str, line, pos.col))  # emit reserved-word token
+                                            continue                 # restart the outer while loop — do NOT fall through to identifier scan
+                                        elif self.current_char not in ALPHANUM:  # any non-alphanumeric (e.g. '(', '{') also closes the keyword
+                                            tokens.append(Token(TT_RW_BRANCH, ident_str, line, pos.col))  # emit reserved-word token
+                                            continue                 # restart the outer while loop
+                    elif self.current_char == "u":                       # 'b'+'u' → either "bud" or "bundle"
+                        ident_str += self.current_char                   # buffer the 'u'
+                        self.advance()                                   # consume 'u'
+                        if self.current_char == "d":                     # 'bu'+'d' → potentially "bud"
+                            ident_str += self.current_char               # buffer the 'd'
+                            self.advance()                               # consume 'd'; check what follows
+                            # Maximal-munch: "bud" needs whitespace or delim4 ({':', '('}) to terminate.
                             if self.current_char is None or (self.current_char is not None and self.current_char.isspace()) or self.current_char in delim4:
-                                tokens.append(Token(TT_RW_BUD, ident_str, line, pos.col))
-                                continue
+                                tokens.append(Token(TT_RW_BUD, ident_str, line, pos.col))  # emit BUD reserved-word token
+                                continue                                 # restart outer loop on next char
                             elif self.current_char is not None and not self.current_char.isspace() and self.current_char not in delim4 and self.current_char not in ALPHANUM:
+                                # Strict rule: an illegal delimiter after the keyword is a lexical error (not a fallback to identifier).
                                 errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))
-                                self.advance()
-                                continue
-                        elif self.current_char == "n": # bundle
-                            ident_str += self.current_char
-                            self.advance()
-                            if self.current_char == "d":
-                                ident_str += self.current_char
-                                self.advance()
-                                if self.current_char == "l":
-                                    ident_str += self.current_char
-                                    self.advance()
-                                    if self.current_char == "e":
-                                        ident_str += self.current_char
-                                        self.advance()
-                                        if self.current_char is not None and self.current_char in space_delim: # struct delimiter (was hawk_dlm)
-                                            tokens.append(Token(TT_RW_BUNDLE, ident_str, line, pos.col))
-                                            continue
+                                self.advance()                           # skip the bad char so we don't loop forever
+                                continue                                 # back to outer scan
+                        elif self.current_char == "n":                   # 'bu'+'n' → potentially "bundle"
+                            ident_str += self.current_char               # buffer 'n'
+                            self.advance()                               # consume 'n'
+                            if self.current_char == "d":                 # 'bun'+'d'
+                                ident_str += self.current_char           # buffer 'd'
+                                self.advance()                           # consume 'd'
+                                if self.current_char == "l":             # 'bund'+'l'
+                                    ident_str += self.current_char       # buffer 'l'
+                                    self.advance()                       # consume 'l'
+                                    if self.current_char == "e":         # 'bundl'+'e' → "bundle" complete
+                                        ident_str += self.current_char   # buffer trailing 'e'
+                                        self.advance()                   # consume 'e'
+                                        if self.current_char is not None and self.current_char in space_delim:  # bundle requires whitespace next
+                                            tokens.append(Token(TT_RW_BUNDLE, ident_str, line, pos.col))  # emit BUNDLE token
+                                            continue                     # next iteration
                                         elif self.current_char is not None and self.current_char not in space_delim and self.current_char not in ALPHANUM:
+                                            # Anything else (and not a letter that would extend it to an identifier) → illegal delimiter error.
                                             errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))
-                                            self.advance()
-                                            continue
-                
+                                            self.advance()               # skip bad char
+                                            continue                     # restart outer scan
+
                 #Letter C
-                elif self.current_char == "c":
-                    ident_str += self.current_char
-                    self.advance()
-                    if self.current_char == "u": # cultivate
-                        ident_str += self.current_char
-                        self.advance()
-                        if self.current_char == "l":
-                            ident_str += self.current_char
-                            self.advance()
-                            if self.current_char == "t":
-                                ident_str += self.current_char
-                                self.advance()
-                                if self.current_char == "i":
-                                    ident_str += self.current_char
-                                    self.advance()
-                                    if self.current_char == "v":
-                                        ident_str += self.current_char
-                                        self.advance()
-                                        if self.current_char == "a":
-                                            ident_str += self.current_char
-                                            self.advance()
-                                            if self.current_char == "t":
-                                                ident_str += self.current_char
-                                                self.advance()
-                                                if self.current_char == "e":
-                                                    ident_str += self.current_char
-                                                    self.advance()
+                elif self.current_char == "c":                           # FSM root for words starting with 'c' (only "cultivate")
+                    ident_str += self.current_char                       # buffer 'c'
+                    self.advance()                                       # consume 'c'
+                    if self.current_char == "u":                         # 'c'+'u' → on track for "cultivate"
+                        ident_str += self.current_char                   # buffer 'u'
+                        self.advance()                                   # consume 'u'
+                        if self.current_char == "l":                     # 'cu'+'l'
+                            ident_str += self.current_char               # buffer 'l'
+                            self.advance()                               # consume 'l'
+                            if self.current_char == "t":                 # 'cul'+'t'
+                                ident_str += self.current_char           # buffer 't'
+                                self.advance()                           # consume 't'
+                                if self.current_char == "i":             # 'cult'+'i'
+                                    ident_str += self.current_char       # buffer 'i'
+                                    self.advance()                       # consume 'i'
+                                    if self.current_char == "v":         # 'culti'+'v'
+                                        ident_str += self.current_char   # buffer 'v'
+                                        self.advance()                   # consume 'v'
+                                        if self.current_char == "a":     # 'cultiv'+'a'
+                                            ident_str += self.current_char  # buffer 'a'
+                                            self.advance()               # consume 'a'
+                                            if self.current_char == "t": # 'cultiva'+'t'
+                                                ident_str += self.current_char  # buffer 't'
+                                                self.advance()           # consume 't'
+                                                if self.current_char == "e":  # 'cultivat'+'e' → "cultivate" complete
+                                                    ident_str += self.current_char  # buffer trailing 'e'
+                                                    self.advance()       # consume 'e'
+                                                    # cultivate (for-loop) requires whitespace or delim4 ({':', '('}) next.
                                                     if self.current_char is None or (self.current_char is not None and self.current_char.isspace()) or self.current_char in delim4:
-                                                        tokens.append(Token(TT_RW_CULTIVATE, ident_str, line, pos.col))
-                                                        continue
+                                                        tokens.append(Token(TT_RW_CULTIVATE, ident_str, line, pos.col))  # emit CULTIVATE token
+                                                        continue         # next iteration
                                                     elif self.current_char is not None and not self.current_char.isspace() and self.current_char not in delim4 and self.current_char not in ALPHANUM:
-                                                        errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))
-                                                        self.advance()
-                                                        continue
-                
+                                                        errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))  # illegal trailer
+                                                        self.advance()   # skip bad char
+                                                        continue         # restart outer scan
+
                 # Letter E
-                elif self.current_char == "e":
-                    ident_str += self.current_char
-                    self.advance()
-                    if self.current_char == "m": # empty
-                        ident_str += self.current_char
-                        self.advance()
-                        if self.current_char == "p":
-                            ident_str += self.current_char
-                            self.advance()
-                            if self.current_char == "t":
-                                ident_str += self.current_char
-                                self.advance()
-                                if self.current_char == "y":
-                                    ident_str += self.current_char
-                                    self.advance()
+                elif self.current_char == "e":                           # FSM root for 'e' (only "empty")
+                    ident_str += self.current_char                       # buffer 'e'
+                    self.advance()                                       # consume 'e'
+                    if self.current_char == "m":                         # 'e'+'m' → potentially "empty"
+                        ident_str += self.current_char                   # buffer 'm'
+                        self.advance()                                   # consume 'm'
+                        if self.current_char == "p":                     # 'em'+'p'
+                            ident_str += self.current_char               # buffer 'p'
+                            self.advance()                               # consume 'p'
+                            if self.current_char == "t":                 # 'emp'+'t'
+                                ident_str += self.current_char           # buffer 't'
+                                self.advance()                           # consume 't'
+                                if self.current_char == "y":             # 'empt'+'y' → "empty" complete
+                                    ident_str += self.current_char       # buffer trailing 'y'
+                                    self.advance()                       # consume 'y'
+                                    # empty is the void return type; whitespace is a valid delimiter.
                                     if self.current_char is None or (self.current_char is not None and self.current_char.isspace()) or self.current_char in space_delim:
-                                        tokens.append(Token(TT_RW_EMPTY, ident_str, line, pos.col))
-                                        continue
+                                        tokens.append(Token(TT_RW_EMPTY, ident_str, line, pos.col))  # emit EMPTY token
+                                        continue                         # next iteration
                                     elif self.current_char is not None and not self.current_char.isspace() and self.current_char not in space_delim and self.current_char not in ALPHANUM:
-                                        errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))
-                                        self.advance()
-                                        continue
+                                        errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))  # illegal trailer
+                                        self.advance()                   # skip bad char
+                                        continue                         # restart outer scan
 
                 # Letter F
                 elif self.current_char == "f":

Backend/main.js

@@ -1,569 +0,0 @@
-  
-  let fitAddon;
-  document.addEventListener('DOMContentLoaded', async () => {
-
-  // Auto-target Flask backend when running from a different origin (e.g., VS Code Live Server on 5500)
-  const API_BASE = (location.port && location.port !== '5000') ? 'http://localhost:5000' : '';
-
-  // Use same-origin Socket.IO connection for portability (works in Docker and cloud)
-  const socketBase = (location.port && location.port !== '5000') ? 'http://localhost:5000' : undefined;
-  const socket = socketBase ? io(socketBase) : io();
-    let waitingForInput = false;
-    let userInput = '';
-    let inputCallback = null;
-    let variable = '';  // Store the variable name for which we need input
-    let termDataListener = null;
-
-    socket.on('connect', () => {
-        console.log('Socket.IO connected');
-    });
-
-    socket.on('disconnect', () => {
-        console.log('Socket.IO disconnected');
-    });
-    //
-
-
-
-      require.config({ paths: { 'vs': 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.43.0/min/vs',
-          'xterm': 'https://cdn.jsdelivr.net/npm/xterm/lib',
-          'xterm-addon-fit': 'https://cdn.jsdelivr.net/npm/xterm-addon-fit/lib/xterm-addon-fit',
-          
-      } });
-
-  require(['vs/editor/editor.main'], function () {
-
-          monaco.languages.register({ id: "gal" });
-
-          monaco.languages.setMonarchTokensProvider("gal", {
-          tokenizer: {
-              
-              root: [
-                  // GAL basic data types
-                  [/\b(tree|seed|leaf|branch|string)\b/, "type"],
-                  // GAL advanced data types
-                  [/\b(variety|fertile|soil|bundle)\b/, "advancedType"],
-                  // GAL control flow
-                  [/\b(plant|harvest|grow|prune|graft|water|sow|root|sprout|bud|cultivate|tend|skip|reclaim|pollinate)\b/, "control"],
-                  // GAL boolean values
-                  [/\b(sunshine|frost|tr|fs|empty)\b/, "boolean"],
-                  // GAL I/O functions
-                  [/\b(bloom|wither|spring)\b/, "io"],
-                  // Comments
-                  [/\/\/.*/, "comment"],
-                  [/#.*/, "comment"],
-                  [/\/\*/, 'comment', '@comment'],
-                  // Numbers (integers and decimals)
-                  [/\d+\.\d+/, "number"],
-                  [/\d+/, "number"],
-                  // Strings
-                  [/"[^"]*"/, "string"],
-                  // Characters
-                  [/'.'/, "character"],
-                  // Operators
-                  [/[+\-*/%<>=!&|~]+/, "operator"],
-                  // Function calls
-                  [/\b[a-zA-Z_]\w*(?=\()/, "functionIdentifier"],
-                  // Identifiers
-                  [/\b[a-zA-Z_]\w*\b/, "identifier"],
-                  // Brackets and braces
-                  [/[\{\}]/, "braces"],
-                  [/[\[\]]/, "bracket"],
-                  [/[\(\)]/, "parenthesis"],
-              ],
-
-              comment: [
-              [/[^*]+/, 'comment'],
-              [/\*\//, 'comment', '@pop'],
-              [/\*/, 'comment'],
-              ],
-          },
-      });
-
-      monaco.languages.setLanguageConfiguration("gal", {
-          comments: {
-              blockComment: ["/*", "*/"],
-              lineComment: "//"          
-          },
-          autoClosingPairs: [
-            { open: '{', close: '}' },
-            { open: '[', close: ']' },
-            { open: '(', close: ')' },
-            { open: '"', close: '"'},
-            { open: "'", close: "'"},
-            { open: '/*', close: '*/'},
-          ],
-      });
-      
-      monaco.editor.defineTheme("galTheme", {
-      base: "vs-dark",
-      inherit: true,
-      rules: [
-        { token: "type", foreground: "#89CFF0", fontStyle: "bold"},
-        { token: "advancedType", foreground: "#D4A5FF", fontStyle: "bold"},
-        { token: "control", foreground: "#FFD36E", fontStyle: "bold"},
-        { token: "io", foreground: "#FF8A5B"},
-        { token: "boolean", foreground: "#B6FF85"},
-        { token: "number", foreground: "#FFE7AF"},
-        { token: "string", foreground: "#A6E3A1"},
-        { token: "character", foreground: "#A6E3A1"},
-        { token: "operator", foreground: "#F2FFEF"},
-        { token: "identifier", foreground: "#E0FFD9"},
-        { token: "functionIdentifier", foreground: "#FF8A5B", fontStyle: "bold"},
-        { token: "braces", foreground: "#7CD26F"},
-        { token: "bracket", foreground: "#7CD26F"},
-        { token: "parenthesis", foreground: "#F2FFEF"},
-        { token: "comment", foreground: "#6D8F74", fontStyle: "italic" },
-      ],
-        colors: {
-          "editor.foreground": "#F2FFEF",
-          "editor.background": "#18361D",
-          "editorCursor.foreground": "#F2FFEF",
-          "editor.lineHighlightBackground": "#204B27",
-          "editorLineNumber.foreground": "#A6C3A9",
-          "editorindentGuide.background": "#2A5A35",
-          "editorindentGuide.activebackground": "#3A7D4A",
-          "scrollbarSlider.background": "#0F2014",
-          "scrollbarSlider.hoverBackground": "#15301E",
-          "scrollbarSlider.activeBackground": "#224B2B"
-        }
-      });
-
-      window.editor = monaco.editor.create(document.getElementById('editor'), {
-        value: `root(){\n\t// your code here\n\t\n}`,
-              language: 'gal',
-              theme: 'galTheme',
-              minimap: { enabled: false },
-              overviewRulerLanes: 0,
-              automaticLayout: true,
-              newLineCharacter: "\n",
-              suggest: {
-                  filterGraceful: false,
-                  showWords: false,
-                  enabled: false,
-              },
-              scrollbar: {
-                  vertical: "auto",
-                  horizontal: "auto",
-                  alwaysConsumeMouseWheel: false,
-                  verticalScrollbarSize: 10,
-                  horizontalScrollbarSize: 10,
-              },
-              // Mobile optimizations
-              quickSuggestions: false,
-              parameterHints: { enabled: false },
-              codeLens: false,
-              folding: false,
-              lineDecorationsWidth: 0,
-              lineNumbersMinChars: 3,
-              renderLineHighlight: 'line',
-              occurrencesHighlight: false,
-              selectionHighlight: false,
-              renderValidationDecorations: 'off',
-          });
-
-          // Add line highlighting on click
-          let currentLineDecorations = [];
-          editor.onDidChangeCursorPosition((e) => {
-            const lineNumber = e.position.lineNumber;
-            // Highlight the current line
-            currentLineDecorations = editor.deltaDecorations(currentLineDecorations, [
-              {
-                range: new monaco.Range(lineNumber, 1, lineNumber, 1),
-                options: {
-                  isWholeLine: true,
-                  className: 'current-line-highlight',
-                  glyphMarginClassName: 'current-line-glyph'
-                }
-              }
-            ]);
-          });
-
-          // (reverted) no status bar cursor updates
-      });
-      
-  require(['vs/editor/editor.main', 'xterm/xterm', 'xterm-addon-fit'], function (_, Xterm, FitAddon) {
-
-          const term = new Xterm.Terminal({
-            cursorBlink: true,
-            cursorStyle: 'bar',
-            scrollback: 5000,
-            rows: 20,
-            
-            theme: {
-              background: '#102417',
-              foreground: '#f2ffef',
-              cursor: '#f2ffef',
-              FontFace: 'monospace',
-              fontStyle: 'bold',
-            },
-          });
-          
-          fitAddon = new FitAddon.FitAddon();
-          term.loadAddon(fitAddon);
-      
-          term.open(document.getElementById('terminal'));
-          
-          setTimeout(() => term.focus(), 100);
-          term.write('Terminal Ready\r\n');
-
-          fitAddon.fit();
-        
-          window.addEventListener('resize', () => {
-            fitAddon.fit();
-          });
-
-          // HUD removed: no coins/energy UI
-
-          // Toolbar buttons
-          const btnRun = document.getElementById('btn-run');
-          const btnLex = document.getElementById('btn-lex');
-          const btnClear = document.getElementById('btn-clear');
-          // Removed Run/Lexical toolbar bindings per UI update
-          btnClear && btnClear.addEventListener('click', () => {
-            term.clear();
-            const tbody = document.getElementById('tokenBody');
-            if (tbody) tbody.innerHTML = '';
-            const tbodySide = document.getElementById('tokenBodySide');
-            if (tbodySide) tbodySide.innerHTML = '';
-            ['status-lex','status-syn','status-sem','status-exe'].forEach(id => {
-              const el = document.getElementById(id);
-              if (el){ el.classList.remove('ok','err'); el.textContent = el.textContent.replace(/:.*/, ': —'); }
-            });
-          });
-
-          // Terminal header actions
-          let autoScroll = true;
-          const autoBtn = document.getElementById('term-autoscroll');
-          const copyBtn = document.getElementById('term-copy');
-          const clearBtn = document.getElementById('term-clear');
-          const toggleMobileLexBtn = document.getElementById('toggle-mobile-lexemes-nav');
-
-          if (autoBtn) {
-            autoBtn.setAttribute('aria-pressed', 'true');
-            autoBtn.addEventListener('click', () => {
-              autoScroll = !autoScroll;
-              autoBtn.setAttribute('aria-pressed', String(autoScroll));
-            });
-          }
-
-          if (copyBtn) {
-            copyBtn.addEventListener('click', async () => {
-              try {
-                const buffer = term.buffer.active;
-                let text = '';
-                for (let i = 0; i < buffer.length; i++) {
-                  const line = buffer.getLine(i);
-                  if (line) text += line.translateToString() + '\n';
-                }
-                await navigator.clipboard.writeText(text);
-              } catch (e) {
-                console.warn('Copy failed:', e);
-              }
-            });
-          }
-
-          if (clearBtn) {
-            clearBtn.addEventListener('click', () => term.clear());
-          }
-
-          // Mobile lexeme table toggle (navbar button)
-          if (toggleMobileLexBtn) {
-            const mobileTokensSection = document.querySelector('.mobile-tokens');
-            const backdrop = document.getElementById('mobile-tokens-backdrop');
-            const toggleIcon = document.getElementById('lexeme-toggle-icon');
-            const closeBtn = document.getElementById('mobile-tokens-close');
-            
-            const closeLexemeTable = () => {
-              if (mobileTokensSection) mobileTokensSection.classList.remove('show');
-              if (backdrop) backdrop.classList.remove('show');
-              if (toggleMobileLexBtn) toggleMobileLexBtn.setAttribute('aria-expanded', 'false');
-              if (toggleIcon) toggleIcon.textContent = '▼';
-            };
-            
-            toggleMobileLexBtn.addEventListener('click', () => {
-              if (!mobileTokensSection) return;
-              
-              const isShowing = mobileTokensSection.classList.toggle('show');
-              if (backdrop) backdrop.classList.toggle('show', isShowing);
-              
-              toggleMobileLexBtn.setAttribute('aria-expanded', String(isShowing));
-              if (toggleIcon) {
-                toggleIcon.textContent = isShowing ? '▲' : '▼';
-              }
-            });
-            
-            // Close when clicking close button
-            if (closeBtn) {
-              closeBtn.addEventListener('click', closeLexemeTable);
-            }
-            
-            // Close when clicking backdrop
-            if (backdrop) {
-              backdrop.addEventListener('click', closeLexemeTable);
-            }
-          }
-
-
-  window.runLexer = async function (options = {}) {
-      const silent = options.silent === true;
-      const sourceCode = editor.getValue();
-      console.log("Running lexer with source code:", sourceCode);
-    if (!silent) {
-      // Separate runs with a blank line
-      term.write('\r\n');
-    }
-          
-              try {
-          const response = await fetch(`${API_BASE}/api/lex`, {
-                      method: 'POST',
-                      headers: { 'Content-Type': 'application/json' },
-                      body: JSON.stringify({ source_code: sourceCode })
-                  });
-          
-                  if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-          
-                  const data = await response.json();
-                  console.log("Lexer response:", data);
-          
-                  const tokensTableBody = document.getElementById('tokenBody');
-                  tokensTableBody.innerHTML = '';
-                  const tokensTableBodySide = document.getElementById('tokenBodySide');
-                  if (tokensTableBodySide) tokensTableBodySide.innerHTML = '';
-                  const tokensTableBodyMobile = document.getElementById('tokenBodyMobile');
-                  if (tokensTableBodyMobile) tokensTableBodyMobile.innerHTML = '';
-
-                  // Map backend token types to display names (Token column)
-                  const displayType = (tok) => {
-                    // For identifiers, show the actual identifier name
-                    if (tok.type === 'idf' || tok.type === 'id' || tok.type === 'TT_IDENTIFIER') {
-                      return tok.value || 'id';
-                    }
-
-                    // For literals, show the actual literal value
-                    const literalTypes = new Set(['intlit','dbllit','strnglit','chrlit','TT_INTEGERLIT','TT_DOUBLELIT','TT_STRINGLIT','TT_CHARLIT','seedlit','treelit','leaflit']);
-                    if (literalTypes.has(tok.type)) return tok.value != null ? String(tok.value) : '';
-
-                    // Boolean literals: sunshine and frost show their keyword as token
-                    if (tok.type === 'sunshine') return 'sunshine';
-                    if (tok.type === 'frost') return 'frost';
-
-                    // Reserved words are their type directly
-                    const kwSet = new Set(['water','plant','seed','leaf','branch','tree','spring','wither','bud','harvest','grow','cultivate','tend','empty','prune','skip','reclaim','root','pollinate','variety','fertile','soil','bundle','string']);
-                    if (kwSet.has(tok.type)) return tok.type;
-
-                    // Show symbols in the Token column as the actual symbol
-                    const SYMBOLS = new Set(['+','-','*','/','%','=','==','===','+=','-=','*=','/=','%=','<','>','<=','>=','!=','&&','&','||','|','!','++','--','~','`','(',')','{','}','[',']',',',';',';',':','.']);
-                    if (tok && typeof tok.value === 'string' && SYMBOLS.has(tok.value)) return tok.value;
-                    if (tok && typeof tok.type === 'string' && SYMBOLS.has(tok.type)) return tok.type;
-
-                    // Fallback for any other token types from old or new lexer
-                    if (tok.type && tok.type.startsWith('TT_')) {
-                      // If value looks like a symbol, prefer it
-                      if (typeof tok.value === 'string' && SYMBOLS.has(tok.value)) return tok.value;
-                      return tok.type.substring(3).toLowerCase();
-                    }
-                    return tok.type || '';
-                  };
-
-                  // Determine token classification (Type column)
-                  const RESERVED = new Set([
-                    'water','plant','seed','leaf','branch','tree','spring','wither','bud','harvest','grow','cultivate','tend','empty','prune','skip','reclaim','root','pollinate','variety','fertile','soil','bundle','string'
-                  ]);
-                  const SYMBOLS = new Set(['+','-','*','/','%','=','==','===','+=','-=','*=','/=','%=','<','>','<=','>=','!=','&&','&','||','|','!','++','--','~','`','(',')','{','}','[',']',',',';',';',':','.']);
-                  const symbolTypeName = (sym) => {
-                    if (sym === '{') return 'R_Curly';
-                    if (sym === '}') return 'L_Curly';
-                    if (sym === '(') return 'L_Paren';
-                    if (sym === ')') return 'R_Paren';
-                    if (sym === '[') return 'L_Brkt';
-                    if (sym === ']') return 'R_Brkt';
-                    if (sym === ',') return 'Comma';
-                    if (sym === ';') return 'Semi_c';
-                    if (sym === ':') return 'Colon';
-                    if (sym === '.') return 'Dot';
-                    return '';
-                  };
-                  const classifyType = (tok) => {
-                    const t = tok.type || '';
-                    // Keep only these categories in Type column
-                    if (RESERVED.has(t)) return 'RW';
-                    if (t === 'idf' || t === 'id' || t === 'TT_IDENTIFIER') return 'ID';
-                    if (t === 'intlit' || t === 'TT_INTEGERLIT') return 'integer';
-                    if (t === 'dbllit' || t === 'TT_DOUBLELIT' || t === 'treelit') return 'double';
-                    if (t === 'strnglit' || t === 'TT_STRINGLIT') return 'string';
-                    if (t === 'chrlit' || t === 'TT_CHARLIT') return 'character';
-                    // Boolean literals
-                    if (t === 'sunshine' || t === 'frost') return 'false';
-                    // Operators are labeled 'operator'
-                    const OPS = new Set(['+','-','*','/','%','=','==','===','+=','-=','*=','/=','%=','<','>','<=','>=','!=','&&','&','||','|','!','++','--','~','`']);
-                    const lex = (tok.value == null ? '' : String(tok.value));
-                    if (OPS.has(lex) || OPS.has(t)) return 'operator';
-                    // Symbols like braces/parens get specific names
-                    if (SYMBOLS.has(lex)) return symbolTypeName(lex);
-                    if (SYMBOLS.has(t)) return symbolTypeName(t);
-                    // Everything else (operators etc.) blank
-                    return '';
-                  };
-          
-                  // Filter out tokens we don't want displayed in the lexeme tables
-                  const visibleTokens = (data.tokens || []).filter(t => t && t.type !== 'TT_NL' && t.type !== 'TT_EOF' && t.type !== 'EOF');
-                  visibleTokens.forEach(token => {
-                      const tDisp = displayType(token);   // Token column
-                      const vDisp = token.value == null ? '' : String(token.value); // Lexeme column
-                      const cDisp = classifyType(token);  // Token Type column
-
-                      const row = tokensTableBody.insertRow();
-                      row.insertCell(0).textContent = vDisp;
-                      row.insertCell(1).textContent = tDisp;
-                      row.insertCell(2).textContent = cDisp;
-
-                      if (tokensTableBodySide){
-                        const r = tokensTableBodySide.insertRow();
-                        r.insertCell(0).textContent = vDisp;
-                        r.insertCell(1).textContent = tDisp;
-                        r.insertCell(2).textContent = cDisp;
-                      }
-
-                      if (tokensTableBodyMobile){
-                        const m = tokensTableBodyMobile.insertRow();
-                        m.insertCell(0).textContent = vDisp;
-                        m.insertCell(1).textContent = tDisp;
-                        m.insertCell(2).textContent = cDisp;
-                      }
-                  });
-
-                  // No table content mirrored to terminal output
-          
-  if (data.errors.length > 0) {
-            if (!silent) {
-            data.errors.forEach(err => {
-              term.write(`${err}\r\n`);
-            });
-            }
-            const sl = document.getElementById('status-lex');
-            if (sl){ sl.classList.remove('ok'); sl.classList.add('err'); sl.textContent = 'Lexical: Error'; }
-      } else {
-            if (!silent) term.write('Lexical analysis successful!\r\n');
-            const sl = document.getElementById('status-lex');
-            if (sl){ sl.classList.remove('err'); sl.classList.add('ok'); sl.textContent = 'Lexical: OK'; }
-    return true;
-                  }
-          
-              } catch (error) {
-          console.error("Error running lexical analysis:", error);
-          if (!silent) term.write('Error running lexical analysis.\r\n');
-                  return false;
-              }
-          };
-
-          // Syntax analysis removed; only lexical phase retained.
-          
-          
-        socket.on('output', function (data) {
-            const lines = data.output.split('\n');
-            lines.forEach((line, index) => {
-              term.write(line);
-              // Only add newline if not the last line or if the original ended with newline
-              if (index < lines.length - 1 || data.output.endsWith('\n')) {
-                term.write('\r\n');
-              }
-            });
-      if (autoScroll) term.scrollToBottom();
-            term.focus(); 
-        });
-          
-        socket.on('input_required', function (data) {
-            const prompt = data.prompt;
-            variable = data.variable;
-    
-
-            waitingForInput = true;
-            userInput = '';  
-
-            if (termDataListener) {
-              term.offData(termDataListener);
-            }
-            
-            const inputStartPosition = term.cols;
-
-            termDataListener = function (e) {
-              if (!waitingForInput) return;
-
-              if (e === '\x1b[A' || e === '\x1b[B' || e === '\x1b[C' || e === '\x1b[D') {
-                return;
-              }
-
-              if (e === '\r') {
-                term.write('\r\n');
-                waitingForInput = false;
-                socket.emit('capture_input', { var_name: variable, input: userInput });
-                userInput = '';
-              } else if (e === '\u007f') {
-                if (userInput.length > 0) {
-                    userInput = userInput.slice(0, -1); 
-                    term.write('\b \b');
-                }
-              } else {
-                userInput += e;
-                term.write(e);
-              }
-
-              
-          };
-  
-          term.onData(termDataListener);
-        });
-
-          
-      window.runCode = async function () {
-        // Run lexical analysis (same as Lexical button)
-        await runLexer({ silent: false });
-      };
-        });
-
-  });
-  
-  
-  document.querySelector(".widthResizer").addEventListener("mousedown", (e) => {
-      e.preventDefault();
-      document.addEventListener("mousemove", widthResize);
-      document.addEventListener("mouseup", () => {
-          document.removeEventListener("mousemove", widthResize);
-      }, { once: true });
-  });
-
-  function widthResize(e) {
-      let newWidth = e.clientX - document.querySelector(".textFieldCont").getBoundingClientRect().left;
-      document.querySelector(".textFieldCont").style.width = `${newWidth}px`;
-  }
-
-  function toggleDropdown() {
-      const menu = document.getElementById("dropdown-menu");
-      menu.classList.toggle("hidden");
-    }
-    
-
-    
-    // Hide dropdown if clicked outside
-    document.addEventListener("click", function (e) {
-      const dropdown = document.querySelector(".dropdown");
-      const menu = document.getElementById("dropdown-menu");
-    
-      if (!dropdown.contains(e.target)) {
-        menu.classList.add("hidden");
-      }
-    });
-
-    // Auto-lex on typing (debounced) to keep sidebar tokens in sync with GALalexer rules
-    function debounce(fn, wait){
-      let t; return function(...args){ clearTimeout(t); t = setTimeout(() => fn.apply(this, args), wait); };
-    }
-    const debouncedLex = debounce(() => window.runLexer({ silent: true }), 400);
-    if (window.editor && editor.onDidChangeModelContent){
-      editor.onDidChangeModelContent(() => {
-        debouncedLex();
-      });
-    }
-
-

Backend/server.py

@@ -1,22 +1,49 @@
+# ============================================================================
+# GAL COMPILER SERVER - HTTP + WebSocket entry point
+# ============================================================================
+# This is the orchestrator of the entire compiler. It exposes Flask routes
+# for each compiler stage (lex / parse / semantic / icg / run) and Socket.IO
+# events for interactive program execution. Every request flows through:
+#
+#     source code -> lexer -> parser+AST -> semantic -> ICG -> interpreter
+#
+# Each stage short-circuits on failure so the user sees the FIRST stage that
+# rejected their code, not a flood of cascading errors.
+# ============================================================================
+
+# ============================================================================
+# WARNING SUPPRESSION + EVENTLET BOOTSTRAP
+# Eventlet provides cooperative concurrency so Socket.IO can park a request
+# (e.g. waiting on water() input) without blocking the whole server.
+# monkey_patch() must run BEFORE flask/socketio are imported.
+# ============================================================================
 import warnings
 warnings.filterwarnings("ignore", message=".*RLock.*were not greened.*")
 
 import eventlet
 eventlet.monkey_patch()
 
+# ============================================================================
+# IMPORTS - Flask web framework + every layer of the GAL compiler
+# ============================================================================
 from flask import Flask, request, jsonify, send_from_directory
 from flask_cors import CORS
 from flask_socketio import SocketIO, emit
 import os
-from google import genai
-from lexer import lex, get_token_description
-from Gal_Parser import LL1Parser
-from cfg import cfg, first_sets, predict_sets
-from GALsemantic import analyze_semantics, validate_ast
-from icg import generate_icg
-from GALinterpreter import Interpreter, InterpreterError, _CancelledError
-from gal_fallback import fallback_reply
-
+from google import genai                                       # AI chat helper (optional)
+from lexer import lex, get_token_description                   # Stage 1: Lexical
+from Gal_Parser import LL1Parser                               # Stage 2: Syntax (LL(1))
+from cfg import cfg, first_sets, predict_sets                  # Grammar + parse table
+from GALsemantic import analyze_semantics, validate_ast        # Stage 3: Semantic
+from icg import generate_icg                                   # Stage 4: ICG (display)
+from GALinterpreter import Interpreter, InterpreterError, _CancelledError  # Stage 5: Run
+from gal_fallback import fallback_reply                        # Rule-based AI fallback
+
+
+# ============================================================================
+# DISPLAY HELPER - Escapes control characters so token values are safe
+# to embed in JSON responses for the IDE's lexeme table.
+# ============================================================================
 def _display_value(val):
     """Escape special chars in token values for safe display (like C's repr)."""
     if val is None:
@@ -27,33 +54,52 @@ def _display_value(val):
     s = s.replace('\r', '\\r')
     return s
 
+
+# ============================================================================
+# FLASK APP INITIALIZATION
+# ============================================================================
 app = Flask(__name__, static_folder='../UI', static_url_path='')
-CORS(app)
-socketio = SocketIO(app, cors_allowed_origins="*")
+CORS(app)                                                       # Allow browser frontend on any origin (dev)
+socketio = SocketIO(app, cors_allowed_origins="*")              # WebSocket layer for live program execution
 
-# Store interpreter instances per session for input handling
+# Per-session interpreter registry (sid -> Interpreter instance).
+# One user can only have one program running at a time; new runs cancel the old.
 interpreters = {}
 
 
+# ============================================================================
+# SESSION EMITTER - Routes interpreter output to the originating browser
+# session instead of broadcasting to every connected client.
+# ============================================================================
 class SessionEmitter:
     """Wrapper around SocketIO that always emits to a specific client session."""
     def __init__(self, sio, sid):
-        self._sio = sio
-        self._sid = sid
+        self._sio = sio                                         # the global SocketIO instance
+        self._sid = sid                                         # this client's session ID
 
     def emit(self, event, data=None, **kwargs):
+        # Always 'to=sid' so output goes to one user, never broadcast
         self._sio.emit(event, data, to=self._sid, **kwargs)
 
-# Initialize the parser once at startup
+
+# ============================================================================
+# PARSER SINGLETON - Built once at startup; the LL(1) parser is stateless
+# across calls so this instance is shared by every request.
+# ============================================================================
 parser = LL1Parser(
-    cfg=cfg,
-    predict_sets=predict_sets,
-    first_sets=first_sets,
-    start_symbol="<program>",
-    end_marker="EOF",
-    skip_token_types={'\n'}  # Skip newline tokens
+    cfg=cfg,                            # Grammar productions
+    predict_sets=predict_sets,          # Pre-computed parse table
+    first_sets=first_sets,              # FIRST sets (for error recovery hints)
+    start_symbol="<program>",           # Top of the GAL grammar
+    end_marker="EOF",                   # Matches the synthetic EOF token from the lexer
+    skip_token_types={'\n'}             # Newlines are filtered before the parser sees them
 )
 
+# ============================================================================
+# STATIC FILE SERVING - Serves the IDE's HTML/CSS/JS/images so the whole app
+# works as a single deployable. The no-cache header prevents stale UI during
+# development.
+# ============================================================================
 @app.after_request
 def add_no_cache(response):
     """Prevent browser from caching static files during development."""
@@ -77,6 +123,12 @@ def serve_static(path):
     """Serve static files (CSS, JS, etc.) from UI folder"""
     return send_from_directory('../UI', path)
 
+
+# ============================================================================
+# API ENDPOINT: /api/lex  - LEXICAL ANALYSIS (stage 1 only)
+# Returns the token stream and any lexical errors. Used by the IDE's
+# "Lexemes" tab to display the token table.
+# ============================================================================
 @app.route('/api/lex', methods=['POST'])
 def lexer_endpoint():
     """
@@ -118,6 +170,12 @@ def lexer_endpoint():
             'error': f'Server error: {str(e)}'
         }), 500
 
+# ============================================================================
+# API ENDPOINT: /api/parse  - LEX + SYNTAX ANALYSIS
+# Runs the lexer and (only if no lex errors) the LL(1) parser.
+# Short-circuits at the first failing stage and labels the response with
+# the failing stage so the IDE can highlight the right phase indicator.
+# ============================================================================
 @app.route('/api/parse', methods=['POST'])
 def parser_endpoint():
     """
@@ -181,6 +239,9 @@ def parser_endpoint():
             'error': f'Server error: {str(e)}'
         }), 500
 
+# ============================================================================
+# API ENDPOINT: /api/health  - liveness check (used by deployment tools)
+# ============================================================================
 @app.route('/api/health', methods=['GET'])
 def health_check():
     """Health check endpoint"""
@@ -189,6 +250,13 @@ def health_check():
         'message': 'GAL Compiler Server is running'
     })
 
+
+# ============================================================================
+# API ENDPOINT: /api/semantic  - LEX + PARSE + AST + SEMANTIC ANALYSIS
+# Uses the parser's two-step API: parse_and_build (syntax + AST construction)
+# then validate_ast (tree-walking semantic checks). Distinguishes between
+# 'syntax' and 'semantic' error stages even though both come from the parser.
+# ============================================================================
 @app.route('/api/semantic', methods=['POST'])
 def semantic_endpoint():
     """
@@ -262,6 +330,12 @@ def semantic_endpoint():
             'error': f'Server error: {str(e)}'
         }), 500
 
+# ============================================================================
+# API ENDPOINT: /api/icg  - LEX + PARSE + SEMANTIC + ICG (display only)
+# ICG produces three-address code (TAC) for the IDE's "Intermediate Code"
+# tab. The interpreter does NOT consume this output; it walks the AST directly.
+# So ICG is a teaching/visualization layer, not a runtime layer.
+# ============================================================================
 @app.route('/api/icg', methods=['POST'])
 def icg_endpoint():
     """
@@ -342,26 +416,41 @@ def icg_endpoint():
         }), 500
 
 
-# ─── REST endpoint for program execution (no Socket.IO needed) ────
+# ============================================================================
+# SYNCHRONOUS EXECUTION (no Socket.IO required)
+#
+# OutputCollector is an adapter — same .emit() interface as SessionEmitter,
+# but instead of streaming output via WebSocket it captures it in a list.
+# This is the adapter pattern: one Interpreter class, two delivery modes.
+# ============================================================================
 
 class OutputCollector:
     """Drop-in replacement for SessionEmitter that collects output in a list."""
     def __init__(self):
-        self.outputs = []
-        self.needs_input = False
+        self.outputs = []                 # Accumulated plant() output strings
+        self.needs_input = False          # Flips to True if program calls water()
 
     def emit(self, event, data=None, **kwargs):
         if event == 'output' and data:
+            # Accumulate normal plant() output
             self.outputs.append(data.get('output', ''))
         elif event == 'input_required':
+            # No interactive channel here -> abort the interpreter so the
+            # client can switch to the Socket.IO flow that supports input.
             self.needs_input = True
-            raise _InputNeeded()  # Abort interpreter when input is needed
+            raise _InputNeeded()
 
 
 class _InputNeeded(Exception):
     """Raised by OutputCollector to abort REST execution when water() is called."""
     pass
 
+
+# ============================================================================
+# API ENDPOINT: /api/run  - One-shot execution returning all output at once.
+# Used for non-interactive programs (no water() calls). For interactive runs,
+# the client uses the Socket.IO 'run_code' event below.
+# ============================================================================
 @app.route('/api/run', methods=['POST'])
 def run_endpoint():
     """Run a GAL program synchronously and return all output."""
@@ -446,14 +535,22 @@ def run_endpoint():
         return jsonify({'error': f'Server error: {str(e)}'}), 500
 
 
-# ─── Socket.IO events for program execution ───────────────────────
+# ============================================================================
+# SOCKET.IO INTERACTIVE EXECUTION
+#
+# This path supports water() input. The interpreter runs in a green thread
+# (eventlet) so it can park while waiting for input without blocking the
+# server. Output is streamed back via 'output' events as plant() fires.
+# ============================================================================
 
 @socketio.on('connect')
 def handle_connect():
+    # No setup needed — interpreter is created lazily on first 'run_code'.
     pass
 
 @socketio.on('disconnect')
 def handle_disconnect():
+    # Drop the user's interpreter so memory doesn't leak across reconnects.
     sid = request.sid
     interpreters.pop(sid, None)
 
@@ -543,6 +640,11 @@ def handle_run_code(data):
 
     socketio.start_background_task(run_interpreter)
 
+# ============================================================================
+# SOCKET.IO INPUT CHANNEL - When a running program calls water(), the
+# interpreter parks on an event. The frontend prompts the user, sends back
+# 'capture_input', and this handler routes the value to the right interpreter.
+# ============================================================================
 @socketio.on('capture_input')
 def handle_capture_input(data):
     """Receive input from the client and forward to the waiting interpreter."""
@@ -551,11 +653,18 @@ def handle_capture_input(data):
     if interp:
         var_name = data.get('var_name', '')
         input_value = data.get('input', '')
+        # Unblock the parked interpreter so execution resumes
         interp.provide_input(var_name, input_value)
 
 
-# ─── AI Chat Helper (Google Gemini) ─────────────────────────────
+# ============================================================================
+# AI CHAT HELPER (Google Gemini)
+# Optional learning aid — answers user questions about GAL syntax. Falls
+# back to a rule-based reply if no GEMINI_API_KEY is set or the API fails.
+# This is NOT part of the compiler pipeline.
+# ============================================================================
 
+# Load the system prompt that teaches Gemini how to talk about GAL
 _prompt_path = os.path.join(os.path.dirname(__file__), 'gal_prompt.txt')
 with open(_prompt_path, 'r', encoding='utf-8') as _f:
     GAL_SYSTEM_PROMPT = _f.read()
@@ -659,10 +768,16 @@ def chat_clear_endpoint():
     return jsonify({'success': True})
 
 
+# ============================================================================
+# SERVER STARTUP - Reads PORT/DEBUG env vars, prints a banner listing every
+# endpoint, then hands the app to eventlet's WSGI server.
+# host='0.0.0.0' makes the server reachable from any network interface,
+# not just localhost.
+# ============================================================================
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 5000))
     debug = os.environ.get('DEBUG', 'False') != 'True'
-    
+
     print("Starting GAL Compiler Server...")
     print(f"Server running at http://0.0.0.0:{port}")
     print("API endpoints:")
@@ -672,4 +787,5 @@ if __name__ == '__main__':
     print(f"  - POST http://localhost:{port}/api/icg (Intermediate Code Generation)")
     print(f"  - POST http://localhost:{port}/api/chat (AI Chat Helper)")
     print(f"  - Socket.IO: run_code (Execute Program)")
+    # allow_unsafe_werkzeug=True is needed when running inside eventlet during dev
     socketio.run(app, host='0.0.0.0', port=port, debug=debug, allow_unsafe_werkzeug=True)

Backend/test_array_param.py

@@ -1,45 +0,0 @@
-"""Quick test for array parameter passing feature."""
-from lexer import Lexer
-from Gal_Parser import LL1Parser
-from GALsemantic import build_ast
-from GALinterpreter import Interpreter
-from cfg import cfg, first_sets, predict_sets
-
-code = '''
-pollinate empty printEl(seed arr[], seed i) {
-    plant("{} ", arr[i]) ;
-    reclaim ;
-}
-
-root() {
-    seed nums[3] ;
-    nums[0] = 10 ;
-    nums[1] = 20 ;
-    nums[2] = 30 ;
-    printEl(nums, 0) ;
-    printEl(nums, 1) ;
-    printEl(nums, 2) ;
-    reclaim ;
-}
-'''
-
-# Lexer
-lexer = Lexer(code)
-tokens, lex_errors = lexer.make_tokens()
-print("Lex OK:", len(tokens), "tokens, errors:", lex_errors)
-
-# Parser
-parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
-errors = parser.parse(tokens)
-print("Parse errors:", errors)
-
-# Semantic + AST
-filtered = [t for t in tokens if t.type != '\n']
-ast = build_ast(filtered)
-print("Semantic + AST OK")
-
-# Interpreter — patch plant() since no Socket.IO in test
-interp = Interpreter()
-interp.plant = lambda value: print(value, end="")
-interp.interpret(ast)
-print("\nDone")

Backend/test_curly_init.py

@@ -1,41 +0,0 @@
-"""Test array initialization with curly brace syntax: seed nums[3] = {10, 20, 30}"""
-from lexer import Lexer
-from Gal_Parser import LL1Parser
-from GALsemantic import build_ast
-from GALinterpreter import Interpreter
-from cfg import cfg, first_sets, predict_sets
-
-code = '''
-pollinate empty printArr(seed arr[], seed n, seed i) {
-    spring(i >= n) {
-        reclaim ;
-    }
-    plant("{}  ", arr[i]) ;
-    printArr(arr, n, i + 1) ;
-    reclaim ;
-}
-
-root() {
-    seed nums[3] = {10, 20, 30} ;
-    printArr(nums, 3, 0) ;
-    reclaim ;
-}
-'''
-
-lexer = Lexer(code)
-tokens, lex_errors = lexer.make_tokens()
-print("Lex:", len(tokens), "tokens, errors:", lex_errors)
-
-parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
-errors = parser.parse(tokens)
-print("Parse:", errors)
-
-filtered = [t for t in tokens if t.type != '\n']
-ast = build_ast(filtered)
-print("Semantic OK")
-
-interp = Interpreter()
-interp.plant = lambda value: print(value, end="")
-interp.interpret(ast)
-print()
-print("Done")

Backend/test_mp16.py

@@ -1,77 +0,0 @@
-"""Test MP16: Array print + sort with recursion using array parameter passing."""
-from lexer import Lexer
-from Gal_Parser import LL1Parser
-from GALsemantic import build_ast
-from GALinterpreter import Interpreter
-from cfg import cfg, first_sets, predict_sets
-
-code = '''
-pollinate empty printArr(seed arr[], seed n, seed i) {
-    spring(i >= n) {
-        reclaim ;
-    }
-    plant("{}  ", arr[i]) ;
-    printArr(arr, n, i + 1) ;
-    reclaim ;
-}
-
-pollinate empty bubblePass(seed arr[], seed n, seed i) {
-    spring(i >= n - 1) {
-        reclaim ;
-    }
-    spring(arr[i] > arr[i + 1]) {
-        seed temp = arr[i] ;
-        arr[i] = arr[i + 1] ;
-        arr[i + 1] = temp ;
-    }
-    bubblePass(arr, n, i + 1) ;
-    reclaim ;
-}
-
-pollinate empty bubbleSort(seed arr[], seed n) {
-    spring(n <= 1) {
-        reclaim ;
-    }
-    bubblePass(arr, n, 0) ;
-    bubbleSort(arr, n - 1) ;
-    reclaim ;
-}
-
-root() {
-    seed nums[5] ;
-    nums[0] = 64 ;
-    nums[1] = 34 ;
-    nums[2] = 25 ;
-    nums[3] = 12 ;
-    nums[4] = 22 ;
-
-    plant("Before sorting:") ;
-    printArr(nums, 5, 0) ;
-    plant("") ;
-
-    bubbleSort(nums, 5) ;
-
-    plant("After sorting:") ;
-    printArr(nums, 5, 0) ;
-    plant("") ;
-    reclaim ;
-}
-'''
-
-lexer = Lexer(code)
-tokens, lex_errors = lexer.make_tokens()
-print("Lex:", len(tokens), "tokens, errors:", lex_errors)
-
-parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
-errors = parser.parse(tokens)
-print("Parse:", errors)
-
-filtered = [t for t in tokens if t.type != '\n']
-ast = build_ast(filtered)
-print("Semantic OK")
-
-interp = Interpreter()
-interp.plant = lambda value: print(value, end="")
-interp.interpret(ast)
-print()
-print("Done")

Backend/test_mp16_full.py

@@ -1,113 +0,0 @@
-"""Test MP16: Array Elements Print & Sort with Recursion (lex+parse+semantic only)."""
-from lexer import Lexer
-from Gal_Parser import LL1Parser
-from GALsemantic import build_ast
-from cfg import cfg, first_sets, predict_sets
-
-code = '''
-pollinate empty printArr(seed arr[], seed n, seed i) {
-    spring(i >= n) {
-        reclaim ;
-    }
-    plant("{} ", arr[i]) ;
-    printArr(arr, n, i + 1) ;
-    reclaim ;
-}
-
-pollinate empty bblPass(seed arr[], seed n, seed i) {
-    spring(i >= n - 1) {
-        reclaim ;
-    }
-    spring(arr[i] > arr[i + 1]) {
-        seed temp = arr[i] ;
-        arr[i] = arr[i + 1] ;
-        arr[i + 1] = temp ;
-    }
-    bblPass(arr, n, i + 1) ;
-    reclaim ;
-}
-
-pollinate empty sortAsc(seed arr[], seed n) {
-    spring(n <= 1) {
-        reclaim ;
-    }
-    bblPass(arr, n, 0) ;
-    sortAsc(arr, n - 1) ;
-    reclaim ;
-}
-
-pollinate empty bblPassDsc(seed arr[], seed n, seed i) {
-    spring(i >= n - 1) {
-        reclaim ;
-    }
-    spring(arr[i] < arr[i + 1]) {
-        seed dTemp = arr[i] ;
-        arr[i] = arr[i + 1] ;
-        arr[i + 1] = dTemp ;
-    }
-    bblPassDsc(arr, n, i + 1) ;
-    reclaim ;
-}
-
-pollinate empty sortDsc(seed arr[], seed n) {
-    spring(n <= 1) {
-        reclaim ;
-    }
-    bblPassDsc(arr, n, 0) ;
-    sortDsc(arr, n - 1) ;
-    reclaim ;
-}
-
-root() {
-    plant("Input the number of elements to be stored in the array :") ;
-    seed n = water(seed) ;
-    seed arr[20] ;
-
-    plant("Input {} elements in the array :", n) ;
-    cultivate(seed i = 0 ; i < n ; i++) {
-        plant("element - {} : ", i) ;
-        arr[i] = water(seed) ;
-    }
-
-    plant("The elements in the array are : ") ;
-    printArr(arr, n, 0) ;
-
-    plant("Sort Out:") ;
-    plant("1. Ascending") ;
-    plant("2. Descending") ;
-    plant("Enter choice (1 or 2): ") ;
-    seed choice = water(seed) ;
-
-    spring(choice == 1) {
-        sortAsc(arr, n) ;
-        plant("Ascending order : ") ;
-        printArr(arr, n, 0) ;
-    }
-    bud(choice == 2) {
-        sortDsc(arr, n) ;
-        plant("Descending order : ") ;
-        printArr(arr, n, 0) ;
-    }
-    wither {
-        plant("Invalid choice!") ;
-    }
-
-    reclaim ;
-}
-'''
-
-# Lexer
-lexer = Lexer(code)
-tokens, lex_errors = lexer.make_tokens()
-print("Lex OK:", len(tokens), "tokens, errors:", lex_errors)
-
-# Parser
-parser = LL1Parser(cfg=cfg, predict_sets=predict_sets, first_sets=first_sets)
-errors = parser.parse(tokens)
-print("Parse:", errors)
-
-# Semantic + AST
-filtered = [t for t in tokens if t.type != '\n']
-ast = build_ast(filtered)
-print("Semantic + AST OK")
-print("All stages passed!")

Docus & mps/CFG_Latest_1_extracted.txt

@@ -0,0 +1,214 @@
+ #  Production   Production  Set  
+1  <program>  ->  <global_declaration>  <function_definition>  root  (  )  {  <statement>  }  
+2  <global_declaration>  
+->  bundle  id  <bundle_or_var>  <global_declaration>  
+3  <global_declaration>  
+->  <data_type>  id  <array_dec>  <var_value>  ;  <global_declaration>  
+4  <global_declaration>  
+->  fertile  <data_type>  id  =  <init_val>  <const_next>  ;  <global_declaration>  
+5  <global_declaration>  
+->  λ  
+6  <bundle_or_var>  ->  {  <bundle_members>  }  ;  
+7  <bundle_or_var>  ->  <bundle_mem_dec>  ;  
+8  <declaration>  ->  <var_dec>  ;  <declaration>  
+9  <declaration>  ->  <const_dec>  ;  <declaration>  
+10  <declaration>  ->  λ  
+11  <data_type>  ->  seed  
+12  <data_type>  ->  tree  
+13  <data_type>  ->  leaf  
+14  <data_type>  ->  branch  
+15  <data_type>  ->  vine  
+16  <const_dec>  ->  fertile  <data_type>  id  =  <init_val>  <const_next>  
+17  <const_next>  ->  ,  id  =  <init_val>  <const_next>  
+18  <const_next>  ->  λ  
+19  <var_dec>  ->  <data_type>  id  <array_dec>  <var_value>  
+20  <var_dec>  ->  bundle  id  <bundle_mem_dec>  
+21  <bundle_mem_dec>  ->  id  <array_dec>  <var_value_next>  
+22  <bundle_mem_dec>  ->  ,  id  <var_value_next>  
+23  <bundle_mem_dec>  ->  λ  
+24  <var_value>  ->  =  <init_val>  <var_value_next>  
+25  <var_value>  ->  <var_value_next>  
+26  <var_value_next>  ->  ,  id  <array_dec>  <var_value>  
+27  <var_value_next>  ->  λ  
+28  <init_val>  ->  <array_init_opt>  
+29  <init_val>  ->  water  (  <water_arg>  )  
+30  <init_val>  ->  <expression>  
+31  <array_dec>  ->  [  <array_dim_opt>  ]  <array_dec>  
+32  <array_dec>  ->  λ  
+33  <array_dim_opt>  ->  intlit  
+34  <array_dim_opt>  ->  dblit  
+35  <array_dim_opt>  ->  λ  
+36  <array_init_opt>  ->  {  <init_vals>  }  
+37  <array_init_opt>  ->  λ  
+38  <init_vals>  ->  <init_val_item>  <init_vals_next>  
+39  <init_vals>  ->  λ  
+40  <init_vals_next>  ->  ,  <init_val_item>  <init_vals_next>  
+41  <init_vals_next>  ->  λ  
+42  <init_val_item>  ->  {  <init_vals>  }  
+43  <init_val_item>  ->  <expression>  
+44  <bundle_declaration>  
+->  bundle  id  {  <bundle_members>  }  
+45  <bundle_members>  ->  <data_type>  id  ;  <bundle_members>  
+46  <bundle_members>  ->  id  id  ;  <bundle_members>  
+47  <bundle_members>  ->  λ  
+48  <function_definition>  
+->  pollinate  <return_type>  id  (  <parameters>  )  {  <statement>  }  <function_definition>  
+49  <function_definition>  
+->  λ  
+50  <return_type>  ->  <data_type>  
+51  <return_type>  ->  empty  
+52  <return_type>  ->  id  
+53  <parameters>  ->  λ  
+54  <parameters>  ->  <param>  <param_next>  
+55  <param>  ->  <data_type>  id  <param_array>  
+56  <param>  ->  id  id  
+57  <param_array>  ->  λ  
+58  <param_array>  ->  [  ]  
+59  <param_next>  ->  λ  
+60  <param_next>  ->  ,  <param>  <param_next>  
+61  <reclaim_opt>  ->  reclaim  <reclaim_value>  
+62  <reclaim_opt>  ->  λ  
+63  <reclaim_value>  ->  <expression>  ;  
+64  <reclaim_value>  ->  ;  
+65  <statement>  ->  <simple_stmt>  <statement>  
+66  <statement>  ->  λ  
+67  <simple_stmt>  ->  id  <id_stmt>  
+68  <simple_stmt>  ->  <inc_dec_op>  id  ;  
+69  <simple_stmt>  ->  <io_stmt>  
+70  <simple_stmt>  ->  <conditional_stmt>  
+71  <simple_stmt>  ->  <loop_stmt>  
+72  <simple_stmt>  ->  <switch_stmt>  
+73  <simple_stmt>  ->  <control_stmt>  
+74  <simple_stmt>  ->  reclaim  <reclaim_value>  
+75  <simple_stmt>  ->  <var_dec>  ;  
+76  <simple_stmt>  ->  <const_dec>  ;  
+77  <id_stmt>  ->  <id_next>  <assign_op>  <assign_rhs>  ;  
+78  <id_stmt>  ->  <inc_dec_op>  ;  
+79  <id_stmt>  ->  (  <arguments>  )  ;  
+80  <assignment_stmt>  ->  <value>  <assign_op>  <assign_rhs>  ;  
+81  <assign_rhs>  ->  water  (  <water_arg>  )  
+82  <assign_rhs>  ->  <expression>  
+83  <assign_op>  ->  =  
+84  <assign_op>  ->  +=  
+85  <assign_op>  ->  -=  
+86  <assign_op>  ->  *=  
+87  <assign_op>  ->  /=  
+88  <assign_op>  ->  %=  
+89  <value>  ->  id  <id_next>  
+90  <id_next>  ->  <array_access>  <post_array_access>  
+91  <id_next>  ->  <struct_access>  
+92  <id_next>  ->  λ  
+93  <array_access>  ->  [  <expression>  ]  <array_access_more>  
+94  <array_access_more>  
+->  [  <expression>  ]  <array_access_more>  
+95  <array_access_more>  
+->  λ  
+96  <struct_access>  ->  .  id  <struct_access_more>  
+97  <struct_access_more>  
+->  .  id  <struct_access_more>  
+98  <struct_access_more>  
+->  λ  
+99  <post_array_access>  
+->  .  id  <post_array_access>  
+100  <post_array_access>  
+->  λ  
+101  <io_stmt>  ->  plant  (  <arguments>  )  ;  
+102  <io_stmt>  ->  water  (  <water_arg>  )  ;  
+103  <water_arg>  ->  <data_type>  
+104  <water_arg>  ->  id  <water_id_tail>  
+105  <water_arg>  ->  λ  
+106  <water_id_tail>  ->  [  <expression>  ]  <water_id_tail>  
+107  <water_id_tail>  ->  λ  
+108  <arguments>  ->  <expression>  <arg_next>  
+109  <arguments>  ->  λ  
+110  <arg_next>  ->  ,  <expression>  <arg_next>  
+111  <arg_next>  ->  λ  
+112  <conditional_stmt>  
+->  spring  (  <expression>  )  {  <statement>  }  <elseif_chain>  <else_opt>  
+113  <elseif_chain>  ->  bud  (  <expression>  )  {  <statement>  }  <elseif_chain>  
+114  <elseif_chain>  ->  λ  
+115  <else_opt>  ->  wither  {  <statement>  }  
+116  <else_opt>  ->  λ  
+117  <loop_stmt>  ->  grow  (  <expression>  )  {  <statement>  }  
+118  <loop_stmt>  ->  cultivate  (  <for_init>  ;  <expression>  ;  <for_update>  )  {  <statement>  }  
+119  <loop_stmt>  ->  tend  {  <statement>  }  grow  (  <expression>  )  ;  
+120  <for_init>  ->  <data_type>  id  <array_dec>  <var_value>  
+121  <for_init>  ->  id  <id_next>  <assign_op>  <expression>  
+122  <for_init>  ->  λ  
+123  <for_update>  ->   id  <for_update_type>  
+124  <for_update>  ->  λ  
+125  <for_update_type>  ->  <inc_dec_op>  
+126  <for_update_type>  ->  <id_next>  <assign_op>  <expression>  
+127  <unary_stmt>  ->  id  <inc_dec_op>  ;  
+128  <inc_dec_op>  ->  ++  
+129  <inc_dec_op>  ->  --  
+130  <switch_stmt>  ->  harvest  (  <expression>  )  {  <case_list>  <default_opt>  }  
+131  <case_list>  ->  variety  <case_literal>  :  <case_statements>  <case_list>  
+132  <case_list>  ->  λ  
+133  <case_literal>  ->  intlit  
+134  <case_literal>  ->  dblit  
+135  <case_literal>  ->  chrlit  
+136  <case_literal>  ->  stringlit  
+137  <case_literal>  ->  sunshine  
+138  <case_literal>  ->  frost  
+139  <case_statements>  ->  <case_statement>  <case_statements>  
+140  <case_statements>  ->  λ  
+141  <case_statement>  ->  id  <id_stmt>  
+142  <case_statement>  ->  <inc_dec_op>  id  ;  
+143  <case_statement>  ->  <var_dec>  ;  
+144  <case_statement>  ->  <io_stmt>  
+145  <case_statement>  ->  <conditional_stmt>  
+146  <case_statement>  ->  <loop_stmt>  
+147  <case_statement>  ->  <switch_stmt>  
+148  <case_statement>  ->  {  <case_statements>  }  
+149  <case_statement>  ->  prune  ;  
+150  <case_statement>  ->  skip  ;  
+151  <case_statement>  ->  reclaim  <reclaim_value>  
+152  <default_opt>  ->  soil  :  <case_statements>  
+153  <default_opt>  ->  λ  
+154  <control_stmt>  ->  prune  ;  
+155  <control_stmt>  ->  skip  ;  
+156  <function_call>  ->  id  (  <arguments>  )  ;  
+157  <expression>  ->  <logic_or>  
+158  <logic_or>  ->  <logic_and>  <logic_or_next>  
+159  <logic_or_next>  ->  ||  <logic_and>  <logic_or_next>  
+160  <logic_or_next>  ->  λ  
+161  <logic_and>  ->  <relational>  <logic_and_next>  
+162  <logic_and_next>  ->  &&  <relational>  <logic_and_next>  
+163  <logic_and_next>  ->  λ  
+164  <relational>  ->  <arithmetic>  <relational_next>  
+165  <relational_next>  ->  <relational_op>  <arithmetic>  
+166  <relational_next>  ->  λ  
+167  <relational_op>  ->  >  
+168  <relational_op>  ->  <  
+169  <relational_op>  ->  >=  
+170  <relational_op>  ->  <=  
+171  <relational_op>  ->  ==  
+172  <relational_op>  ->  !=  
+173  <arithmetic>  ->  <term>  <arithmetic_next>  
+174  <arithmetic_next>  ->  +  <term>  <arithmetic_next>  
+175  <arithmetic_next>  ->  -  <term>  <arithmetic_next>  
+176  <arithmetic_next>  ->  `  <term>  <arithmetic_next>  
+177  <arithmetic_next>  ->  λ  
+178  <term>  ->  <factor>  <term_next>  
+179  <term_next>  ->  *  <factor>  <term_next>  
+180  <term_next>  ->  /  <factor>  <term_next>  
+181  <term_next>  ->  %  <factor>  <term_next>  
+182  <term_next>  ->  λ  
+183  <factor>  ->  (  <paren_expr>  
+184  <factor>  ->  <unary_op>  <factor>  
+185  <factor>  ->  id  <factor_id_next>  
+186  <factor>  ->  intlit  
+187  <factor>  ->  dblit  
+188  <factor>  ->  chrlit  
+189  <factor>  ->  stringlit  
+190  <factor>  ->  sunshine  
+191  <factor>  ->  frost  
+192  <paren_expr>  ->  <data_type>  )  <factor>  
+193  <paren_expr>  ->  <expression>  )  
+194  <unary_op>  ->  ~  
+195  <unary_op>  ->  !  
+196  <factor_id_next>  ->  <array_access>  <post_array_access>  
+197  <factor_id_next>  ->  <struct_access>  
+198  <factor_id_next>  ->  (  <arguments>  )  
+199  <factor_id_next>  ->  λ   

Docus & mps/CFG_Latest_First_Follow_Predict_Set_extracted.txt

@@ -0,0 +1,1441 @@
+XI. FIRST SET
+#
+Nonterminal
+First Set
+1
+<program>
+->
+{ branch, bundle, fertile, leaf, pollinate, root, seed, tree, vine }
+2
+<global_declaration>
+->
+{ branch, bundle, fertile, leaf, seed, tree, vine, λ }
+3
+<bundle_or_var>
+->
+{ {, ,, ;, id }
+4
+<declaration>
+->
+{ branch, bundle, fertile, leaf, seed, tree, vine, λ }
+5
+<data_type>
+->
+{ branch, leaf, seed, tree, vine }
+6
+<const_dec>
+->
+{ fertile }
+7
+<const_next>
+->
+{ ,, λ }
+8
+<var_dec>
+->
+{ branch, bundle, leaf, seed, tree, vine }
+9
+<bundle_mem_dec>
+->
+{ ,, id, λ }
+10
+<var_value>
+->
+{ ,, =, λ }
+11
+<var_value_next>
+->
+{ ,, λ }
+12
+<init_val>
+->
+{ !, ~, (, {, id, water, intlit, dblit, chrlit, stringlit, sunshine, frost, λ }
+13
+<array_dec>
+->
+{ [, λ }
+14
+<array_dim_opt>
+->
+{ intlit, dblit, λ }
+15
+<array_init_opt>
+->
+{ {, λ }
+16
+<init_vals>
+->
+{ !, ~, (, {, id, intlit, dblit, chrlit, stringlit, sunshine, frost, λ }
+17
+<init_vals_next>
+->
+{ ,, λ }
+18
+<init_val_item>
+->
+{ !, ~, (, {, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+19
+<bundle_declaration>
+->
+{ bundle }
+20
+<bundle_members>
+->
+{ branch, id, leaf, seed, tree, vine, λ }
+21
+<function_definition>
+->
+{ pollinate, λ }
+22
+<return_type>
+->
+{ branch, empty, id, leaf, seed, tree, vine }
+23
+<parameters>
+->
+{ branch, id, leaf, seed, tree, vine, λ }
+24
+<param>
+->
+{ branch, id, leaf, seed, tree, vine }
+25
+<param_array>
+->
+{ [, λ }
+26
+<param_next>
+->
+{ ,, λ }
+27
+<reclaim_opt>
+->
+{ reclaim, λ }
+28
+<reclaim_value>
+->
+{ !, ~, (, ;, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+29
+<statement>
+->
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, λ }
+30
+<simple_stmt>
+->
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+31
+<id_stmt>
+->
+{ ++, --, (, [, ., =, +=, -=, *=, /=, %= }
+32
+<assignment_stmt>
+->
+{ id }
+33
+<assign_rhs>
+->
+{ !, ~, (, id, water, intlit, dblit, chrlit, stringlit, sunshine, frost }
+34
+<assign_op>
+->
+{ =, +=, -=, *=, /=, %= }
+35
+<value>
+->
+{ id }
+36
+<id_next>
+->
+{ [, ., λ }
+37
+<array_access>
+->
+{ [ }
+38
+<array_access_more>
+->
+{ [, λ }
+39
+<struct_access>
+->
+{ . }
+40
+<struct_access_more>
+->
+{ ., λ }
+41
+<post_array_access>
+->
+{ ., λ }
+42
+<io_stmt>
+->
+{ plant, water }
+43
+<water_arg>
+->
+{ branch, id, leaf, seed, tree, vine, λ }
+44
+<water_id_tail>
+->
+{ [, λ }
+45
+<arguments>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost, λ }
+46
+<arg_next>
+->
+{ ,, λ }
+47
+<conditional_stmt>
+->
+{ spring }
+48
+<elseif_chain>
+->
+{ bud, λ }
+49
+<else_opt>
+->
+{ wither, λ }
+50
+<loop_stmt>
+->
+{ cultivate, grow, tend }
+51
+<for_init>
+->
+{ branch, id, leaf, seed, tree, vine, λ }
+52
+<for_update>
+->
+{ id, λ }
+53
+<for_update_type>
+->
+{ ++, --, [, ., =, +=, -=, *=, /=, %= }
+54
+<unary_stmt>
+->
+{ id }
+55
+<inc_dec_op>
+->
+{ ++, -- }
+56
+<switch_stmt>
+->
+{ harvest }
+57
+<case_list>
+->
+{ variety, λ }
+58
+<case_literal>
+->
+{ intlit, dblit, chrlit, stringlit, sunshine, frost }
+59
+<case_statements>
+->
+{ ++, --, {, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, λ }
+60
+<case_statement>
+->
+{ ++, --, {, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+61
+<default_opt>
+->
+{ soil, λ }
+62
+<control_stmt>
+->
+{ prune, skip }
+63
+<function_call>
+->
+{ id }
+64
+<expression>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+65
+<logic_or>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+66
+<logic_or_next>
+->
+{ ||, λ }
+67
+<logic_and>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+68
+<logic_and_next>
+->
+{ &&, λ }
+69
+<relational>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+70
+<relational_next>
+->
+{ >, <, >=, <=, ==, !=, λ }
+71
+<relational_op>
+->
+{ >, <, >=, <=, ==, != }
+72
+<arithmetic>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+73
+<arithmetic_next>
+->
+{ +, -, `, λ }
+74
+<term>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+75
+<term_next>
+->
+{ *, /, %, λ }
+76
+<factor>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+77
+<paren_expr>
+->
+{ !, ~, (, branch, id, leaf, seed, tree, vine, intlit, dblit, chrlit, stringlit, sunshine, frost }
+78
+<unary_op>
+->
+{ !, ~ }
+79
+<factor_id_next>
+->
+{ (, [, ., λ }
+XII. FOLLOW SET
+#
+Nonterminal
+Follow Set
+1
+<program>
+->
+{ EOF }
+2
+<global_declaration>
+->
+{ pollinate, root }
+3
+<bundle_or_var>
+->
+{ branch, bundle, fertile, leaf, pollinate, root, seed, tree, vine }
+4
+<declaration>
+->
+{ }
+5
+<data_type>
+->
+{ ), id }
+6
+<const_dec>
+->
+{ ; }
+7
+<const_next>
+->
+{ ; }
+8
+<var_dec>
+->
+{ ; }
+9
+<bundle_mem_dec>
+->
+{ ; }
+10
+<var_value>
+->
+{ ; }
+11
+<var_value_next>
+->
+{ ; }
+12
+<init_val>
+->
+{ ,, ; }
+13
+<array_dec>
+->
+{ ,, ;, = }
+14
+<array_dim_opt>
+->
+{ ] }
+15
+<array_init_opt>
+->
+{ ,, ; }
+16
+<init_vals>
+->
+{ } }
+17
+<init_vals_next>
+->
+{ } }
+18
+<init_val_item>
+->
+{ }, , }
+19
+<bundle_declaration>
+->
+{ }
+20
+<bundle_members>
+->
+{ } }
+21
+<function_definition>
+->
+{ root }
+22
+<return_type>
+->
+{ id }
+23
+<parameters>
+->
+{ ) }
+24
+<param>
+->
+{ ), , }
+25
+<param_array>
+->
+{ ), , }
+26
+<param_next>
+->
+{ ) }
+27
+<reclaim_opt>
+->
+{ }
+28
+<reclaim_value>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+29
+<statement>
+->
+{ } }
+30
+<simple_stmt>
+->
+{ ++, --, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+31
+<id_stmt>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+32
+<assignment_stmt>
+->
+{ }
+33
+<assign_rhs>
+->
+{ ; }
+34
+<assign_op>
+->
+{ !, ~, (, id, water, intlit, dblit, chrlit, stringlit, sunshine, frost }
+35
+<value>
+->
+{ =, +=, -=, *=, /=, %= }
+36
+<id_next>
+->
+{ =, +=, -=, *=, /=, %= }
+37
+<array_access>
+->
+{ ), ], }, ,, ;, ., =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+38
+<array_access_more>
+->
+{ ), ], }, ,, ;, ., =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+39
+<struct_access>
+->
+{ ), ], }, ,, ;, =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+40
+<struct_access_more>
+->
+{ ), ], }, ,, ;, =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+41
+<post_array_access>
+->
+{ ), ], }, ,, ;, =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+42
+<io_stmt>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+43
+<water_arg>
+->
+{ ) }
+44
+<water_id_tail>
+->
+{ ) }
+45
+<arguments>
+->
+{ ) }
+46
+<arg_next>
+->
+{ ) }
+47
+<conditional_stmt>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+48
+<elseif_chain>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, wither }
+49
+<else_opt>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+50
+<loop_stmt>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+51
+<for_init>
+->
+{ ; }
+52
+<for_update>
+->
+{ ) }
+53
+<for_update_type>
+->
+{ ) }
+54
+<unary_stmt>
+->
+{ }
+55
+<inc_dec_op>
+->
+{ ), ;, id }
+56
+<switch_stmt>
+->
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+57
+<case_list>
+->
+{ }, soil }
+58
+<case_literal>
+->
+{ : }
+59
+<case_statements>
+->
+{ }, soil, variety }
+60
+<case_statement>
+->
+{ ++, --, {, }, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+61
+<default_opt>
+->
+{ } }
+62
+<control_stmt>
+->
+{ ++, --, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+63
+<function_call>
+->
+{ }
+64
+<expression>
+->
+{ ), ], }, ,, ; }
+65
+<logic_or>
+->
+{ ), ], }, ,, ; }
+66
+<logic_or_next>
+->
+{ ), ], }, ,, ; }
+67
+<logic_and>
+->
+{ ), ], }, ,, ;, || }
+68
+<logic_and_next>
+->
+{ ), ], }, ,, ;, || }
+69
+<relational>
+->
+{ ), ], }, ,, ;, &&, || }
+70
+<relational_next>
+->
+{ ), ], }, ,, ;, &&, || }
+71
+<relational_op>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+72
+<arithmetic>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, || }
+73
+<arithmetic_next>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, || }
+74
+<term>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, ` }
+75
+<term_next>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, ` }
+76
+<factor>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+77
+<paren_expr>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+78
+<unary_op>
+->
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+79
+<factor_id_next>
+->
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+XIII. PREDICT SET
+No
+FIRST / Expression Form
+Basis
+Predict Set
+1
+first(<global_declaration> <function_definition> root ( ) { <statement> })
+first(<global_declaration> <function_definition> root ( ) { <statement> })
+{ branch, bundle, fertile, leaf, pollinate, root, seed, tree, vine }
+2
+first(bundle id <bundle_or_var> <global_declaration>)
+first(bundle id <bundle_or_var> <global_declaration>)
+{ bundle }
+3
+first(<data_type> id <array_dec> <var_value> ; <global_declaration>)
+first(<data_type> id <array_dec> <var_value> ; <global_declaration>)
+{ branch, leaf, seed, tree, vine }
+4
+first(fertile <data_type> id = <init_val> <const_next> ; <global_declaration>)
+first(fertile <data_type> id = <init_val> <const_next> ; <global_declaration>)
+{ fertile }
+5
+first(λ)
+follow(<global_declaration>)
+{ pollinate, root }
+6
+first({ <bundle_members> } ;)
+first({ <bundle_members> } ;)
+{ { }
+7
+first(<bundle_mem_dec> ;)
+first(<bundle_mem_dec> ;)
+{ ,, ;, id }
+8
+first(<var_dec> ; <declaration>)
+first(<var_dec> ; <declaration>)
+{ branch, bundle, leaf, seed, tree, vine }
+9
+first(<const_dec> ; <declaration>)
+first(<const_dec> ; <declaration>)
+{ fertile }
+10
+first(λ)
+follow(<declaration>)
+{ }
+11
+first(seed)
+first(seed)
+{ seed }
+12
+first(tree)
+first(tree)
+{ tree }
+13
+first(leaf)
+first(leaf)
+{ leaf }
+14
+first(branch)
+first(branch)
+{ branch }
+15
+first(vine)
+first(vine)
+{ vine }
+16
+first(fertile <data_type> id = <init_val> <const_next>)
+first(fertile <data_type> id = <init_val> <const_next>)
+{ fertile }
+17
+first(, id = <init_val> <const_next>)
+first(, id = <init_val> <const_next>)
+{ , }
+18
+first(λ)
+follow(<const_next>)
+{ ; }
+19
+first(<data_type> id <array_dec> <var_value>)
+first(<data_type> id <array_dec> <var_value>)
+{ branch, leaf, seed, tree, vine }
+20
+first(bundle id <bundle_mem_dec>)
+first(bundle id <bundle_mem_dec>)
+{ bundle }
+21
+first(id <array_dec> <var_value_next>)
+first(id <array_dec> <var_value_next>)
+{ id }
+22
+first(, id <var_value_next>)
+first(, id <var_value_next>)
+{ , }
+23
+first(λ)
+follow(<bundle_mem_dec>)
+{ ; }
+24
+first(= <init_val> <var_value_next>)
+first(= <init_val> <var_value_next>)
+{ = }
+25
+first(<var_value_next>)
+first(<var_value_next>) ∪ follow(<var_value>)
+{ ,, ; }
+26
+first(, id <array_dec> <var_value>)
+first(, id <array_dec> <var_value>)
+{ , }
+27
+first(λ)
+follow(<var_value_next>)
+{ ; }
+28
+first(<array_init_opt>)
+first(<array_init_opt>) ∪ follow(<init_val>)
+{ {, ,, ; }
+29
+first(water ( <water_arg> ))
+first(water ( <water_arg> ))
+{ water }
+30
+first(<expression>)
+first(<expression>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+31
+first([ <array_dim_opt> ] <array_dec>)
+first([ <array_dim_opt> ] <array_dec>)
+{ [ }
+32
+first(λ)
+follow(<array_dec>)
+{ ,, ;, = }
+33
+first(intlit)
+first(intlit)
+{ intlit }
+34
+first(dblit)
+first(dblit)
+{ dblit }
+35
+first(λ)
+follow(<array_dim_opt>)
+{ ] }
+36
+first({ <init_vals> })
+first({ <init_vals> })
+{ { }
+37
+first(λ)
+follow(<array_init_opt>)
+{ ,, ; }
+38
+first(<init_val_item> <init_vals_next>)
+first(<init_val_item> <init_vals_next>)
+{ !, ~, (, {, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+39
+first(λ)
+follow(<init_vals>)
+{ } }
+40
+first(, <init_val_item> <init_vals_next>)
+first(, <init_val_item> <init_vals_next>)
+{ , }
+41
+first(λ)
+follow(<init_vals_next>)
+{ } }
+42
+first({ <init_vals> })
+first({ <init_vals> })
+{ { }
+43
+first(<expression>)
+first(<expression>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+44
+first(bundle id { <bundle_members> })
+first(bundle id { <bundle_members> })
+{ bundle }
+45
+first(<data_type> id ; <bundle_members>)
+first(<data_type> id ; <bundle_members>)
+{ branch, leaf, seed, tree, vine }
+46
+first(id id ; <bundle_members>)
+first(id id ; <bundle_members>)
+{ id }
+47
+first(λ)
+follow(<bundle_members>)
+{ } }
+48
+first(pollinate <return_type> id ( <parameters> ) { <statement> } <function_definition>)
+first(pollinate <return_type> id ( <parameters> ) { <statement> } <function_definition>)
+{ pollinate }
+49
+first(λ)
+follow(<function_definition>)
+{ root }
+50
+first(<data_type>)
+first(<data_type>)
+{ branch, leaf, seed, tree, vine }
+51
+first(empty)
+first(empty)
+{ empty }
+52
+first(id)
+first(id)
+{ id }
+53
+first(λ)
+follow(<parameters>)
+{ ) }
+54
+first(<param> <param_next>)
+first(<param> <param_next>)
+{ branch, id, leaf, seed, tree, vine }
+55
+first(<data_type> id <param_array>)
+first(<data_type> id <param_array>)
+{ branch, leaf, seed, tree, vine }
+56
+first(id id)
+first(id id)
+{ id }
+57
+first(λ)
+follow(<param_array>)
+{ ), , }
+58
+first([ ])
+first([ ])
+{ [ }
+59
+first(λ)
+follow(<param_next>)
+{ ) }
+60
+first(, <param> <param_next>)
+first(, <param> <param_next>)
+{ , }
+61
+first(reclaim <reclaim_value>)
+first(reclaim <reclaim_value>)
+{ reclaim }
+62
+first(λ)
+follow(<reclaim_opt>)
+{ }
+63
+first(<expression> ;)
+first(<expression> ;)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+64
+first(;)
+first(;)
+{ ; }
+65
+first(<simple_stmt> <statement>)
+first(<simple_stmt> <statement>)
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+66
+first(λ)
+follow(<statement>)
+{ } }
+67
+first(id <id_stmt>)
+first(id <id_stmt>)
+{ id }
+68
+first(<inc_dec_op> id ;)
+first(<inc_dec_op> id ;)
+{ ++, -- }
+69
+first(<io_stmt>)
+first(<io_stmt>)
+{ plant, water }
+70
+first(<conditional_stmt>)
+first(<conditional_stmt>)
+{ spring }
+71
+first(<loop_stmt>)
+first(<loop_stmt>)
+{ cultivate, grow, tend }
+72
+first(<switch_stmt>)
+first(<switch_stmt>)
+{ harvest }
+73
+first(<control_stmt>)
+first(<control_stmt>)
+{ prune, skip }
+74
+first(reclaim <reclaim_value>)
+first(reclaim <reclaim_value>)
+{ reclaim }
+75
+first(<var_dec> ;)
+first(<var_dec> ;)
+{ branch, bundle, leaf, seed, tree, vine }
+76
+first(<const_dec> ;)
+first(<const_dec> ;)
+{ fertile }
+77
+first(<id_next> <assign_op> <assign_rhs> ;)
+first(<id_next> <assign_op> <assign_rhs> ;)
+{ [, ., =, +=, -=, *=, /=, %= }
+78
+first(<inc_dec_op> ;)
+first(<inc_dec_op> ;)
+{ ++, -- }
+79
+first(( <arguments> ) ;)
+first(( <arguments> ) ;)
+{ ( }
+80
+first(<value> <assign_op> <assign_rhs> ;)
+first(<value> <assign_op> <assign_rhs> ;)
+{ id }
+81
+first(water ( <water_arg> ))
+first(water ( <water_arg> ))
+{ water }
+82
+first(<expression>)
+first(<expression>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+83
+first(=)
+first(=)
+{ = }
+84
+first(+=)
+first(+=)
+{ += }
+85
+first(-=)
+first(-=)
+{ -= }
+86
+first(*=)
+first(*=)
+{ *= }
+87
+first(/=)
+first(/=)
+{ /= }
+88
+first(%=)
+first(%=)
+{ %= }
+89
+first(id <id_next>)
+first(id <id_next>)
+{ id }
+90
+first(<array_access> <post_array_access>)
+first(<array_access> <post_array_access>)
+{ [ }
+91
+first(<struct_access>)
+first(<struct_access>)
+{ . }
+92
+first(λ)
+follow(<id_next>)
+{ =, +=, -=, *=, /=, %= }
+93
+first([ <expression> ] <array_access_more>)
+first([ <expression> ] <array_access_more>)
+{ [ }
+94
+first([ <expression> ] <array_access_more>)
+first([ <expression> ] <array_access_more>)
+{ [ }
+95
+first(λ)
+follow(<array_access_more>)
+{ ), ], }, ,, ;, ., =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+96
+first(. id <struct_access_more>)
+first(. id <struct_access_more>)
+{ . }
+97
+first(. id <struct_access_more>)
+first(. id <struct_access_more>)
+{ . }
+98
+first(λ)
+follow(<struct_access_more>)
+{ ), ], }, ,, ;, =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+99
+first(. id <post_array_access>)
+first(. id <post_array_access>)
+{ . }
+100
+first(λ)
+follow(<post_array_access>)
+{ ), ], }, ,, ;, =, +=, -=, *=, /=, %=, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }
+101
+first(plant ( <arguments> ) ;)
+first(plant ( <arguments> ) ;)
+{ plant }
+102
+first(water ( <water_arg> ) ;)
+first(water ( <water_arg> ) ;)
+{ water }
+103
+first(<data_type>)
+first(<data_type>)
+{ branch, leaf, seed, tree, vine }
+104
+first(id <water_id_tail>)
+first(id <water_id_tail>)
+{ id }
+105
+first(λ)
+follow(<water_arg>)
+{ ) }
+106
+first([ <expression> ] <water_id_tail>)
+first([ <expression> ] <water_id_tail>)
+{ [ }
+107
+first(λ)
+follow(<water_id_tail>)
+{ ) }
+108
+first(<expression> <arg_next>)
+first(<expression> <arg_next>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+109
+first(λ)
+follow(<arguments>)
+{ ) }
+110
+first(, <expression> <arg_next>)
+first(, <expression> <arg_next>)
+{ , }
+111
+first(λ)
+follow(<arg_next>)
+{ ) }
+112
+first(spring ( <expression> ) { <statement> } <elseif_chain> <else_opt>)
+first(spring ( <expression> ) { <statement> } <elseif_chain> <else_opt>)
+{ spring }
+113
+first(bud ( <expression> ) { <statement> } <elseif_chain>)
+first(bud ( <expression> ) { <statement> } <elseif_chain>)
+{ bud }
+114
+first(λ)
+follow(<elseif_chain>)
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, wither }
+115
+first(wither { <statement> })
+first(wither { <statement> })
+{ wither }
+116
+first(λ)
+follow(<else_opt>)
+{ ++, --, {, }, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water }
+117
+first(grow ( <expression> ) { <statement> })
+first(grow ( <expression> ) { <statement> })
+{ grow }
+118
+first(cultivate ( <for_init> ; <expression> ; <for_update> ) { <statement> })
+first(cultivate ( <for_init> ; <expression> ; <for_update> ) { <statement> })
+{ cultivate }
+119
+first(tend { <statement> } grow ( <expression> ) ;)
+first(tend { <statement> } grow ( <expression> ) ;)
+{ tend }
+120
+first(<data_type> id <array_dec> <var_value>)
+first(<data_type> id <array_dec> <var_value>)
+{ branch, leaf, seed, tree, vine }
+121
+first(id <id_next> <assign_op> <expression>)
+first(id <id_next> <assign_op> <expression>)
+{ id }
+122
+first(λ)
+follow(<for_init>)
+{ ; }
+123
+first(id <for_update_type>)
+first(id <for_update_type>)
+{ id }
+124
+first(λ)
+follow(<for_update>)
+{ ) }
+125
+first(<inc_dec_op>)
+first(<inc_dec_op>)
+{ ++, -- }
+126
+first(<id_next> <assign_op> <expression>)
+first(<id_next> <assign_op> <expression>)
+{ [, ., =, +=, -=, *=, /=, %= }
+127
+first(id <inc_dec_op> ;)
+first(id <inc_dec_op> ;)
+{ id }
+128
+first(++)
+first(++)
+{ ++ }
+129
+first(--)
+first(--)
+{ -- }
+130
+first(harvest ( <expression> ) { <case_list> <default_opt> })
+first(harvest ( <expression> ) { <case_list> <default_opt> })
+{ harvest }
+131
+first(variety <case_literal> : <case_statements> <case_list>)
+first(variety <case_literal> : <case_statements> <case_list>)
+{ variety }
+132
+first(λ)
+follow(<case_list>)
+{ }, soil }
+133
+first(intlit)
+first(intlit)
+{ intlit }
+134
+first(dblit)
+first(dblit)
+{ dblit }
+135
+first(chrlit)
+first(chrlit)
+{ chrlit }
+136
+first(stringlit)
+first(stringlit)
+{ stringlit }
+137
+first(sunshine)
+first(sunshine)
+{ sunshine }
+138
+first(frost)
+first(frost)
+{ frost }
+139
+first(<case_statement> <case_statements>)
+first(<case_statement> <case_statements>)
+{ ++, --, {, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+140
+first(λ)
+follow(<case_statements>)
+{ }, soil, variety }
+141
+first(id <id_stmt>)
+first(id <id_stmt>)
+{ id }
+142
+first(<inc_dec_op> id ;)
+first(<inc_dec_op> id ;)
+{ ++, -- }
+143
+first(<var_dec> ;)
+first(<var_dec> ;)
+{ branch, bundle, leaf, seed, tree, vine }
+144
+first(<io_stmt>)
+first(<io_stmt>)
+{ plant, water }
+145
+first(<conditional_stmt>)
+first(<conditional_stmt>)
+{ spring }
+146
+first(<loop_stmt>)
+first(<loop_stmt>)
+{ cultivate, grow, tend }
+147
+first(<switch_stmt>)
+first(<switch_stmt>)
+{ harvest }
+148
+first({ <case_statements> })
+first({ <case_statements> })
+{ { }
+149
+first(prune ;)
+first(prune ;)
+{ prune }
+150
+first(skip ;)
+first(skip ;)
+{ skip }
+151
+first(reclaim <reclaim_value>)
+first(reclaim <reclaim_value>)
+{ reclaim }
+152
+first(soil : <case_statements>)
+first(soil : <case_statements>)
+{ soil }
+153
+first(λ)
+follow(<default_opt>)
+{ } }
+154
+first(prune ;)
+first(prune ;)
+{ prune }
+155
+first(skip ;)
+first(skip ;)
+{ skip }
+156
+first(id ( <arguments> ) ;)
+first(id ( <arguments> ) ;)
+{ id }
+157
+first(<logic_or>)
+first(<logic_or>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+158
+first(<logic_and> <logic_or_next>)
+first(<logic_and> <logic_or_next>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+159
+first(|| <logic_and> <logic_or_next>)
+first(|| <logic_and> <logic_or_next>)
+{ || }
+160
+first(λ)
+follow(<logic_or_next>)
+{ ), ], }, ,, ; }
+161
+first(<relational> <logic_and_next>)
+first(<relational> <logic_and_next>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+162
+first(&& <relational> <logic_and_next>)
+first(&& <relational> <logic_and_next>)
+{ && }
+163
+first(λ)
+follow(<logic_and_next>)
+{ ), ], }, ,, ;, || }
+164
+first(<arithmetic> <relational_next>)
+first(<arithmetic> <relational_next>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+165
+first(<relational_op> <arithmetic>)
+first(<relational_op> <arithmetic>)
+{ >, <, >=, <=, ==, != }
+166
+first(λ)
+follow(<relational_next>)
+{ ), ], }, ,, ;, &&, || }
+167
+first(>)
+first(>)
+{ > }
+168
+first(<)
+first(<)
+{ < }
+169
+first(>=)
+first(>=)
+{ >= }
+170
+first(<=)
+first(<=)
+{ <= }
+171
+first(==)
+first(==)
+{ == }
+172
+first(!=)
+first(!=)
+{ != }
+173
+first(<term> <arithmetic_next>)
+first(<term> <arithmetic_next>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+174
+first(+ <term> <arithmetic_next>)
+first(+ <term> <arithmetic_next>)
+{ + }
+175
+first(- <term> <arithmetic_next>)
+first(- <term> <arithmetic_next>)
+{ - }
+176
+first(` <term> <arithmetic_next>)
+first(` <term> <arithmetic_next>)
+{ ` }
+177
+first(λ)
+follow(<arithmetic_next>)
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, || }
+178
+first(<factor> <term_next>)
+first(<factor> <term_next>)
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+179
+first(* <factor> <term_next>)
+first(* <factor> <term_next>)
+{ * }
+180
+first(/ <factor> <term_next>)
+first(/ <factor> <term_next>)
+{ / }
+181
+first(% <factor> <term_next>)
+first(% <factor> <term_next>)
+{ % }
+182
+first(λ)
+follow(<term_next>)
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, ` }
+183
+first(( <paren_expr>)
+first(( <paren_expr>)
+{ ( }
+184
+first(<unary_op> <factor>)
+first(<unary_op> <factor>)
+{ !, ~ }
+185
+first(id <factor_id_next>)
+first(id <factor_id_next>)
+{ id }
+186
+first(intlit)
+first(intlit)
+{ intlit }
+187
+first(dblit)
+first(dblit)
+{ dblit }
+188
+first(chrlit)
+first(chrlit)
+{ chrlit }
+189
+first(stringlit)
+first(stringlit)
+{ stringlit }
+190
+first(sunshine)
+first(sunshine)
+{ sunshine }
+191
+first(frost)
+first(frost)
+{ frost }
+192
+first(<data_type> ) <factor>)
+first(<data_type> ) <factor>)
+{ branch, leaf, seed, tree, vine }
+193
+first(<expression> ))
+first(<expression> ))
+{ !, ~, (, id, intlit, dblit, chrlit, stringlit, sunshine, frost }
+194
+first(~)
+first(~)
+{ ~ }
+195
+first(!)
+first(!)
+{ ! }
+196
+first(<array_access> <post_array_access>)
+first(<array_access> <post_array_access>)
+{ [ }
+197
+first(<struct_access>)
+first(<struct_access>)
+{ . }
+198
+first(( <arguments> ))
+first(( <arguments> ))
+{ ( }
+199
+first(λ)
+follow(<factor_id_next>)
+{ ), ], }, ,, ;, >, <, >=, <=, ==, !=, &&, ||, +, -, `, *, /, % }

Docus & mps/CFG_Latest_extracted.txt

@@ -0,0 +1,225 @@
+ #  Production   Production  Set  
+1  <program>  ->  <global_declaration>  <function_definition>  root  (  )  {  <statement>  }  
+2  <global_declaration>  
+->  bundle  id  <bundle_or_var>  <global_declaration>  
+3  <global_declaration>  
+->  <data_type>  id  <array_dec>  <var_value>  ;  <global_declaration>  
+4  <global_declaration>  
+->  fertile  <data_type>  id  =  <init_val>  <const_next>  ;  <global_declaration>  
+5  <global_declaration>  
+->  λ  
+6  <bundle_or_var>  ->  {  <bundle_members>  }  ;  
+7  <bundle_or_var>  ->  <bundle_mem_dec>  ;  
+8  <declaration>  ->  <var_dec>  ;  <declaration>  
+9  <declaration>  ->  <const_dec>  ;  <declaration>  
+10  <declaration>  ->  λ  
+11  <data_type>  ->  seed  
+12  <data_type>  ->  tree  
+13  <data_type>  ->  leaf  
+14  <data_type>  ->  branch  
+15  <data_type>  ->  vine  
+16  <const_dec>  ->  fertile  <data_type>  id  =  <init_val>  <const_next>  
+17  <const_next>  ->  ,  id  =  <init_val>  <const_next>  
+18  <const_next>  ->  λ  
+19  <var_dec>  ->  <data_type>  id  <array_dec>  <var_value>  
+20  <var_dec>  ->  bundle  id  <bundle_mem_dec>  
+21  <bundle_mem_dec>  ->  id  <array_dec>  <var_value_next>  
+22  <bundle_mem_dec>  ->  ,  id  <var_value_next>  
+23  <bundle_mem_dec>  ->  λ  
+24  <var_value>  ->  =  <init_val>  <var_value_next>  
+25  <var_value>  ->  <var_value_next>  
+26  <var_value_next>  ->  ,  id  <array_dec>  <var_value>  
+27  <var_value_next>  ->  λ  
+28  <init_val>  ->  <array_init_opt>  
+29  <init_val>  ->  water  (  <water_arg>  )  
+30  <init_val>  ->  <expression>  
+31  <array_dec>  ->  [  <array_dim_opt>  ]  <array_dec>  
+32  <array_dec>  ->  λ  
+33  <array_dim_opt>  ->  intlit  
+34  <array_dim_opt>  ->  dblit  
+35  <array_dim_opt>  ->  λ  
+36  <array_init_opt>  ->  {  <init_vals>  }  
+37  <array_init_opt>  ->  λ  
+38  <init_vals>  ->  <init_val_item>  <init_vals_next>  
+39  <init_vals>  ->  λ  
+40  <init_vals_next>  ->  ,  <init_val_item>  <init_vals_next>  
+41  <init_vals_next>  ->  λ  
+42  <init_val_item>  ->  {  <init_vals>  }  
+43  <init_val_item>  ->  <expression>  
+44  <bundle_declaration>  
+->  bundle  id  {  <bundle_members>  }  
+45  <bundle_members>  ->  <data_type>  id  ;  <bundle_members>  
+46  <bundle_members>  ->  id  id  ;  <bundle_members>  
+47  <bundle_members>  ->  λ  
+48  <function_definition>  
+->  pollinate  <return_type>  id  (  <parameters>  )  {  <statement>  }  <function_definition>  
+49  <function_definition>  
+->  λ  
+50  <return_type>  ->  <data_type>  
+51  <return_type>  ->  empty  
+52  <return_type>  ->  id  
+53  <parameters>  ->  λ  
+54  <parameters>  ->  <param>  <param_next>  
+55  <param>  ->  <data_type>  id  <param_array>  
+56  <param>  ->  id  id  
+57  <param_array>  ->  λ  
+58  <param_array>  ->  [  ]  
+59  <param_next>  ->  λ  
+60  <param_next>  ->  ,  <param>  <param_next>  
+61  <reclaim_opt>  ->  reclaim  <reclaim_value>  
+62  <reclaim_opt>  ->  λ  
+63  <reclaim_value>  ->  <expression>  ;  
+64  <reclaim_value>  ->  ;  
+65  <statement>  ->  <simple_stmt>  <statement>  
+66  <statement>  ->  λ  
+67  <simple_stmt>  ->  id  <id_stmt>  
+68  <simple_stmt>  ->  <inc_dec_op>  id  ;  
+69  <simple_stmt>  ->  <io_stmt>  
+70  <simple_stmt>  ->  <conditional_stmt>  
+71  <simple_stmt>  ->  <loop_stmt>  
+72  <simple_stmt>  ->  <switch_stmt>  
+73  <simple_stmt>  ->  <control_stmt>  
+74  <simple_stmt>  ->  reclaim  <reclaim_value>  
+75  <simple_stmt>  ->  <var_dec>  ;  
+76  <simple_stmt>  ->  <const_dec>  ;  
+77  <id_stmt>  ->  <id_next>  <assign_op>  <assign_rhs>  ;  
+78  <id_stmt>  ->  <inc_dec_op>  ;  
+79  <id_stmt>  ->  (  <arguments>  )  ;  
+80  <assignment_stmt>  
+->  <value>  <assign_op>  <assign_rhs>  ;  
+81  <assign_rhs>  ->  water  (  <water_arg>  )  
+82  <assign_rhs>  ->  <expression>  
+83  <assign_op>  ->  =  
+84  <assign_op>  ->  +=  
+85  <assign_op>  ->  -=  
+86  <assign_op>  ->  *=  
+87  <assign_op>  ->  /=  
+88  <assign_op>  ->  %=  
+89  <value>  ->  id  <id_next>  
+90  <id_next>  ->  <array_access>  <post_array_access>  
+91  <id_next>  ->  <struct_access>  
+92  <id_next>  ->  λ  
+93  <array_access>  ->  [  <expression>  ]  <array_access_more>  
+94  <array_access_more>  
+->  [  <expression>  ]  <array_access_more>  
+95  <array_access_more>  
+->  λ  
+96  <struct_access>  ->  .  id  <struct_access_more>  
+97  <struct_access_more>  
+->  .  id  <struct_access_more>  
+98  <struct_access_more>  
+->  λ  
+99  <post_array_access>  
+->  .  id  <post_array_access>  
+100  <post_array_access>  
+->  λ  
+101  <io_stmt>  ->  plant  (  <arguments>  )  ;  
+102  <io_stmt>  ->  water  (  <water_arg>  )  ;  
+103  <water_arg>  ->  <data_type>  
+104  <water_arg>  ->  id  <water_id_tail>  
+105  <water_arg>  ->  λ  
+106  <water_id_tail>  ->  [  <expression>  ]  <water_id_tail>  
+107  <water_id_tail>  ->  λ  
+108  <arguments>  ->  <expression>  <arg_next>  
+109  <arguments>  ->  λ  
+110  <arg_next>  ->  ,  <expression>  <arg_next>  
+111  <arg_next>  ->  λ  
+112  <conditional_stmt>  
+->  spring  (  <expression>  )  {  <statement>  }  <elseif_chain>  <else_opt>  
+113  <elseif_chain>  ->  bud  (  <expression>  )  {  <statement>  }  <elseif_chain>  
+114  <elseif_chain>  ->  λ  
+115  <else_opt>  ->  wither  {  <statement>  }  
+116  <else_opt>  ->  λ  
+117  <loop_stmt>  ->  grow  (  <expression>  )  {  <statement>  }  
+118  <loop_stmt>  ->  cultivate  (  <for_init>  ;  <expression>  ;  <for_update>  )  {  <statement>  }  
+119  <loop_stmt>  ->  tend  {  <statement>  }  grow  (  <expression>  )  ;  
+120  <for_init>  ->  <data_type>  id  <array_dec>  <var_value>  
+121  <for_init>  ->  id  <id_next>  <assign_op>  <expression>  
+122  <for_init>  ->  λ  
+123  <for_update>  ->   id  <for_update_type>  
+124  <for_update>  ->  λ  
+125  <for_update_type>  
+->  <inc_dec_op>  
+126  <for_update_type>  
+->  <id_next>  <assign_op>  <expression>  
+127  <unary_stmt>  ->  id  <inc_dec_op>  ;  
+128  <inc_dec_op>  ->  ++  
+129  <inc_dec_op>  ->  --  
+130  <switch_stmt>  ->  harvest  (  <expression>  )  {  <case_list>  <default_opt>  }  
+131  <case_list>  ->  variety  <case_literal>  :  <case_statements>  <case_list>  
+132  <case_list>  ->  λ  
+133  <case_literal>  ->  intlit  
+134  <case_literal>  ->  dblit  
+135  <case_literal>  ->  chrlit  
+136  <case_literal>  ->  stringlit  
+137  <case_literal>  ->  sunshine  
+138  <case_literal>  ->  frost  
+139  <case_statements>  
+->  <case_statement>  <case_statements>  
+140  <case_statements>  
+->  λ  
+141  <case_statement>  ->  id  <id_stmt>  
+142  <case_statement>  ->  <inc_dec_op>  id  ;  
+143  <case_statement>  ->  <var_dec>  ;  
+144  <case_statement>  ->  <io_stmt>  
+145  <case_statement>  ->  <conditional_stmt>  
+146  <case_statement>  ->  <loop_stmt>  
+147  <case_statement>  ->  <switch_stmt>  
+148  <case_statement>  ->  {  <case_statements>  }  
+149  <case_statement>  ->  prune  ;  
+150  <case_statement>  ->  skip  ;  
+151  <case_statement>  ->  reclaim  <reclaim_value>  
+152  <default_opt>  ->  soil  :  <case_statements>  
+153  <default_opt>  ->  λ  
+154  <control_stmt>  ->  prune  ;  
+155  <control_stmt>  ->  skip  ;  
+156  <function_call>  ->  id  (  <arguments>  )  ;  
+157  <expression>  ->  <logic_or>  
+158  <logic_or>  ->  <logic_and>  <logic_or_next>  
+159  <logic_or_next>  ->  ||  <logic_and>  <logic_or_next>  
+160  <logic_or_next>  ->  λ  
+161  <logic_and>  ->  <relational>  <logic_and_next>  
+162  <logic_and_next>  ->  &&  <relational>  <logic_and_next>  
+163  <logic_and_next>  ->  λ  
+164  <relational>  ->  <arithmetic>  <relational_next>  
+165  <relational_next>  
+->  <relational_op>  <arithmetic>  
+166  <relational_next>  
+->  λ  
+167  <relational_op>  ->  >  
+168  <relational_op>  ->  <  
+169  <relational_op>  ->  >=  
+170  <relational_op>  ->  <=  
+171  <relational_op>  ->  ==  
+172  <relational_op>  ->  !=  
+173  <arithmetic>  ->  <term>  <arithmetic_next>  
+174  <arithmetic_next>  
+->  +  <term>  <arithmetic_next>  
+175  <arithmetic_next>  
+->  -  <term>  <arithmetic_next>  
+176  <arithmetic_next>  
+->  \  <arithmetic_next>`  
+177  <arithmetic_next>  
+->  λ  
+178  <term>  ->  <factor>  <term_next>  
+179  <term_next>  ->  *  <factor>  <term_next>  
+180  <term_next>  ->  /  <factor>  <term_next>  
+181  <term_next>  ->  %  <factor>  <term_next>  
+182  <term_next>  ->  λ  
+183  <factor>  ->  (  <paren_expr>  
+184  <factor>  ->  <unary_op>  <factor>  
+185  <factor>  ->  id  <factor_id_next>  
+186  <factor>  ->  intlit  
+187  <factor>  ->  dblit  
+188  <factor>  ->  chrlit  
+189  <factor>  ->  stringlit  
+190  <factor>  ->  sunshine  
+191  <factor>  ->  frost  
+192  <paren_expr>  ->  <data_type>  )  <factor>  
+193  <paren_expr>  ->  <expression>  )  
+194  <unary_op>  ->  ~  
+195  <unary_op>  ->  !  
+196  <factor_id_next>  ->  <array_access>  <post_array_access>  
+197  <factor_id_next>  ->  <struct_access>  
+198  <factor_id_next>  ->  (  <arguments>  )  
+199  <factor_id_next>  ->  λ   

Docus & mps/CFG_live_from_code.txt

@@ -0,0 +1,199 @@
+<program> -> <global_declaration> <function_definition> root ( ) { <statement> }
+<global_declaration> -> bundle id <bundle_or_var> <global_declaration>
+<global_declaration> -> <data_type> id <array_dec> <var_value> ; <global_declaration>
+<global_declaration> -> fertile <data_type> id = <init_val> <const_next> ; <global_declaration>
+<global_declaration> -> λ
+<bundle_or_var> -> { <bundle_members> } ;
+<bundle_or_var> -> <bundle_mem_dec> ;
+<declaration> -> <var_dec> ; <declaration>
+<declaration> -> <const_dec> ; <declaration>
+<declaration> -> λ
+<data_type> -> seed
+<data_type> -> tree
+<data_type> -> leaf
+<data_type> -> branch
+<data_type> -> vine
+<const_dec> -> fertile <data_type> id = <init_val> <const_next>
+<const_next> -> , id = <init_val> <const_next>
+<const_next> -> λ
+<var_dec> -> <data_type> id <array_dec> <var_value>
+<var_dec> -> bundle id <bundle_mem_dec>
+<bundle_mem_dec> -> id <array_dec> <var_value_next>
+<bundle_mem_dec> -> , id <var_value_next>
+<bundle_mem_dec> -> λ
+<var_value> -> = <init_val> <var_value_next>
+<var_value> -> <var_value_next>
+<var_value_next> -> , id <array_dec> <var_value>
+<var_value_next> -> λ
+<init_val> -> <array_init_opt>
+<init_val> -> water ( <water_arg> )
+<init_val> -> <expression>
+<array_dec> -> [ <array_dim_opt> ] <array_dec>
+<array_dec> -> λ
+<array_dim_opt> -> intlit
+<array_dim_opt> -> dblit
+<array_dim_opt> -> λ
+<array_init_opt> -> { <init_vals> }
+<array_init_opt> -> λ
+<init_vals> -> <init_val_item> <init_vals_next>
+<init_vals> -> λ
+<init_vals_next> -> , <init_val_item> <init_vals_next>
+<init_vals_next> -> λ
+<init_val_item> -> { <init_vals> }
+<init_val_item> -> <expression>
+<bundle_declaration> -> bundle id { <bundle_members> }
+<bundle_members> -> <data_type> id ; <bundle_members>
+<bundle_members> -> id id ; <bundle_members>
+<bundle_members> -> λ
+<function_definition> -> pollinate <return_type> id ( <parameters> ) { <statement> } <function_definition>
+<function_definition> -> λ
+<return_type> -> <data_type>
+<return_type> -> empty
+<return_type> -> id
+<parameters> -> λ
+<parameters> -> <param> <param_next>
+<param> -> <data_type> id <param_array>
+<param> -> id id
+<param_array> -> λ
+<param_array> -> [ ]
+<param_next> -> λ
+<param_next> -> , <param> <param_next>
+<reclaim_opt> -> reclaim <reclaim_value>
+<reclaim_opt> -> λ
+<reclaim_value> -> <expression> ;
+<reclaim_value> -> ;
+<statement> -> <simple_stmt> <statement>
+<statement> -> λ
+<simple_stmt> -> id <id_stmt>
+<simple_stmt> -> <inc_dec_op> id ;
+<simple_stmt> -> <io_stmt>
+<simple_stmt> -> <conditional_stmt>
+<simple_stmt> -> <loop_stmt>
+<simple_stmt> -> <switch_stmt>
+<simple_stmt> -> <control_stmt>
+<simple_stmt> -> reclaim <reclaim_value>
+<simple_stmt> -> <var_dec> ;
+<simple_stmt> -> <const_dec> ;
+<id_stmt> -> <id_next> <assign_op> <assign_rhs> ;
+<id_stmt> -> <inc_dec_op> ;
+<id_stmt> -> ( <arguments> ) ;
+<assignment_stmt> -> <value> <assign_op> <assign_rhs> ;
+<assign_rhs> -> water ( <water_arg> )
+<assign_rhs> -> <expression>
+<assign_op> -> =
+<assign_op> -> +=
+<assign_op> -> -=
+<assign_op> -> *=
+<assign_op> -> /=
+<assign_op> -> %=
+<value> -> id <id_next>
+<id_next> -> <array_access> <post_array_access>
+<id_next> -> <struct_access>
+<id_next> -> λ
+<array_access> -> [ <expression> ] <array_access_more>
+<array_access_more> -> [ <expression> ] <array_access_more>
+<array_access_more> -> λ
+<struct_access> -> . id <struct_access_more>
+<struct_access_more> -> . id <struct_access_more>
+<struct_access_more> -> λ
+<post_array_access> -> . id <post_array_access>
+<post_array_access> -> λ
+<io_stmt> -> plant ( <arguments> ) ;
+<io_stmt> -> water ( <water_arg> ) ;
+<water_arg> -> <data_type>
+<water_arg> -> id <water_id_tail>
+<water_arg> -> λ
+<water_id_tail> -> [ <expression> ] <water_id_tail>
+<water_id_tail> -> λ
+<arguments> -> <expression> <arg_next>
+<arguments> -> λ
+<arg_next> -> , <expression> <arg_next>
+<arg_next> -> λ
+<conditional_stmt> -> spring ( <expression> ) { <statement> } <elseif_chain> <else_opt>
+<elseif_chain> -> bud ( <expression> ) { <statement> } <elseif_chain>
+<elseif_chain> -> λ
+<else_opt> -> wither { <statement> }
+<else_opt> -> λ
+<loop_stmt> -> grow ( <expression> ) { <statement> }
+<loop_stmt> -> cultivate ( <for_init> ; <expression> ; <for_update> ) { <statement> }
+<loop_stmt> -> tend { <statement> } grow ( <expression> ) ;
+<for_init> -> <data_type> id <array_dec> <var_value>
+<for_init> -> id <id_next> <assign_op> <expression>
+<for_init> -> λ
+<for_update> -> id <for_update_type>
+<for_update> -> λ
+<for_update_type> -> <inc_dec_op>
+<for_update_type> -> <id_next> <assign_op> <expression>
+<unary_stmt> -> id <inc_dec_op> ;
+<inc_dec_op> -> ++
+<inc_dec_op> -> --
+<switch_stmt> -> harvest ( <expression> ) { <case_list> <default_opt> }
+<case_list> -> variety <case_literal> : <case_statements> <case_list>
+<case_list> -> λ
+<case_literal> -> intlit
+<case_literal> -> dblit
+<case_literal> -> chrlit
+<case_literal> -> stringlit
+<case_literal> -> sunshine
+<case_literal> -> frost
+<case_statements> -> <case_statement> <case_statements>
+<case_statements> -> λ
+<case_statement> -> id <id_stmt>
+<case_statement> -> <inc_dec_op> id ;
+<case_statement> -> <var_dec> ;
+<case_statement> -> <io_stmt>
+<case_statement> -> <conditional_stmt>
+<case_statement> -> <loop_stmt>
+<case_statement> -> <switch_stmt>
+<case_statement> -> { <case_statements> }
+<case_statement> -> prune ;
+<case_statement> -> skip ;
+<case_statement> -> reclaim <reclaim_value>
+<default_opt> -> soil : <case_statements>
+<default_opt> -> λ
+<control_stmt> -> prune ;
+<control_stmt> -> skip ;
+<function_call> -> id ( <arguments> ) ;
+<expression> -> <logic_or>
+<logic_or> -> <logic_and> <logic_or_next>
+<logic_or_next> -> || <logic_and> <logic_or_next>
+<logic_or_next> -> λ
+<logic_and> -> <relational> <logic_and_next>
+<logic_and_next> -> && <relational> <logic_and_next>
+<logic_and_next> -> λ
+<relational> -> <arithmetic> <relational_next>
+<relational_next> -> <relational_op> <arithmetic>
+<relational_next> -> λ
+<relational_op> -> >
+<relational_op> -> <
+<relational_op> -> >=
+<relational_op> -> <=
+<relational_op> -> ==
+<relational_op> -> !=
+<arithmetic> -> <term> <arithmetic_next>
+<arithmetic_next> -> + <term> <arithmetic_next>
+<arithmetic_next> -> - <term> <arithmetic_next>
+<arithmetic_next> -> ` <term> <arithmetic_next>
+<arithmetic_next> -> λ
+<term> -> <factor> <term_next>
+<term_next> -> * <factor> <term_next>
+<term_next> -> / <factor> <term_next>
+<term_next> -> % <factor> <term_next>
+<term_next> -> λ
+<factor> -> ( <paren_expr>
+<factor> -> <unary_op> <factor>
+<factor> -> id <factor_id_next>
+<factor> -> intlit
+<factor> -> dblit
+<factor> -> chrlit
+<factor> -> stringlit
+<factor> -> sunshine
+<factor> -> frost
+<paren_expr> -> <data_type> ) <factor>
+<paren_expr> -> <expression> )
+<unary_op> -> ~
+<unary_op> -> !
+<factor_id_next> -> <array_access> <post_array_access>
+<factor_id_next> -> <struct_access>
+<factor_id_next> -> ( <arguments> )
+<factor_id_next> -> λ

Docus & mps/DEFENSE_03_lexer.md

@@ -0,0 +1,791 @@
+# GAL Compiler — Defense-Prep Walkthrough
+
+## File 3 of 9: `lexer.py` — the `Lexer` class itself
+
+This is the **scanner** (lexical analyzer) of GAL. It is where raw character text becomes a stream of tokens. The file is large (~1900 lines) because GAL has 26 reserved words, 5 data types, ~20 operators, 5 literal kinds, two comment styles, and strict per-keyword delimiter rules. The entire file is built around **one big function**: `Lexer.make_tokens()`.
+
+---
+
+## 1. FILE PURPOSE
+
+`lexer.py` performs **lexical analysis** — phase 1 of compilation. Its responsibilities:
+
+1. Read the GAL source code character by character.
+2. Group characters into **lexemes** and tag each with a **token type** (a `Token` object).
+3. **Track line and column** so every token knows where it came from in the source.
+4. **Detect lexical errors** (illegal characters, malformed numbers, unclosed strings/comments, bad delimiters) and produce `LexicalError` objects — without crashing.
+5. **Skip whitespace and comments** entirely (they never become tokens).
+6. **Recognize keywords vs identifiers** with a transition-diagram-style hand-written FSM, one branch per starting letter.
+7. Emit a final `EOF` token so the parser knows when input ends.
+
+Where it sits in the pipeline:
+
+```
+   Source code (Python string)
+            │
+            ▼
+   ┌──────────────────┐
+   │ Lexer (this file)│
+   └──────────────────┘
+            │
+   ─ tokens, errors ─→ server.py / parser
+```
+
+What depends on it:
+
+| File | What it imports | When used |
+|---|---|---|
+| `server.py` | `lex`, `get_token_description` | Every API endpoint runs `lex(source_code)` first |
+| `Gal_Parser.py` | (consumes tokens, doesn't import the lexer module) | Receives tokens to drive the LL(1) parser |
+| `GALsemantic.py` | `Lexer` (for some tests) | Uses `analyze_semantics(tokens)` legacy path |
+| `icg.py` | (consumes tokens) | Reads the same token stream to emit display TAC |
+
+The lexer **does not** depend on anything other than the token/Position/error classes that live at the top of the same file. That makes it easy to test in isolation.
+
+---
+
+## 2. IMPORTS / DEPENDENCIES
+
+**The lexer file has zero `import` statements.** Everything it needs — the character classes, the token-type constants, the `Position`, `LexicalError`, and `Token` classes — is defined in the same file (the part covered in defense file #2 of this series).
+
+This is intentional. The lexer must be a pure data-processing function with no side effects beyond producing tokens. By avoiding imports, we guarantee:
+
+- It can be unit-tested without setting up Flask, Socket.IO, or eventlet.
+- It has no hidden global state from other modules.
+- Removing or renaming any import in `server.py` cannot break tokenization.
+
+**Defense answer:** *"The lexer is self-contained. The only data structures it uses are defined in the same file. This isolates the most-tested, most-critical phase of the compiler from runtime concerns."*
+
+---
+
+## 3. GLOBAL CONSTANTS / VARIABLES
+
+The lexer relies on the constants defined at the top of `lexer.py` (these were covered in defense file #2). Briefly:
+
+- **Character classes** — `ZERO`, `DIGIT`, `ZERODIGIT`, `LOW_ALPHA`, `UPPER_ALPHA`, `ALPHA`, `ALPHANUM` — used to test `if self.current_char in ALPHA:` etc.
+- **Delimiter sets** — `space_delim`, `delim2` … `delim24`, `idf_delim`, `whlnum_delim`, `decim_delim` — each one is the set of characters that may legally follow a particular kind of token. The actively-used ones (`space_delim`, `delim4`, `delim6`, `delim7`, `delim8`, `delim23`, `idf_delim`, `whlnum_delim`, `decim_delim`) drive lookahead checks in the scanner. The numbered ones are kept as 1-to-1 documentation mapping back to the GAL proposal's regular-definition table.
+- **Token-type constants** (`TT_*`) — what each emitted `Token` is tagged with.
+
+The `Lexer` instance itself owns three pieces of state:
+
+```python
+self.source_code   # the raw input string
+self.pos           # a Position(index, line, col) — current scan location
+self.current_char  # the character at self.pos.index, or None at EOF
+```
+
+That's it. No caches, no counters outside the loop. Everything else lives in local variables of `make_tokens()`.
+
+---
+
+## 4. CLASSES AND FUNCTIONS
+
+This file exposes one class (`Lexer`) and two module-level functions (`run` and `lex`). The `Lexer` class has three methods.
+
+### 4.1 `Lexer.__init__(source_code)` (lines 307-311)
+
+```python
+def __init__(self, source_code):
+    self.source_code = source_code.replace('\r', '')
+    self.pos = Position(-1, 1, -1)
+    self.current_char = None
+    self.advance()
+```
+
+**Receives:** the full GAL source code as a Python string.
+
+**Returns / modifies:** populates the three instance fields and primes `current_char` to the first character of the source.
+
+**Why it exists:** sets up scanner state. The `\r` strip handles Windows line endings (`\r\n`) so the rest of the lexer only ever has to consider `\n`.
+
+**Why `Position(-1, 1, -1)`:** the position starts *before* the first character. The very first call to `self.advance()` will move it to index 0, line 1, column 0 — the actual start of the source.
+
+**Compiler stage:** Lexical (setup).
+
+### 4.2 `Lexer.advance()` (lines 313-317)
+
+```python
+def advance(self):
+    self.pos.advance(self.current_char)
+    self.current_char = (
+        self.source_code[self.pos.index]
+        if self.pos.index < len(self.source_code) else None
+    )
+```
+
+**Receives:** nothing.
+
+**Returns / modifies:** `self.pos` is incremented (line/column updated based on the *previous* `current_char`); `self.current_char` is set to the next source character or `None` if past the end.
+
+**Why it exists:** every scanner branch in `make_tokens` calls `self.advance()` to move forward by one character. Centralizing it ensures consistent line/column tracking.
+
+**Edge case:** when EOF is reached, `self.current_char` becomes `None`. Every scanner branch checks `is not None` before reading.
+
+### 4.3 `Lexer.make_tokens()` (lines 319-1832 — the heart of the lexer)
+
+```python
+def make_tokens(self):
+    tokens = []
+    line = 1
+    errors = []
+    pos = self.pos.copy()
+    while self.current_char != None:
+        # ... one big if-elif-else over current_char ...
+    if self.current_char is None:
+        tokens.append(Token(TT_EOF, "", line, pos.col))
+    return tokens, errors
+```
+
+**Receives:** nothing (operates on `self.source_code`).
+
+**Returns:** the tuple `(tokens, errors)` — a list of `Token` objects and a list of `LexicalError` objects.
+
+**Why it exists:** this is the scanner. Every character of the source goes through this loop exactly once. Each iteration recognizes one lexeme and emits at most one token (whitespace and comments emit nothing).
+
+**Edge cases:**
+- Empty source: the `while` loop never runs, EOF is appended, `(([EOF], [])` is returned.
+- Source with only comments: tokens list contains only EOF.
+- Source with only errors: tokens list may still contain valid tokens before/after each error.
+
+**Defense framing:** *"Make_tokens is one big dispatch. The first character of each lexeme decides which branch to take. Inside each branch we keep reading characters as long as they belong to the current token, then emit it. Errors are collected — never raised — so we can report multiple problems in one pass."*
+
+### 4.4 `run(source_code)` and `lex(source_code)` module-level helpers (lines 1838-1880)
+
+```python
+def run(source_code):
+    """Legacy function - runs lexer and returns tokens and errors."""
+    lexer = Lexer(source_code)
+    return lexer.make_tokens()
+
+def lex(source_code):
+    """Main entry point for lexical analysis (used by server.py)."""
+    lexer = Lexer(source_code)
+    tokens, errors = lexer.make_tokens()
+    str_errors = [e.as_string() if hasattr(e, 'as_string') else str(e)
+                  for e in errors]
+    return tokens, str_errors
+```
+
+**Why two:**
+
+- `run()` is the **legacy** entry point (kept for older grading/test scripts that imported it). Returns raw `LexicalError` objects.
+- `lex()` is the **production** entry point used by `server.py`. It additionally converts each error into its formatted string via `as_string()`, because the HTTP/JSON layer needs strings, not Python objects.
+
+**Stage:** Lexical (public interface).
+
+**Defense answer for "why two?":** *"`run` is kept for backwards compatibility with grading scripts. `lex` is what the server uses — it adds error-to-string conversion so the JSON response is ready to serialize."*
+
+---
+
+## 5. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+The body of `make_tokens` is a huge `if … elif … elif … else` chain. I'll walk the most important branches in the order they appear. Every branch follows the same pattern: detect the start character → consume the lexeme → emit a token (or an error) → `continue` the loop.
+
+### 5.1 The keyword/identifier scanner — letter-by-letter FSM (lines 338-940)
+
+```python
+if self.current_char in ALPHA:
+    ident_str = ''
+    pos = self.pos.copy()
+
+    if self.current_char == "b":
+        ident_str += self.current_char
+        self.advance()
+        if self.current_char == "r":  # branch
+            ident_str += self.current_char
+            self.advance()
+            if self.current_char == "a":
+                ...
+                # eventually:
+                if self.current_char is None or self.current_char in space_delim:
+                    tokens.append(Token(TT_RW_BRANCH, ident_str, line, pos.col))
+                    continue
+        elif self.current_char == "u":
+            ...  # bud / bundle
+    elif self.current_char == "c":
+        ...  # cultivate
+    elif self.current_char == "e":
+        ...  # empty
+    elif self.current_char == "f":
+        ...  # frost / fertile
+    elif self.current_char == "g":
+        ...  # grow
+    # ... and so on for h, l, p, r, s, t, v, w
+```
+
+**What this block does:** Hand-written transition diagram. For each letter the source could start with that begins a GAL keyword, there is an explicit nested `if` chain that walks character-by-character down the keyword's spelling. If the chain completes AND the next character is a valid delimiter (space, `;`, `{`, etc.), a keyword `Token` is emitted.
+
+**Why hand-written and not regex/dictionary?**
+
+- **Visibility for the panel**: this is the implementation of the **transition diagrams** in the GAL compiler proposal. Each `if` chain corresponds to one DFA path in the spec. A panelist can point at any `if "h"` branch and it maps directly to the proposal's "harvest" transition diagram.
+- **Per-keyword delimiter rules**: GAL is strict about what may come after each keyword. `bud` requires `:` or `(` to follow (delim4); `fertile` requires `;` (delim8); `plant` allows `;`, `(`, `,`, etc. (delim6). With a regex-based approach, this would all be a separate validation step. With the hand-written FSM, the delimiter check is in-line right where the keyword is recognized.
+- **Identifier fallback**: if the chain breaks (e.g., `b` is followed by `e`, not `r` or `u`), control falls through to a generic "scan an identifier" loop that runs at the end of the block (lines 802-940 in the file). The result is `Token('id', ident_str, ...)`.
+
+**Why the spec-derived scanner uses delimiter sets:**
+
+```python
+if self.current_char is None or (self.current_char is not None and self.current_char.isspace()) or self.current_char in delim4:
+    tokens.append(Token(TT_RW_CULTIVATE, ident_str, line, pos.col))
+    continue
+elif self.current_char is not None and not self.current_char.isspace() and self.current_char not in delim4 and self.current_char not in ALPHANUM:
+    errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))
+    self.advance()
+    continue
+```
+
+This pattern repeats for every keyword. The two cases are:
+
+1. **Valid delimiter** (`delim4` for `cultivate`) — emit the keyword token, continue.
+2. **Invalid non-alphanumeric delimiter** (e.g., `cultivate$`) — report a delimiter error.
+
+The third implicit case — character is alphanumeric — means the keyword spelling matched a *prefix* but the user actually typed a longer identifier (e.g., `cultivate1`). Control falls out of the keyword branch and into the generic identifier loop, which builds `Token('id', 'cultivate1')`.
+
+**Defense answer:** *"The keyword scanner is a hand-written transition diagram, one branch per starting letter. This mirrors the FSMs documented in our compiler proposal. After spelling out each keyword, we check that the next character is a valid delimiter for that specific keyword — for example, `cultivate` may only be followed by `:`, `(`, or whitespace because it's a control-flow header. If the next character is alphanumeric instead, we treat the prefix as part of an identifier."*
+
+### 5.2 The negative-literal scanner — `~` (lines 991-1049)
+
+This is the most distinctive part of GAL — `~` is the negative sign.
+
+```python
+elif self.current_char == "~":  # Added for negative prefix
+    ident_str = self.current_char
+    pos = self.pos.copy()
+    self.advance()
+
+    # If ~ is directly followed by a digit, consume the number as a negative literal
+    if self.current_char is not None and self.current_char in ZERODIGIT:
+        # Read integer digits
+        num_str = ""
+        integer_digit_count = 0
+        while self.current_char is not None and self.current_char in ZERODIGIT:
+            integer_digit_count += 1
+            num_str += self.current_char
+            self.advance()
+
+        # Check for decimal point (negative double)
+        if self.current_char == ".":
+            ...
+            tokens.append(Token(TT_DOUBLELIT, ident_str, line, pos.col))
+            continue
+        else:
+            # Negative integer
+            if integer_digit_count > 8:
+                errors.append(LexicalError(pos, f"Integer exceeds maximum of 8 digits"))
+                continue
+            num_str = num_str.lstrip("0") or "0"
+            ident_str = "~" + num_str
+            tokens.append(Token(TT_INTEGERLIT, ident_str, line, pos.col))
+            continue
+
+    # ~ not followed by a digit: emit as negate operator
+    elif self.current_char is None or self.current_char in ALPHANUM + ' \t\n':
+        tokens.append(Token(TT_NEGATIVE, ident_str, line, pos.col))
+        continue
+    else:
+        errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'."))
+        self.advance()
+        continue
+```
+
+**What this block does:** The lexer treats `~` two different ways depending on what comes next:
+
+1. **`~` followed by a digit** (e.g., `~5`, `~3.14`) — fold the sign into a literal token. The result is a single `Token('intlit', '~5', …)` or `Token('dbllit', '~3.14', …)`. The `~` stays in the value string so the interpreter can recognize it later and emit a real negative number.
+2. **`~` followed by an identifier or a paren** (e.g., `~x`, `~(a + b)`) — emit a separate `Token('~', '~', …)` (the `TT_NEGATIVE` operator). The parser's grammar treats this as a unary minus prefix on an expression.
+
+**Why both behaviors:** for literals, folding the sign at lex time means the parser never needs a "unary minus" production in front of every integer or double — the literal already carries the sign. For variables, we *can't* fold because the value isn't known yet, so we keep the operator as a separate token.
+
+**Defense answer:** *"GAL uses `~` for negation. The lexer pre-folds `~5` into a single negative integer literal at scan time, but emits `~` as a separate operator token when it precedes an identifier. This avoids a unary-minus production in the grammar for the literal case."*
+
+### 5.3 Maximal-munch operator scanners (lines 1051-1283)
+
+```python
+elif self.current_char == "!":
+    ident_str = self.current_char
+    pos = self.pos.copy()
+    self.advance()
+    if self.current_char == "=":
+        ident_str += self.current_char
+        self.advance()
+        tokens.append(Token(TT_NOTEQ, ident_str, line, pos.col))
+        continue
+    else:
+        tokens.append(Token(TT_NOT, ident_str, line, pos.col))
+        continue
+```
+
+**Pattern:** when the current character could start either a 1-char or a 2-char operator (e.g., `!` could be NOT or `!=`), we read the first char, **peek** at the next, and decide:
+
+- If the next char extends the operator → emit the longer token.
+- Otherwise → emit the shorter token.
+
+This is **maximal munch** — the classic lexer rule "always grab the longest valid token."
+
+**Operators handled this way:**
+
+| Single | Double | Triple-extended |
+|---|---|---|
+| `!` | `!=` | — |
+| `=` | `==` | `===` is detected by the parser as `==` followed by `=` (we deliberately don't make a `TT_TRIPLEEQ` token; the parser issues a friendlier error) |
+| `<` | `<=` | — |
+| `>` | `>=` | — |
+| `+` | `++`, `+=` | — |
+| `-` | `--`, `-=` | — |
+| `*` | `**`, `*=` | — |
+| `/` | `/=`, also `//` (single-line comment), `/*` (multi-line comment) | — |
+| `%` | `%=` | — |
+| `&` | `&&` | — (single `&` is captured as `TT_SINGLE_AND` so the parser can flag it as invalid) |
+| `\|` | `\|\|` | — (single `\|` is captured as `TT_SINGLE_OR`) |
+
+**Why we emit `TT_SINGLE_AND` and `TT_SINGLE_OR`:** if the user writes `a & b`, the lexer doesn't crash — it produces a token with type `&`. The parser's grammar has no rule that accepts `&` alone, so it produces the error *"Invalid operator '&'. Did you mean '&&'?"*. By passing it through as a token, error reporting happens at the layer that knows the most context.
+
+**Defense answer for maximal munch:** *"For multi-character operators we use the maximal-munch rule. We read one character, peek the next, and if together they form a longer operator we emit the longer token. This is what a textbook lexer does and resolves all ambiguity between e.g. `=` (assignment) and `==` (equality)."*
+
+**Defense answer for `&` and `|`:** *"We tokenize single ampersand and single pipe as `TT_SINGLE_AND` and `TT_SINGLE_OR` — token types that the parser explicitly does not accept. This means the user gets a syntax error at the parser layer with the full grammar context, instead of a misleading lexical error."*
+
+### 5.4 Newline, tab, space — whitespace handling (lines 1286-1313)
+
+```python
+elif self.current_char == '\n':
+    pos = self.pos.copy()
+    if tokens and tokens[-1].type != TT_NL:
+        tokens.append(Token(TT_NL, "\\n", line, pos.col))
+    while self.current_char == '\t' or self.current_char == ' ' or self.current_char == '\n':
+        if self.current_char == '\t' or self.current_char == ' ':
+            self.advance()
+        else:
+            line += 1
+            self.advance()
+    continue
+
+elif self.current_char == '\t':
+    ident_str = self.current_char
+    pos = self.pos.copy()
+    while self.current_char == '\t':
+        self.advance()
+    continue
+
+elif self.current_char == ' ':
+    ident_str = self.current_char
+    pos = self.pos.copy()
+    self.advance()
+    while self.current_char == ' ':
+        self.advance()
+    continue
+```
+
+**What this block does:**
+
+- A single `\n` token is emitted to mark the end of a logical line, but **only if** the last token wasn't already a `\n` — this collapses multiple consecutive blank lines into one newline token.
+- The inner `while` loop advances past *all* contiguous whitespace (spaces, tabs, newlines), so the next iteration of the outer loop starts at a real character.
+- For tabs and spaces alone, the consumed whitespace is discarded entirely (no token emitted).
+
+**Why emit `TT_NL` tokens at all when the parser is configured to skip them?** Because the lexer's *line counter* depends on counting newlines. The token is also useful for error recovery and for the IDE's lexeme view. The parser is configured with `skip_token_types={'\n'}` so it transparently ignores them during parsing.
+
+**Why the `if tokens and tokens[-1].type != TT_NL` guard:** Prevents a sequence like `\n\n\n\n` from emitting four `TT_NL` tokens — only one is needed.
+
+**Defense answer:** *"Whitespace is consumed but not emitted as tokens, except newlines. Newlines are emitted exactly once per logical line break so the parser's line tracking and the IDE's lexeme view stay accurate. The parser is configured to skip newline tokens during shift operations."*
+
+### 5.5 Forward slash — division, comments, and divide-assign (lines 1318-1370)
+
+```python
+elif self.current_char == "/":
+    ident_str = self.current_char
+    pos = self.pos.copy()
+    self.advance()
+
+    if self.current_char == "/":  # Single-line comment: // comment text
+        ident_str += self.current_char
+        self.advance()
+        while self.current_char is not None and self.current_char != "\n":
+            ident_str += self.current_char
+            self.advance()
+        continue
+
+    elif self.current_char == "*":  # Multi-line comment: /* ... */
+        ident_str += self.current_char
+        self.advance()
+        found_close = False
+        while self.current_char is not None:
+            if self.current_char == "*" and self.pos.index + 1 < len(self.source_code) and self.source_code[self.pos.index + 1] == "/":
+                ident_str += "*/"
+                self.advance()
+                self.advance()
+                found_close = True
+                break
+            else:
+                ident_str += self.current_char
+                if self.current_char == "\n":
+                    line += 1
+                self.advance()
+        if not found_close:
+            errors.append(LexicalError(pos, f"Missing closing '*/' after '{ident_str}'"))
+            continue
+        continue
+
+    elif self.current_char == "=":
+        ident_str += self.current_char
+        self.advance()
+        tokens.append(Token(TT_DIVEQ, ident_str, line, pos.col))
+        continue
+
+    else:
+        ...
+        tokens.append(Token(TT_DIV, ident_str, line, pos.col))
+        continue
+```
+
+**What this block does:** the `/` character is a four-way fork:
+
+1. `//` — single-line comment. Consume everything up to (but not including) the next newline. **Comments are NOT emitted as tokens** — they vanish from the token stream entirely.
+2. `/*` — multi-line comment. Consume characters until `*/` is found, tracking line numbers internally. If EOF is reached before `*/`, report *"Missing closing '*/'"*.
+3. `/=` — divide-assign operator.
+4. Plain `/` — division operator.
+
+**Why comments don't become tokens:** they have zero meaning to the parser or any later stage. Suppressing them at the lexer level keeps every later layer simpler.
+
+**Multi-line comment edge case — line counting:** because a `/* ... */` block can span many lines, we explicitly increment `line` whenever we consume a newline inside the comment. Otherwise error messages after a multi-line comment would point at the wrong line.
+
+**Defense answer:** *"The forward slash has four meanings — comment, multi-line comment, divide-assign, division. We resolve them by peeking at the next character. Comments are consumed but never emitted; they don't reach the parser. Unclosed multi-line comments produce a lexical error with the position of the opening `/*`."*
+
+### 5.6 Number scanner — integers and doubles (lines 1418-1625)
+
+```python
+elif self.current_char in ZERODIGIT:
+    dot_count = 0
+    ident_str = ""
+    pos = self.pos.copy()
+    integer_digit_count = 0
+    fractional_digit_count = 0
+
+    # Read all digits before decimal point
+    while self.current_char is not None and self.current_char in ZERODIGIT:
+        integer_digit_count += 1
+        ident_str += self.current_char
+        self.advance()
+
+    # Check for decimal point (converts to double/float)
+    if self.current_char == ".":
+        # ... read fractional part ...
+        # ... validate digit limits ...
+        tokens.append(Token(TT_DOUBLELIT, ident_str, line, pos.col))
+        continue
+
+    # No decimal point — emit as integer
+    if integer_digit_count > 8:
+        # Process integer part in chunks of 8: each chunk beyond the valid last ≤8 digits is an error
+        ...
+    tokens.append(Token(TT_INTEGERLIT, remaining, line, pos.col))
+    continue
+```
+
+**What this block does:** When the current char is a digit (0-9):
+
+1. Read all consecutive digits — the integer part.
+2. If the next character is `.`, this is a double — read the fractional part too.
+3. Validate against GAL's digit limits:
+   - **Integer (`seed`)**: max 8 digits.
+   - **Double (`tree`)**: max 15 digits before decimal, max 8 digits after.
+4. Format the value (strip leading zeros from integer part, drop trailing zeros from fractional part, ensure at least one fractional digit).
+5. Emit `TT_INTEGERLIT` or `TT_DOUBLELIT`.
+
+**Edge case — leading zero stripping:**
+
+```python
+remaining = remaining.lstrip("0") or "0"
+```
+
+The `or "0"` is a Python idiom: if `lstrip("0")` returns the empty string (i.e., the input was all zeros like `"0000"`), keep one zero so the number isn't lost.
+
+**Edge case — trailing zero handling on doubles:**
+
+```python
+fractional_part = (parts[1] if len(parts) > 1 else "").rstrip("0") or "0"
+if fractional_part == "0":
+    num_str = f"{integer_part}.0"
+else:
+    num_str = f"{integer_part}.{fractional_part}"
+```
+
+`3.140` becomes `3.14`; `3.000` becomes `3.0` (we always keep at least one zero after the decimal so it's still recognizable as a double). This keeps display consistent.
+
+**Defense answer:** *"The number scanner reads all consecutive digits, then checks for a decimal point. We enforce the digit limits documented in the GAL specification — 8 digits for integers, 15 left and 8 right for doubles. We also normalize the displayed value: strip leading zeros, drop trailing zeros after the decimal but keep at least one."*
+
+### 5.7 String literal scanner — `"..."` (lines 1631-1692)
+
+```python
+elif self.current_char == '"':
+    string = ''
+    pos = self.pos.copy()
+    escape_character = False
+    string += self.current_char  # opening quote
+    self.advance()
+
+    escape_characters = {
+        'n': '\n', 't': '\t',
+        '{': '\\{', '}': '\\}',
+        '"': '"', '\\': '\\',
+    }
+
+    has_string_error = False
+    while self.current_char is not None and (self.current_char != '"' or escape_character):
+        if escape_character:
+            if self.current_char in escape_characters:
+                string += escape_characters[self.current_char]
+            else:
+                errors.append(LexicalError(pos, f"Invalid escape sequence '\\{self.current_char}'..."))
+                has_string_error = True
+            escape_character = False
+        else:
+            if self.current_char == '\\':
+                escape_character = True
+            elif self.current_char == '\n':
+                break  # newline ends the string (unclosed)
+            else:
+                string += self.current_char
+        self.advance()
+
+    if self.current_char == '"':
+        string += self.current_char
+        self.advance()
+    else:
+        errors.append(LexicalError(pos, f"Missing closing '\"' for string literal"))
+        continue
+
+    tokens.append(Token(TT_STRINGLIT, string, line, pos.col))
+    continue
+```
+
+**What this block does:**
+
+1. Consume the opening `"`.
+2. Read characters until the closing `"`. The `escape_character` flag tracks whether the next character is an escape continuation.
+3. Recognized escapes: `\n`, `\t`, `\{`, `\}`, `\"`, `\\`. Anything else triggers an *"Invalid escape sequence"* error.
+4. A literal newline (not preceded by `\`) inside a string ends the string scan; if the next char is not `"`, the string is unclosed.
+5. Emit `TT_STRINGLIT` whose `value` is the **fully-parsed text** including the quotes (the parser/interpreter peel the quotes off later).
+
+**Why escape sequences are processed at the lexer:** the value stored in the token is the **real** string (with `\n` already converted to a newline char). This matches how C compilers do it — the lexer is the single point that handles escapes, so every later stage sees the actual text the user intended.
+
+**Defense answer:** *"String literals are scanned with a small state machine that tracks whether the next character is part of an escape sequence. Recognized escapes are `\\n`, `\\t`, `\\{`, `\\}`, `\\\"`, `\\\\`. Unclosed strings produce a lexical error with the position of the opening quote so the IDE can highlight the right place."*
+
+### 5.8 Character literal scanner — `'a'` (lines 1698-1777)
+
+```python
+elif self.current_char == "'":
+    string = ''
+    char = ''
+    pos = self.pos.copy()
+    string += self.current_char
+    self.advance()
+    has_error = False
+
+    while self.current_char is not None and self.current_char != "'":
+        if self.current_char == '\n':
+            break
+        elif self.current_char == '\\':
+            string += self.current_char
+            self.advance()
+            if self.current_char in "'\\nt":
+                char += f"\\{self.current_char}"
+                string += self.current_char
+            else:
+                errors.append(LexicalError(pos, f"Invalid escape sequence..."))
+                has_error = True
+                break
+        else:
+            string += self.current_char
+            char += self.current_char
+        self.advance()
+
+    if self.current_char == "'":
+        string += self.current_char
+        self.advance()
+    else:
+        errors.append(LexicalError(pos, f"Missing closing quote..."))
+        continue
+
+    inner = char.strip()
+    if len(inner) == 0:
+        # Empty char literal '' defaults to a space character
+        ...
+    elif len(inner) > 1:
+        errors.append(LexicalError(pos, f"Character literal must contain exactly one character..."))
+        continue
+
+    tokens.append(Token(TT_CHARLIT, string, line, pos.col))
+    continue
+```
+
+**What this block does:** Like strings, but enforces **exactly one character** between the quotes. Multi-char content like `'AB'` is rejected with *"Character literal must contain exactly one character"*.
+
+**Special cases:**
+- Empty `''` is treated as a space character (defensive default).
+- Escape sequences `\n`, `\t`, `\\`, `\'` are accepted and treated as one character.
+- Newline inside the literal ends scanning; reported as unclosed.
+
+**Defense answer:** *"A character literal is exactly one character (or one escape sequence) inside single quotes. We share the escape logic with strings but require length 1. Empty `''` defaults to space because some legacy programs rely on this."*
+
+### 5.9 Backtick — concatenation operator (lines 1779-1789)
+
+```python
+elif self.current_char == '`':
+    pos = self.pos.copy()
+    ident_str = self.current_char
+    self.advance()
+    if self.current_char is not None and self.current_char not in set(ALPHANUM + '(~!"\' ' + '\t' + '\n'):
+        errors.append(LexicalError(pos, f"Invalid delimiter '{self.current_char}' after '{ident_str}'"))
+        self.advance()
+        continue
+    tokens.append(Token(TT_CONCAT, ident_str, line, pos.col))
+    continue
+```
+
+**What this block does:** GAL uses backtick `` ` `` as the **string-concatenation** operator (where most languages would use `+` or `..`). It's a single-character token. The delimiter check ensures the next character is something that could legally start an operand (an identifier, a literal, a paren, etc.).
+
+**Defense answer:** *"GAL uses backtick as the concatenation operator. We chose it because the `+` symbol is reserved for arithmetic and using a distinct character makes string-vs-number context obvious to the reader."*
+
+### 5.10 The catch-all `else` — illegal characters (lines 1791-1826)
+
+```python
+else:
+    pos = self.pos.copy()
+    char = self.current_char
+
+    if char == '_':
+        # Underscore at start of identifier — special error
+        ...
+        if temp_str in reserved_words:
+            errors.append(LexicalError(pos, f"Reserved word cannot start with a symbol: '_{temp_str}'"))
+        else:
+            errors.append(LexicalError(pos, f"Identifiers cannot start with a symbol: '_...'"))
+        ...
+        continue
+    else:
+        self.advance()
+        errors.append(LexicalError(pos, f"Illegal Character '{char}'"))
+        continue
+```
+
+**What this block does:** if no branch above matched, the character is illegal. We emit a lexical error and skip past the bad character so scanning can continue.
+
+**Special case for `_`:** GAL identifiers must start with a letter, not an underscore. If the user wrote `_water`, we want to give a more helpful error than "illegal character" — we peek ahead, check if the rest of the word is a reserved word, and emit a clearer message: *"Reserved word cannot start with a symbol: '_water'"*.
+
+**Defense answer:** *"The default branch reports any character we don't recognize as an illegal-character lexical error. We have a special path for leading underscore because that's a common typo where the user expected an identifier; we tell them specifically that identifiers must start with a letter."*
+
+### 5.11 EOF handling and return (lines 1828-1832)
+
+```python
+if self.current_char is None:
+    tokens.append(Token(TT_EOF, "", line, pos.col))
+
+return tokens, errors
+```
+
+**What this block does:** after the main `while` loop ends (EOF reached), append a synthetic `TT_EOF` token. This is critical — the parser's LL(1) table uses `EOF` as the end-marker terminal. Without this token, the parser would not know when to stop.
+
+**Defense answer:** *"The lexer always appends an EOF token at the end of input. The parser is configured with `end_marker='EOF'` and uses this synthetic token to know when valid input has ended."*
+
+---
+
+## 6. DEFENSE QUESTION PREPARATION
+
+**Q: Why is the keyword scanner hand-written instead of using regex or a dictionary?**
+
+> "Three reasons. First, it directly mirrors the transition diagrams in our compiler proposal — each `if` chain is one DFA path, so a panel can trace the implementation back to the spec. Second, GAL has per-keyword delimiter rules (e.g., `cultivate` requires `:` or `(` to follow) — a regex approach would need a separate validator. Third, the hand-written FSM cleanly falls through to the generic identifier loop when a keyword prefix doesn't complete — `seedling` is recognized as one identifier, not as `seed` + `ling`."
+
+**Q: How does the lexer distinguish `seed` (keyword) from `seedy` (identifier)?**
+
+> "After spelling out the keyword `seed`, the next character must be a valid delimiter — whitespace, `;`, `(`, etc. If the next character is alphanumeric (`y` in `seedy`), the FSM exits and control falls through to the generic identifier loop, which builds an `id` token whose value is `seedy`. So `seedy` is one identifier token, not two."
+
+**Q: Why does `~` produce two different kinds of tokens?**
+
+> "When `~` is followed by a digit, we fold the sign into the literal at lex time — the result is a single `intlit` or `dbllit` token whose value carries the `~`. When `~` is followed by an identifier or paren, we emit a separate `~` operator token. This means the parser doesn't need a unary-minus production for literals — they already arrive negated. For variables, the parser uses the `~` token as a unary prefix in expressions."
+
+**Q: Why are comments stripped at the lexer instead of just turned into tokens that the parser ignores?**
+
+> "Comments have no semantic role anywhere in the compiler. Carrying them through as tokens would complicate every later stage. Stripping at lex time is cleanest. We do still track line numbers carefully through multi-line comments so error messages stay accurate."
+
+**Q: How does the lexer recover from errors? Does it stop on the first one?**
+
+> "It never stops. Every error path appends a `LexicalError` to the errors list, calls `self.advance()` to skip past the bad character, and `continue`s the loop. This way the user sees all lexical errors in one pass instead of fixing them one at a time."
+
+**Q: How does the lexer handle Windows line endings?**
+
+> "In the constructor we strip `\\r` from the source: `source_code.replace('\\r', '')`. After that, the rest of the lexer only ever has to consider `\\n` for line endings. This is a defensive normalization that prevents Windows users from seeing wrong line counts."
+
+**Q: What is maximal munch, and where do you apply it?**
+
+> "Maximal munch is the lexer rule 'always read the longest valid token.' We apply it to every multi-character operator: `=` vs `==`, `<` vs `<=`, `+` vs `++` vs `+=`, etc. Each branch peeks at the next character and emits the longer token if applicable, otherwise the shorter one. There are no ambiguous cases that survive."
+
+**Q: What happens if a string literal is unclosed at end of file?**
+
+> "We detect this in the main while loop: `while self.current_char is not None and (self.current_char != '\"' or escape_character)`. If we exit the loop and `self.current_char` is `None` (EOF) or `\\n` (newline), we emit `LexicalError(pos, 'Missing closing \"...')` with the position of the *opening* quote. The lexer then returns. The parser doesn't run because the server short-circuits on lexical errors."
+
+**Q: Why does the lexer enforce digit limits like 8 digits for integers?**
+
+> "These are documented constraints in the GAL specification. An 8-digit cap means the user cannot accidentally write `9999999999999` and overflow the runtime's 32-bit integer logic. The lexer enforces them up front so the user gets a clear error pointing at the bad number, rather than a confusing arithmetic-overflow at runtime."
+
+**Q: Why are there two functions — `run` and `lex`?**
+
+> "`run` is a legacy entry point kept for backward compatibility with grading scripts. `lex` is the production entry used by `server.py` — it does the same scanning but additionally converts each `LexicalError` object to its formatted string via `as_string()`, because the JSON layer needs strings, not objects."
+
+---
+
+## 7. SIMPLE WALKTHROUGH EXAMPLE
+
+Sample source:
+
+```
+root() {
+    seed age = 10;
+    plant(age);
+    reclaim;
+}
+```
+
+How the lexer scans this character by character:
+
+| Step | `pos` | `current_char` | Branch entered | Output |
+|---|---|---|---|---|
+| 1 | (0,1,0) | `r` | `current_char in ALPHA` → `r` branch → spell `root` | `Token('root', 'root', 1, 0)` |
+| 2 | (4,1,4) | `(` | `current_char == "("` | `Token('(', '(', 1, 4)` |
+| 3 | (5,1,5) | `)` | `current_char == ")"` | `Token(')', ')', 1, 5)` |
+| 4 | (6,1,6) | ` ` | `current_char == ' '` → consume whitespace | (no token) |
+| 5 | (7,1,7) | `{` | `current_char == "{"` | `Token('{', '{', 1, 7)` |
+| 6 | (8,1,8) | `\n` | `current_char == '\n'` | `Token('\n', '\\n', 1, 8)` |
+| 7 | (9,2,0) | ` ` | space-skip loop | (no token) |
+| 8 | (13,2,4) | `s` | `s` branch → spell `seed` | `Token('seed', 'seed', 2, 4)` |
+| 9 | (17,2,8) | ` ` | whitespace | (no token) |
+| 10 | (18,2,9) | `a` | `a` is not a keyword start letter → identifier loop | `Token('id', 'age', 2, 9)` |
+| 11 | (21,2,12) | ` ` | whitespace | (no token) |
+| 12 | (22,2,13) | `=` | `=` branch → next char is `space`, not `=` → assignment | `Token('=', '=', 2, 13)` |
+| 13 | (23,2,14) | ` ` | whitespace | (no token) |
+| 14 | (24,2,15) | `1` | digit branch → read `10` | `Token('intlit', '10', 2, 15)` |
+| 15 | (26,2,17) | `;` | `;` branch | `Token(';', ';', 2, 17)` |
+| 16 | (27,2,18) | `\n` | newline | `Token('\n', '\\n', 2, 18)` |
+| 17 | … | … | continues for `plant(age);`, `reclaim;`, `}` | … |
+| last | EOF | `None` | loop ends | `Token('EOF', '', 5, 1)` |
+
+The final `(tokens, errors)` returned to the caller:
+
+- `tokens` is the list above (22 tokens including 4 newlines and EOF).
+- `errors` is `[]` because the source is well-formed.
+
+If instead the user typed `seed age = 10@;` (with an illegal `@`):
+
+| Step | `current_char` | Action |
+|---|---|---|
+| … | `1` then `0` | digit loop builds `10` |
+| | `@` | next char isn't `.`, isn't whitespace, isn't a valid delimiter for an integer; the digit branch's delimiter check at line 1418's exit triggers → `LexicalError(pos, "Invalid delimiter '@' after '10'")`. Lexer advances past `@` and continues. |
+| | `;` | normal `;` token emitted |
+
+The result is the same token list as the valid case, but `errors` contains one entry. The server sees `errors` is non-empty and short-circuits the pipeline at the lexical stage.
+
+---
+
+## 8. DEFENSE-READY EXPLANATION (memorize this)
+
+> "**`lexer.py` is the scanner of my compiler.** **It receives** GAL source code as a Python string. **It walks the source character by character** in one pass, dispatching each character to the correct scanner branch — keywords, identifiers, numbers, strings, characters, operators, comments, or whitespace. **It produces** a list of `Token` objects with type, value, line, and column, plus a list of `LexicalError` objects for any problems it finds. **It never raises an exception** — every error is collected and the scanner advances past the bad character so we can report multiple errors in one pass. **Keywords are recognized via a hand-written transition diagram** that mirrors the FSMs in our compiler proposal. **The `~` character is special**: when it precedes a digit we fold it into a negative literal at scan time; when it precedes an identifier we emit it as a separate negation operator. **Multi-character operators use the maximal-munch rule** — we always emit the longest valid token. **Comments are consumed but not emitted**; they vanish from the token stream entirely. **Whitespace is skipped except for newlines**, which we emit once per logical line break so the parser can track lines. **The lexer always appends a synthetic EOF token at the end** so the parser knows when input ends. **It exposes two functions to the rest of the system** — `run` (legacy, returns raw error objects) and `lex` (production, returns string-formatted errors for JSON serialization)."
+
+---
+
+*Next file in the defense-prep series: `cfg.py` and `Gal_Parser.py` — the LL(1) grammar and the table-driven parser.*

Docus & mps/DEFENSE_03_lexer.pdf

@@ -0,0 +1,448 @@
+%PDF-1.4
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R /F3 4 0 R /F4 5 0 R /F5 6 0 R /F6 8 0 R 
+  /F7 10 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/BaseFont /Courier /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font
+>>
+endobj
+5 0 obj
+<<
+/BaseFont /ZapfDingbats /Name /F4 /Subtype /Type1 /Type /Font
+>>
+endobj
+6 0 obj
+<<
+/BaseFont /Symbol /Name /F5 /Subtype /Type1 /Type /Font
+>>
+endobj
+7 0 obj
+<<
+/Contents 31 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+8 0 obj
+<<
+/BaseFont /Helvetica-Oblique /Encoding /WinAnsiEncoding /Name /F6 /Subtype /Type1 /Type /Font
+>>
+endobj
+9 0 obj
+<<
+/Contents 32 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+10 0 obj
+<<
+/BaseFont /Helvetica-BoldOblique /Encoding /WinAnsiEncoding /Name /F7 /Subtype /Type1 /Type /Font
+>>
+endobj
+11 0 obj
+<<
+/Contents 33 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+12 0 obj
+<<
+/Contents 34 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+13 0 obj
+<<
+/Contents 35 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+14 0 obj
+<<
+/Contents 36 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+15 0 obj
+<<
+/Contents 37 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+16 0 obj
+<<
+/Contents 38 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+17 0 obj
+<<
+/Contents 39 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+18 0 obj
+<<
+/Contents 40 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+19 0 obj
+<<
+/Contents 41 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+20 0 obj
+<<
+/Contents 42 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+21 0 obj
+<<
+/Contents 43 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+22 0 obj
+<<
+/Contents 44 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+23 0 obj
+<<
+/Contents 45 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+24 0 obj
+<<
+/Contents 46 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+25 0 obj
+<<
+/Contents 47 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+26 0 obj
+<<
+/Contents 48 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+27 0 obj
+<<
+/Contents 49 0 R /MediaBox [ 0 0 612 792 ] /Parent 30 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+28 0 obj
+<<
+/PageMode /UseNone /Pages 30 0 R /Type /Catalog
+>>
+endobj
+29 0 obj
+<<
+/Author (\(anonymous\)) /CreationDate (D:20260507223138+08'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260507223138+08'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (\(unspecified\)) /Title (DEFENSE_03_lexer.md) /Trapped /False
+>>
+endobj
+30 0 obj
+<<
+/Count 19 /Kids [ 7 0 R 9 0 R 11 0 R 12 0 R 13 0 R 14 0 R 15 0 R 16 0 R 17 0 R 18 0 R 
+  19 0 R 20 0 R 21 0 R 22 0 R 23 0 R 24 0 R 25 0 R 26 0 R 27 0 R ] /Type /Pages
+>>
+endobj
+31 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2376
+>>
+stream
+Gatm=gN)%,&:O:Slq=6Ma+aoWfsb;S9KMUkNRd9OAhl%D98n-H8B"RNqX$H(9sOmo8lBqDaoE5;]@]9YMf>ul_qX'?:A!S*Y&?=?LLs?#4m(/YNc&GFIpM\&Oe.A3d#Tt9N'*HUr_kDV!:O!5]RY8;3Bk?l3E^9M\>,\=]LjuZk\']:Md"QaEC-\D;A+IHZ]?s?:2fV`[N:b)YmQ1I@M,hRSFOtr]pP2A5C")jiVqstH$[s*>6(lbHDad.22HGI*m)sGOqmpEZKGhrb4TfJ$I0e;gLacMk[5kGU4*GW@ug^6m6:W[TJ0hm!4gH"*g)WXo\FKf#Fi;uf$3)E]MdJ68n/4.C=Tku<G,.WoCXhX5DZP@j2MS\CQ`fJ6U7ZinU=99b1F+?05"keDlHjHl,SSPXNke08fgOYBo.JoP>'I`V+iPJVrM@uI#e;rafKq2oi!6^l@mIP[2b61#^82[an(qXR`aqi"m<?tMq2cqZtX-Q'VObt4e;+#X%l&[N4Nog@2s-n1_CU^6=cR8Umf'G#);FuHIq@,?WIf4P^&m4-'Uq=3+F35DWjqEAM.a2<&[F,>g#"d1E;VgL'''lUQ5ilAO7P^k17:0[Va186IsctX,&Wb90<#CeE"D#ZBjd>>gQ-C(A0!LZk/4iAlD;!oe0dMXJ?J'WS5HF"XK4iHTn?]Q>0_u!l/%V%019$/Lu^4#+HqK@>1ap\^=X.6=sr7=!=ukH]0dtaJEX0rc+K@%1.\,ei5L+=\*j4QQq<aFceLp=WH.Cf6)kReeM=?T&kaQJob`,k"q9_G=Xq*=lbtk1@geg0brF@'R\GTonW75qg@LK*k;Z]o1n_./;+":Ck6;=DqZ\$Hk,f9A>&A@X(<ZC%r<"TBSbQKA"I_RIL=4n;NHC<[Zo/oR)Ks!^:V"Nq`irps7UDQihX)$K]C&7OG4P?60T&1iP)/sf0C.!A@]khLl80/jgDqF?Vs7_eg<Rp;^C?>3E#H7d\\[k,=1omX^esmM`Q8[&[n[?^HZTa0Ci7R:0kr9rR>0jK4_`M^q!.MWBRHY;Cl"ceBCjXCR%H+?-"%THe`H;3"^KYP!O%^,'D_/q4VtCQNNE8#e.m9;80s3/_I#U6:;#+RaQS&&km.%0277^=HXB?MI+_C"ZAT0D`OfY?XjET#"G(r&]<Abj%#Loo/ESkM1?\lq:V'RR6cTGD"QLpSQ>!Nbgs<2?sSrn,h8bbAb95l01-4C)bNMYdo'`e;n('$3R0'jm,1"hi%@REdEW?@n#)\.LSo"IR;DB!Cg_W/i`I[a'P]bY1s=qmYAAXQP&c\!AjBZTf(if;KHunL[Hs&kZ)k/+KSug"Yo&\`QsY!Qf@I-)\QC6-S-_'])\$Z4IHli*[(hoB*/YC%$JV14"ZM=Rgo#O`4Wg9E$GHPcl:N=S@s&P@JF=tFC]jROFZ*348*e?s^2c7P(p4rT-uk8K"=>_W"2M35s,kg_6T'8nPq4cIVc4QtUo0)>$#mFepT$_4Q:g4>D5i4]Y#nrBW3g7M6amT@?;auMiUp_t<\1$b30$fEc43V&S7YpUj6$RYarTArZs^i3Y9;M[d1&2SW]m9#H3T/<q<ca@T8l%L-(6&.Ths*RWMBN><:F+K3q\`SY,D.L;uUhY]:UkA^EZaIp#j,'34sR1Z7;uPk/S,afu7.'\^5A)m;D2.FJtWZ":fQo%h:lUD"BVOFg^u!9A3dfG_#0Ze>).XC*IuVajY=sIKKX"HLg;.B'i^-oB?e+gKU]q:\*'2RF9>Wl)?84CYmBAa"1augI8L1Jpp/_/Ro=]H.r:*pqQ5*5$.WA5VN#9G"UQI)kT3@0XYrUNTtPPY5;<bG5^IR/doq[#"Jk)SM(FTd@a@=1hhJ6&\KLNPTu:6@>^M"kkCeOT+Kdl`t9M^7A9*=dElLD\g*'"6W]:(h"bmoh,0-n#SGkKBltohN"WU=Saf$agm#Z/j=,N;1T;Zjiu3@Ag9!Y,JSAGUWmB:oD-T#-iE,@I\mM4#g09&N*A'0d45W-/,n)-(ONqMG7jgN4DpLTT&,5d<mn*H4FdP7a^j^8ZdF94LilaWY=%R`fS*m$4_a;q28uqK^B%d@4e/JHIlu]*GVOHPBD*NKZJ#<[-W^KWQC0f=Y7A08-l?\O&3[pM8NK=KHh+X#d/qqU"/E.>^e6*jd<b*<?>P^J&b77/"o8GW;P-V%<qHe25#`DU3h;MPpG)t#f<Yt[Nq:"2W:l`P+9UnVCi><LB3"9t[>$Ikr7W<V!6=E,((d[!6bq4rNacL:!,er9p`sW[Js&JQ&s7uZ]"o/%-@.:hlE.#poTg-Z3S*L9iH$ei$@<rbX"rdd:FVmOr3fN'62p)50T;>kis#Me"\t"KA9_YZ]pq?X"MuNdJM,#Q~>endstream
+endobj
+32 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2952
+>>
+stream
+Gb!;f=``=W&q801kh:Ge-"YI`Gg;eB3*B%&Clb^b<,K1g"d>%e0b4^bfrP&Im05"B#=Xcs^9!N#'S$Dam]XHG@/,MHhdHl]E<<%F3,en^.<+%I@<)\;PBVMiCM%s_#V<G&[qsC"-&:=&ie[qcZb*GIb8)3?$hmA(o_%P`53;#k:36N/oi,S#L3k(+R&_SDi]U!7KZOH[i-.;0[>fgNJ1GK[7p^2jnm21`^^=3%1E.n&@ug$,i>E4]+7(,c1WMgITjdfVS](bVg]2:)+!!FV3'I3a+>>R/[D_B@+^jtob`$A]`^!];8S.P6ka=7t]8XIsJ6T<q9#Ef(q*2Uf+#?n_N.9<%?<$%&A#+2umjClX)(\B#mHhTu&!7m`S\$XX?utbHYl!)jMh1>l;=N5l:i6-\4Ipq`CG&\)(mc^pWj4)aXnhOTdX*br3?Ih19O6r`kechpWS.s>O/@1'AY*Y8FBOn'muNj^B"dt.?F]#9k*U(nbZe3K<pI(GD$i-uR7`e&otsDFjo).#T.t@*ju9aoi_cGB<4Kl&Y%@p86V_u4_S`VX@8"Pt;\-?>0f(XYmRL]WQ&AV.YbdNnK6A9R]n7]gC),\N1C^0)n"J4'X9u(-r3AA*Uf5JG;-_B[[=lZTV\X0!`IEBOZTRIYa+<'mgTR!uiH:\]djC:,ErpPtgimb*D%/3UJeRfB9k2cAP1SUEH=fmh2?qk.=Z\.El]BN<<:g$r^I2`/lFHb2P>1k]S(u\V]kt2AW8<',[q[7=hfWO0SjZs@A)3G"g[[buPS:ROe6hUG0P2)ACagZ(?9@1kK!(54g4:S#`ENU<3BCi>="P:=dW:sJOCt5lAMoCP-cj]Y$?S.j)1OHFG']@=E>@ZiW@eNO@:>nQP.[BD;%gWW^s@?"*:bOAY$@#"k9K#p;_3hB9Sb#qcUa)AW`?St.[(Adc6+b27+"TWiT+E(kL8m#Sbf&b$MuW^^P3;[U`\7fllGsCo9+k3-shSUp27ZX*C"moW+f)Zn^b,R,^7=Z>NKo;+rq5#Lh7!*8&/[tK\6nLThelZ#(jJaZIb87,LoKa7PJ8e`G[]e\!&m5L!Sp@k?";%Y<H6^h]8s<o.A""jiqu)B'MoIi*9BePR[tKV^uqQU")S>+GRf'\:-gcK@Z0lfQ.Vsp*11Oj^FZ[G6*MjE\'8hR=YWTWeBiPaB-3k;4hVD\0(?F*E8k6SQ2N:'):WC\nD-dUG1.8bDS[G'ZK$)'e6<W3m^[Z;SfkHcI]mLl<f7TTNSPGhC<O3ZZ+?u)M(g,WoT\59H/]&>d[?b+hh,j>\,?/='T4?S&UkV.*\hDWDP<8)Z2d#N?2lO:dOd.W+f5Td_C]$^Ys@4/n0eds%'#mn[E1-<OVCdWSrqh.YEi,'dg[jL`uVa<G6C%[n8'tY+-nG@!6t:/.M1SH=Wg$24bV0W6:>d@(OEG,(eFVRUN%C16+3Tku<F<M0-o\ooA@57>T-r1OBRY/GQ^Xood@XnYj#X3It6@:CHe@j@]Gm6qo(Ed%8j*-C^uX2.:+^^hDNpi1bf7lPXGFOi>k<M@J:*Us0\j)R?B!mDU'ZTZ]Hi^g/!FlcQfK4oqa.q?;#1i:h*q,aP6uAs4DZ%5<^8#SGolP!>tB%V;"CH.l6\'MX_Rnea`3Y\'gqfb"XT7-bCTD+e)Ob]f`l,K6c[o,!$)$J["-.6SogB\\2+C-RG-Qn[H!=FDQW<JK]@*YId'f1@Cih?P8r([FMj7nIE!D?oOn9$OD`$^I!\](i+Uhe'rX)u?$Ag;rP+I3d8rk0HXs;Q?KLc]Y,]:;Z^_Yejd*-ttt]9Msjl87?:.X>0gM-s_$*BjRrIrhTN+(7::?cb^[X9fIS3_UZniEO92+GpK66/C[,>pf\oa@?k?U'^ZH"$>-gRVO2/0s8U/6"J3Td,t%`BH0r<o>h2UI/2WP+I(d2l8=+/E=*Kk7.tc7KF`r+Op@7\j5VmV,m:An/^R7-G7g&lE)+\B^CNW*LG<]$i"Nr@(.(,6sJ7BT,gRZB6Ahgp)-PfYT0`WnfC$.huJ"srC5%;d/-HdXQ9H`'NmDY%]XI2,8PU.fCHNrT#)q:Ipe`H!P6LKKQ,:.kVm$d"M>m._jNm?t&>RVlFr[d"g#$5;sP'tFRK(<aY]9CI)No_t,`@X0n&GQWLl-XO#E2Y+$o]]UO#L>BXVje%(O4HP_,47@-,oF8_hu>mT^$^ZY5@8fOR.OTTRgrPLH2Ye$g#^ICch]6nG&q_R4+q#*d]7<$*DkZPGblAIp$G+>D`'CPg'SW"!h&>)qBF&mk)?akYH.-u-K327)?)1k]RZr86jWO(KR<et%HrnYb#f'^+/s)2idIeRUgag2%1.Ff"4ri,25%:q:p\+`77^iYcS]nM"3:V6a5Qa=.gCPkECUEa$Z*1))bMG'k%`ic-M%CE\Q6fP1Y\j"`bLbIYVZ"Y?Ch:NAP7Nf,&AW3-g96;m-!$I#UIicE\'+r!toE1=.t)!Lq6q#1.t(%!GLddlg9.ja3eu70<_]->GMKQ>$q(n3fFT4e6:9MS090,eB""H6s#&Uee^j$eSqOS5js=<ChonnP2rfg"ec:i4r+IedcZuMT;Qg1\(SZ,HPKTOMb]RJPG@ZH'&hREauDP,D:Z9#ep7GLqEpcErk*<ZRehhe[.;])*;AnF.d2"?P3:/+VH&:%Tu6&6h69d1O)Wlr]6NnAJ_\8VeD<CTq:cXS.Y3Y]I*<bV_Zek,R\h0tC-JOGKgukAS)TE3dJkbb(\p0H<DkcUs/8.SbT]jDCLbgHR(GnfeDj$Agg6q3hCos+P+^Dp"$jHe"?*nVFM)9.E8e*pl6bhdg:)g9[JssO9V":nBJllJqcAYi'E%L&OY5&X?cQ'E:esm3`S2!t++/pOnIDHq_q\^k3F*Q[H\$RC%rK"XDLK>C)dS5d(+THHOM>Cl#n*kD*p\pAfP,c'GGKe3Yei?i_n5pM-NK3E~>endstream
+endobj
+33 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2189
+>>
+stream
+Gau0D>Ar7S'RnB33']2d.2#+GmbR`dA]ZVK8@ui.+6LC9A3/9k9.E@jaaX0u.G:"=g/]kJ/eWPV3VVte.G4D_p&AP'nFHo<D^\EdUDZmp\1kLJld<i;P?&;G5t(YEHf>7'lVQ5^MFTOT[];49-S>M`&R9M\f!"O[iMp"EBuU>S_Il!73/e^_TSssQ3+jrA#=boI#/B3LX(=Cu"Tgb0+mOCE_[""jKil8ko'(p3`$^5l2"FM#S`dF:e4+kBV\H\SE?J5aBId'u=V]7pUag,An4?MO3<6\n3ThOE-V3j7Q;C/8k)V#-Ri,d7_<1=r@e`c!WD&4tCo-rl5G(</k563^+rd.3VC&\^4NI,X3/=S+@PrO[flkF^RE&d5LjG*qM2mL6DS%oC2^nmb'ff?ilh<>nguq6LEO?nc,!Ta0T2/#=;B#>7qa?e5H;7"&KS]b^_sDNtc1i)3?D]c?FB[@WZYfXc*l/c>A#\"c:7F`WW?c-[,]PU&eN)^c>1>PN>X;61.`J&/5@d2['"D7gnKR-5&E"EQ;3igp0$uX8K4QU^p`[PYMV6,k.d/BOX@<&D:Lru%1N7/ich*U-VA@j*@c(6n5cAUEUZW2,O3!/]&UN)Ne-C/hgIZ15ZV&o1EfFS.'9E2AfJ&bgf\I-Dq12>fhI[7dHa1!F*ogBkU-09$Xo#7uj@)fo6K><^>Yha:lM2U#(NUcirP%f]kmV7#AZ.2%$!c<#]>)+pLNdsW^s/Kq=/4[0hq]@aR2890@:n%Pg5:o$5'87[6ffnInM^2mE0A+Ticoc+%D,V]Ga?[3D[0W/$XZKhZ+bs";5%\-1[NW,T<ZkD;SiX%A8tVcfP2(u;c1%%R>ZM7@FpG/.EJCg(<*Z+pdN2h4G-e--`Z^)(DCpU74l2LIr*,s:"p9t@CI)TB5?0_Y1B^Wc3<C8i,W-tX!@SYF/_1+W';E,0L9LpLpJ9/]pS/@T]oWVFeBooZqsJ!Up(=:.J-d$!HHo9AibGpTcNaX`cs8,Uj4F;PHiY(]QFlm/T"p,'R3X9fYN8/Bffe=%r<e91UOZpgPW]G]oc"T6167p6,tAVa)flgmEI\j$E&5Ys0b"X#[V+__T16lGUuV9iUh5%q.@?mrjNoX^S'b?^DGBVGRMmUC96h6MPnWW=8VDFHInJn[M*`VFfF8U4rZdu<U\..msjh[.hI,=W""HmZT?8p&\,h\TH+hMMXhl$(O=2bNmro$qntDQK+ip?kX`*@e0C4Rb*i=XAmgZUgFR,k/a-+*VKA,mXY5U<c=2WaT`!/YKf$!/$5ReUSkU`kRS&\pE)==2FJEdFDUCF''p\.4]FAqePdk`1&be=Wi;tgT3QO@85o:CAKR&R^*nGK&iLki6&gBJBe,<^]W9Y&9N]a-bqkd2=SA-2!7''!2BoHN?AHd4UBm5U*`V<$=%j\CK9hSlKQO"3!<&)RWaM!M08eZU1q%T%M$td$%G\k/OKZ:"u^#0b'@]&#61!`h"7a0+`!!-"HA5\hY+ClZ2(.P,0RiG'<UiLh)dACGF2.Er[cu%DE`=s7.H$tDQ]8?)Y+n'bdIn/q0@dRrPANO2ZLQLh:p,Bl1'RoS#?#mQ5S,?/sQ'EW7/h.7hRD]@4gKQe:3.4XT\]T'=#(?CO]/aFPA+?'l09g\R;,_1^HIR0`dcRns2QW7LLgjnS\\Wlj'n&*fXO$pFd3CT(!D,n`%WMitAR-LF4//\BPJ@T_bb_FT0EX\S^)-fYHh^Z,`Wj^W*TUJA1![a;rL++]H7RB%E%We'`4=HRW73]1/9OIf2/8$V%A6=16X:-UdC6m!DaXNl9h8nY(FJVbA3:t.DLJ`6le@(65<I*1'T,aDlDaq2A`',Bjb:GH3)UV.e(S'C&L0Y\H6T.q1sjM'ZaHVsHi#]W4#f?E8`[CM"5!Vq>)&W0"6)h>3c#Iis+ppQO_0kWL;Bk#Mb4+Z?mbJZ>L]!VF0<]#XM0+=/,YH),<$U<K/9@^bI"5FbP-PI0Y\U"rO>Z!,K(:u^^e$:V`B6mC\#5KW?rstY+M9XAl-JQJnd.g9Lk7)AG[u/4a5OA,n3#sq7]U259eCgb[M`IL>>[pmm'_[Z;Rj9_2=F?#],`HFcG)KC$3LaFF/SO_K>De^aWgA0FC4(Vc[>1^-K1+Fh#X1k)+u$oNub.Wm&Vd)Q@Mi8Lpbm[C^^EA!9]C-3Yds!QQ2s"o~>endstream
+endobj
+34 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2164
+>>
+stream
+Gatm<gMYb8&:O:S9O/?p"+/;S9r*>&o\ouWS2P3foH=PMRTrFCGr&%2<PQ7\QV0u9<g'"QM'\'A1V8!Gk0/cE=np%fH^kcJ1ni+%S@D:W)0)"R1qB=GaiVGW?4#[ZaF*rV\`:JJ3,O/rF/cs_FkcSWCQn-?fZe.&m`-:C\]h*2'/f_4AtirA9l55N<AYNQT$cUT9jZ!PrkR*u)%Tb]libNAE*1!j\+J+d#n(%aa$+?iia;q0hdbG_4ku./2.g+m;@Ar,5-3r"(@sm>XmYaB/U9ZIABnA+!uh)rR3tkj$L>mE0PecX1F6JG#*#c!^_0.s\5L[%(MTQT4YB,gf>#(s["80(?AR[4[%+IgCIC'jnZo;ddGDm$W&C$S'60Fu`h<97=bp>e7b;!8]qQj6M?:N)X.pkF&<7=Z2n^"4G&YHqCrpK'qp.l"KNf^90kZ+ufQFZ71%#u*_&n#Mkt!)8Tb[d)kkH\Om[62u./.tWHcA*,QlT?mKK2!\mBK1*EC7oMhK%T@21eGHF<gbs29VbAESHfR#l*XtHDZCBP9ZNVZEsW2%M(4;i7M=5ZjT/-&_/Iu1\E&X`jGSKG^SC\JSTqZEs',J_hVD^Sk!WJOq1D1SM2\"KhUA"*+h%JS&N"TQ+%/_%rs9g)C8i^K<*/IS"<pY#9FI`h&<u#O.QX&,m&>6#7j7/QaK,h.cj#4gA$rPA[Qgc[[28EJ7iOCr9:gP.L_*1P-=>20h,9>]6$g4lp>7J%4"ptghC."U&tM^bchhVhRlhn!fO'N'ZkGRO^IW5\OA]Se*6,-K&`B4b@T//Xh3,X?.O]fF08q47%^(21=%jK"d5Q`3_#__7s5'-<(.9$H\fp,c>.oe=JT:lA"kj-_u_37S1#mb7kN/`/GAU;;_IB<gr<o7TU"cp&LR#jC<"1$IJ+XOJrnXd2^!..I9`9;Q7^W,R7tr.67=13D+Q>+SGt2)bMY+,03P/X<lgb9^o*r9\39B7V?'+j&Yca3XL2h4Kt9RT]_a8>[\9Wj%dJ[Cdl>LQjUq3U3T>9Bn5s(9-<tJjQQBI>YQ%q1-uB8\Ct_&IJeIQ[iiJ&N?V;\R6u`U+d;7^Z2U+l<jm-qI?Zc-I=]X/W_V#:,&IXskq0sTE[$>p#,&:rCom)]!X)b/>+1Y2ZM`d84\!33lBe1as,3qL`aLNdX4$b\-3V][Q)LZWIbq.HM>36aj3f[Nm39cP]L@?P.*U)g<W4=sp5@8>LR+&Ri\F\]ZKU-,Y#?-`igUYB7&MrP/0jWsB]@-\m;SM%JHWA<!&Z()Q&@+LM9:;<],OA$\\KsYC*.<LqVfU?f@iDD6;R1sHNd07Y;]]uB)MZKWZp3+.s6AVA0l7^47"fY(E`[[mT\(A>M`+1cVN\j\Nu`$VrndtHG].i.4G)bM1s>^td[)@TP?t-PCbMQO9PiCXG=IUah.F++LN=G.05^6C_iOCf5BG*7-q>2F(eR$`f8i\WUXAs]@jf0hDj-=u>g^P!7ME`-/?PbL2Q9AU=u/qui\UZR+db4`8l#t78M0XDoP;i>W`.D_O+QeRW;6g/]`S=A&gAAcMH*_C>^_mgE$3tsFm_5=g9R!MP@Co+"abDuAqV-nZ^%57Lnq(^3jGEdl(9f/4:J/-B;nMqk4pcJ;ctiU]"H3S%Wi&3:),Xt%VZ4C]:4R,1cHWP\6jR=7"\g!F#B_=cQP(343U/RmA^V2?h!&PaP@_f5YmaQed\*W%[%!.>7I9I9J%o]AL9#b3%MnbPZ9IkoM"r=Em.MaL9&*N2F,spR$gS`7umE&3^24mXCE0@G!R#V&#Z>'2e!iI/"/&J=;CW>7Jtt\W"A<_]BLb8Q$X8)%,/Ue9Bj)425Qa<hO6C/^!eM8Q*@p=Y/b_Rn6Q_Rne-@H<Mmi5TIKPECPN!^fr@W?$^WX;m_H'$7NsT]H"UK6M.-8gNJ#h[.SX.)Y%LSIU?35PA-W6/3V+hs#!mcV0s&'7>())n2)dF.C!5`0-#YC]B6=#u1?%)^I!qMPZQ@O6;i*Md/OqJ-]_R`8D>REVl+B?PKmWeYj6Dn>9SQ+rFQKYYkfCP9LO6;np3gj8[bEF6SD;^CD00Q/`'@K]7h$B+0g?]7MlI0`1.r1ro3,/'9D%*n`e-=S>.F[FoJDoB#.]i(a8jX%*"(/inZQe:2^HemImuB)?N~>endstream
+endobj
+35 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2210
+>>
+stream
+Gat=,D/\/g')p`p0h?;_ZY)(ghVCOrUttaugK^3%)X&5M+J:%7Ag<4;MN6`Q5JKQXNanQ9]iBSZerV\XpP5R&i?,K-ZN\.V&R9^Z5^aJDJVGG'd1q$G^%hOp91]S$8E0>)$'R1S..!"0AeraZ]-#$<oYHRonm+NLhj7F6?7m^)E!8Jt.5,HHA)C(T@P\MA3K1\ikU.V5IjfW\-:0>Hi3#u5.t/k`OO>D/r=OaM.$I':&9WMRP/rT>_t9iOMZOSY4Za[\,pt=?e0D\_b<1T9,hT8G@KW&#9lM>U5IFP"G4s.HWL`#l0BeC0P(;*_ia_IKmhPb/g`)lpK^HVtL`5oUDjL0&8u6(4bd<J.@hgZ)>!jT)WF8s$*%#HVe=*FbY"5raj?VY0#+"Gh#[g*+L.mmm=kCGl2@$CL<.O<]#[M?gg7(^B?s9>@=t<Iqi*J*m?rl/CFLT\HR.-'n^9-[m7\cH2s*Xcc%0]sG5a@l&Fj%Pf6RanJXS#ha+=H&lVJEIN?\]6U,p]i@G!Lq?5th(QWGap*G!5.Q4Sr,gCqk/giefsVN"n&7<QdrW11N2EVC^cfo-7J!dt#ft^""NG8OjDI`X,4MCh''6A9_S-LEThM9Fb.kfO[;.?&%#H!*7Z$F<?5CS6<7HX8*\+9"o.k[3&[$Cd5nn:M5GKV3^6%4Hi!R][BjIKOo?XVD*<OXA2HIM("$`_b0,QbS85p`7C=h'aBd^9:Z\:_gaOVg;[rm=XNh,VXOn]9m)XY""aapIPb2-A!0,0m8=nfMV"+M7`4UDc>p:U1e\''`#kL32->(lKNLf5GOU9Mp`1VEBh9.C;.(Ht+*Xdc@s1!-=VD?'^t?O.*fP+bLO8)gq93mk#0e&cGHeun6[=X7\3iV%OMH('U6N)3<$'j27],:p-r)KYr*\a;pe^cUFc?61Q`8Ld,&m5NqSV7Irs*.h$[?mgjo$jp[s`f<^YN.#?=/^VJ%:$bNDZ4UpZb6rA:Ki,+<F#1VgGQ3q3mGaKUS?\b:&+mWC=]8,8(D0djQH%KH3M!2XDZ:EeKi7OVmh5l:Ahs]ApA(hI0]0[nI"tjbu9%MCI[4G&gp!hJ2IdQd(pHYobkqpSo*g!`lD4ZPgB:[0En7Usc?oO2YM$=IIF=!/T&uP:FV9J8]42<Q1@Mn,[T[%F%;B:dlO/9tRU^Jg4C7:9)IgOE6D0XW_AT[+UUO)%nkH7f/T2p7o,ZK6gXClK+c)Y?9?MK)Z*(`#/q]fYG'")][F2<]2gQI/[Uq%pap:eY6<[>[t5rATaf.7YiL'GK16C@7r?n5P4.N6TRoG$:[:4E9R+'$(l$1FOVX""V\7eI(_jB?\f[VR$\6Q;4Xtt`6gJpJfCTt-L3th"s:VZ(G/^E&gJ\.d_RX0>"mGF:REDpeP:Ndju0#bgaN.-a)3S;?4^l$_htl]mOCajbkcE[d/upDs%oaCk"<mV.ERlJTn9a#&l!m`?JU"?I/OoZJ<.*g_0PMS?G5&9<O0W*Q4^io9NLIL,`$NM/6pW[]RdE2frhD^H2i85\EmV7S\alDbWYr)pm,9RE-:jmi+8Cd#KqR(.jo2sfe"q64Z3foUm(KbpcUB9)MI"m_<pk5Y%;=iRQD_Y$5)]CNobE2c.P3R*@I^2QMJ$L1-]aqh>[9<p>)p=fC(rs[g)5PacntG@8i-24"RdbG)F>h8[dutNOeC0-5t>/I>M&1s-J#9bOug>R=f(o/mB)pgbX@60Aas30.OY!Q-Zh,cW$<uFobN(n;5W%S98nC.Cn0+]sJJSjp(Q(qDJ%qNo!4Vp&X!.-Tg.>q`_*)C>jWPMgaTq@35+$Q?;I?+n/&AV%))I8UTe($"6Le9^K;>4rILW@6ifpqR`e)95<o;FtYq#q@[8@UM$iMblIuhG>cNK%W][,f7E6$3bGTo!db0((G'[9]a0-n0K^^7#^f$afo(BhMcjj?QR_$_Em#YFJVlTnBb\-I7=6FS"457<;;3Z!B">4&*<RB).Qf"%Y/$'2DA$1sXp_+0=VdFU>EEBam1qG<Eb4dnj,Vhfm(g4Ob82h9eBAL!9s&RJIrfQsQ*FCt?N4iVQi,ek+LC"t*fk"qf\.^sa)TF+_nJL)J%;^H%]B9iR`9J>`ohbXqmna(fWscHb6GnYToX`&@71b&W<j)08UG.)6s@Y,d,0V*hr\^A5E.O!&Bp,oi\URQOUHNP`RObOOZOT-`Fa&Xi\*"3<Ib~>endstream
+endobj
+36 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 3010
+>>
+stream
+Gau0ED3*F0')nJ06#?!$DelZlotEjYlm8-EJY\W*h$,hU#\]X7H''CAU3EqF1r'!$W#&YRD9KW)A.`H+%`oSPoC/019e?'Tl[Rq(+b,uEmpFhfAn8Iu[S'm]I7*G"cTXRoT7lt^U43&(FbA%`Ci];RXO+bcB4nAC>t12O@GVG2rHS3o]Z`:E9LM0QM5<a96"Z&Z,j-[Dr+e(d(R]`1$iC*mDPlr3((s^b%:QI04cN_$%X`<l$&b],Z=r=0hubq@gP*s?OQEsLNEe-0YZVKlleN%-$Q4)&1S6^\X[3qnXS*iNLW$HsLJbDN=m4>>n=-6q@_l;[1p_gbkbrq0R^LI3^WBC!AKoY<=_7h7CB4H278f3%br!"_LU&2pK7i53:W,_uMCY*k,[9PPqt$k?VkqmQ(6Yj.^+&qX':ETV4S6-Io]CZoH'.2kaV.;7Ge@p[E-BfQBp^V]F-nf0MF*PQQ7cRs)9GcB?G4&V&(S6oZckj3a_g.I//="e9(GZQMK&>^T8Y:`/,ejK?%#uNG+c<.#NoO=4C&MtaG/k("JHC38tKu`3nUiaeND0YO0Y=J(D!6>ocg1R9\RU@?7,HM4X^tK(=:Fui=k-;US6n1crmRj%VWnWb]>n`_@)<=k#1)pd)^@/4j]'P;L?WuCanLne;ZT(6(M!Xh/X@?/9[^o%XR/=QWh5IZ68L<FZI;2r\Q"8'?0$rG^@Sk"^+)gCnq+F0"-TjjR/#Q>%!%^'f(N&R:f_m*nMA4s+KVf#[cQo!n4WMQQ!/E^0MQg\IbCBO>E`Li5V:05\'btZ]S[6aMDGR,hXE1NO5JKm.ps>nPU&.39da)rEpIK0,'e@aV16qK,)EY%U<I*d!*sKZ"]S%5`bTPrRj%S+!cpqDs=eD/+I1+kG;8lScbP".?CO1i\B17$f!n5!sV:FEaE]2a9,6!U:N9U-1Z@SAA^9$jlE\.8r8eFroG_,,hf)<=H(iUre-r.kp2D,l@iKF&Tn.Q!@MX?$U]G_ZW/LT/J`!?dYn#hABB?=!^F7QD(VALb`K8GLrH8uGWA3GeFG5f52Zj-3,fB:*:J.e/VYq:1Q(_:5\gNU%5(g.e-fBpr[%)!P=kQWO?7J3!Im`Bopj'p9QV[5.9$V8Gp2s\'(SQ>'fG+.gn]\IR[,(mjsL%8@%oAI1M%D,)!3aijL.9lG!-'/:0!E&g1+*27CHL(OZ7OnYS*o8l>JLPM#n$5A/h[@^*HjI_\@&G'\fu_H%ge^TT3d_3);;#le)PB\g3ug-BW($6>[#;N;PJcrr_;!'*Wr%2UQMURXGf_9mVepP)IVhj(`o_iR/VX9'P]Rn,>>Y#UAVL^?@cg]_^%=B+:s9E<phjTl;)\'d?-iek`D#SLbnf%tF_?.0Q&T98LcO#"tZ4RkqYZ6"Bf3?+Q_65Pj]X6@epiE8]Qk4!<d#e@+_bLLTZ/Zg3AU\J[;s3$bRGZ*bg<#GjtW1u<fgLJU?)'F=)u;2#)TB-ZGHKWuSMWjt'?b-K6:/7nn-felN7QmAe#jL1a"&br+4'd\Pq$4o.35VemZI/i0cb?s.#mshs?hK<dg0H<G3:sq<rE4sPEQl.[8m]Ip>o8(R1TCA22I[N@NG-,PXa5"CSpXANU^V9(>5SQXfliQZGI$$-ZmdSua#eV.@jjedZ0BYKW4o`4)bTG/H7JH`S2HkSm^Zn6Y)tLrM'LCHXPMn;4nua(^co$FlY9.sbMV3b62FVVK,M7ngW$E0aQ+Hf,&#+=&8Q94=opA$6LhXm;E@0:BeD/9\?+bC6!-*RV=,>kqU:](O*KVPV,-2P"^&-)^I5WtU#eH*OlIu5k;?><%G\Og?@N]dg!:nKY%oo/B!R#]:SPJEh$`,Y4mFq!41LQ51*Tl8tpr@_6kC^lM_/(kXc-cnoE_sF'NP7SPa7ksMBZ'P1j)G0WB*D7HHWdJ]i*<npMIn\,^./D3d]rk=\p6/<Kf[jm]+"[tg!nG>(KC5^TT6Ik5`d`KK&84daRs>0/nh@p+2Y/r)D(_ffU,o??F\XQ4LFADBW[XL(:EMU#O"r*:VpGek#u6e[E0("9;NN5_BRhY4@TSX#C#[@+)_9Xb>+(M%SGY'?4g!];"d1<fjoZK=#kn^O^ANR1Z,52'%4Y1O$H,K"?*Lg9abFr.G(mQ=h;Iem8X(8XKtW(8'/r7C;u!!X`,5_p,do+b1`<sa#&*gD^VKRa&(VbYaKE@Z7pD'#0G`u56hZTci8Y,G!)+GAf8h0k0Y'<E1f%HHo*gm^WmReY'X;9h%-G#KVuEGE.^VA]K9!S"oEOW#.um5-NL]<U?FP47L$ZZ[F0.=kdAFN]]_7?qJG,pDIqEBb-;RU]MOtAM*P324+Kgs,3C[WUL1'oNRVE6A+K:GDkX,Ni[qV1"Tf;J>I9B7Z>785C=UpJ,iX-bW<W\DF__2^]Pc0V8u_T[%N'^9lHSTG"Or0.!!2rV2F*]RZqUA6na469`9`7a[j/3n14Hsdm&019S,OrdqeMaBYYdqn-+'h12.I-/6_ld,o^eruSh.,Y\J?0B5"b5n^+_rkO#(!!A6LH:e-DWR;-2<`.h[kO\'Pi=.EguT]8NH[blU^9joU^V;>o^KW/UlDg'fN0;:qK1RaGlmX3rPt?S>:m@GOMJReBnB&\,(jMs7=l0+)iT<ZI-)9G3!h:YIqZE7l7tSo=8/rh<P'e92e*aI_%M)ste4,OoaBrLZ(kbc)\TN<f.^U=7`^H$q^/HQT`=8d4QX!XZd^NqUQ!4+@g!#,>N7<)l`G7$X!WQ(GMen3ou\(5d&i<)<LO%YNTMalp2NN`=de?BD4k=#Ye[6Z*\J88]]4etYC1d+"e,'h_m*VsB9E,&G7uI=_<q=4nWFHeSSY@!7%=:q(?FpN[$d\m.h'l^AG!]fM8BAr`kp$);X>L4%U>+[$*@e)[-Fn,NCPrl=nM[r"t/pcZt38elmq8aikLNIj=E6+jeo4fiKbC>4eh[S7JF[!Lb_1DB;.E8fFj^3`.^j5@qHn'5@9q/boXFk2XerrE8kU%J~>endstream
+endobj
+37 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2392
+>>
+stream
+Gau0E>Ar7S'RnB33(l!EBbOOCmKG?gD:>XQR^Rj\]a-$"M70hWi_"6]ChS:p%OK8!g6't2!Gk9eiOSM@(K3$WO4Nc.$Li'AcehQl%#/8b(9q7l%9LHBDb"Q]P7'Qoe8o*0Sn1gPr[]CZJ?%(djUd=NZO*4m_VjhC28%)\=e(9L?Al)08c\s&0$O)YJ9qX@5@O=d1AHO(gLG%^"Y@tI*m/g$o>a1Vo-39r-)-I5i(&G=e9=`FXj9^MW.FMA`0QQKIq+'X^S8#5W\a_KH31:I,5_eh!?r,q.8O?;a&rS^+;5Dp`O>oCHp1.jE8&IHUlNJlMI]DtGu9C!q@ZPK!>cPk9TEKHCmH_@M"Z+ZImrB/5+@B[$3iln07F>E]`.Erjn70s]AXXGO^q<i`>Kq@-I,H5P(\)nS8'=5Y;";&31Ghs7?Ng$0AdGQBpD.,Ll!OegJDgrr$@4J0e/d@d:C"BVa%V%=ql7e;XmrG`?A$[jO7LeWgpp#pg%qhLq?K>W.^Dm`T]L=I#J)/F"37FWd@QRq9%j!1`ou0hai?;nLPLs)gEoA#iHN4_QE3fq"WebT!_)\oB*ZSiRQ\`hu4R=/iPnD#KZHC@lR'NKns,Y&%jXK$P7#W!AC,VAc_^$'YMRIjVE\2OQ-sknk;TdBGND6]`.]ljiuu_BT3Z2Jgq&3P?n4W29*nkgWSQfhlh?p6L/*/7!B$L>FrbF?N)3>;do0dr4SlmpClKFAo0!_pCj9^`L<5c[lb$e0^,0\(B.R.=>g*F/icl_I6/Xe7B,Ugp*W18#1R]#o6mEVLl!MjKn/^BFc8/mC]KXL$/kUuL9T@hUf%.,',^X%jV:`nN.t2m,?..C-lZCB.7EPF^i1bG&U.obWXufm61$C.HQG"SeKW%9*KPo]2D"WOM8#&]MmE`N)(['10MdC]iOeBoL=LI,@oG]7^"j*(/NmQ%L3X<E1N1`[LMcDqKK5>MW@5ZsfoaMOLhj5`bbSp8Nb"a:BY).J87:2sf'Wl*N6n.iI%U34Qr(]:;??MiO*K1G\oONI@MmUq\b33c.cVq_*^X$WnJ)f0V1%Fs/7M_0S])ElT%2:sN-U*MBB@e@IpZ5/,HN'Rkr7a'@Q7,"ar]MZ1.H(Kem1r_/`J4ZSpiIY"!N3B*JWnQV7NpIkXdYq8]^uQA8=0'akdrC$jM;WaI2HiH[!)FT8@Qn]+sY(\hZc1,"-bYAN\(FQ'\7&M+ik1):uEhe4<r&Eh6797c:d6Rj?1!G&@l/UQjcKMbVbPpX^>h-d;m:8<g"=UGG_RPY/">!AePW:cHXN--EBf3d/n!g!=PMRE%<G7d-/sb"=!</=<59Z.bS?EO"rU-EY5qBrOCdf,J7/?-EX!bDhTrB]q.BAFX$:;F/1]A"H,hY/=7]bHb!]U3%XfE]?LVNn$-#g)afg1Ej*o<qnT?R0f:@fu*G58S2HbV2!fkULdQGoe!XJU><*#Z4L"M=a0Ni$W3`b'dd>BT1W.1MFo(p@C*-!Zk1'tT%lG`o^oQQ1JITR$-Htn^$:q*d:$N0choh23<%rg/0UsS#;=XOFCtO[S[52'M8q>W7YDfm1QL"$5IeGn#hQnC@tQYeJP_9X$4BIW@`Tn")\bL&6,CgdRi&OLJ:g.a`P])I:C#XS)\#O]4@T'=20*@6-t-$C2!)o`U@(FZ9KVj)(\a##.ocWPjuC)=r;t<2%@=TBa(6.Ofjg,"mg)(fY/-p">5G\X3NZbM)QlLf@SP`Mh8:YEVD&W]IN)d0Wp?D?+A/J7fq2_3Q@7+8+_*0Y4Vh":.NfHg/*j%ODO:ZHlZY?MiQt7R#&@7S*ZT+0FB7JM4KQn#1.@01Cej*)736U/:3gB32aaeri$?XW-K#4,-+_-%<>;\dQ_G+;K2f=mLcNnW/rO:g3%KDEjf[1j]/<COagrr>M3-%VZ'Il>Ef1jMB)*X'HVp=7k#5gd<JXdPdDf?'43P7aPVeGSLEYVH)]fFbUh8krB&(>mP;WkZNuHS7,]imT\^\[&b-MTnYJs?)Wf,MQA;am)&;;`?G9*]X:6'eN=,2M1c;rFR<D9R\b@Zofp\.qh?@.^73Cjmd9guWCN7p6t#&UaNM,G*lniiV\BO94kg/[F_86Q4"*E',/iZ$l4WXt$n/[:ErUllA2DY$t:etk4rD*;elD>e(h(iH$DRVVj3L:e42lZVS]RG$6)kp)V,U^^ksbDA7k/.%\Z"#2Cb?sE5F%&%:?m^>>)f_&e2`fPO#kI*K5:Zkk?>o?,#3YOr=fg=![8i3A=cRJJ0eWam2fFio2j"T(`.mNMj!G1E-*t%_c7cfa3Vl_-BqN,rW@UnRP0AAY7W,m-s1FYFG7bfNCL$"/GQ!DWV'<K[\ErSQ%_sls?s#84d`:jMIl:/#1-J<-s#Y4mp26P\u~>endstream
+endobj
+38 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2667
+>>
+stream
+GauGcCN%rcn9]W'X["s,N>7S%DsN-qI@rsTY-!8(0sEAjD/7P:Q/jqHp>^@mhD$V(8Ro-9)*X)T^*A[AFSnYipFHIBFTRo5#nRH-"V=Tg@Ian7:!UJE'dKjun2.c@f1a4B%0F"gPGMAH$L$!H23S*L1kZgbkfo$0n66m8rI?9bOtV'EEgTbi^mZi8\5-Q(2b_N9"s7jN&r_N@^d5&,`"i/,cQpH6iV"pB*e?lkc*2$iW;p-Y`)"6YESeB$DFBW"C3kL@r&C,k-lD7gd1)9PQu'`@AB*_H$:G]J$TVK_J2$hPAJn:<+!a:<Zc/.@Cf``NCrKhk8J3(U0O(f8c#>_fi_;+^1h0)]grDD]0Haj[!FjHR7=38mQ=8*]`3lFb!Q?rd^!1bYSTF:%*8Z14+M<ll\fdl`q"apSl-g$mEb#ZL9C*IDP308UgXhB$XZ=-s@)+P.2W?[K"gDYMF$B3Yr.gTrpI29\6;#r"%G@=Z%"18h\_e)AEP]^bf0gmNgh9;"#Mq'_PU&,:%3Ebmfip2BTZ,Ue5qRGEc=.3,ki_RBEO8,:B(7a>Zu0&aa1*K_+,&KeIC-*Q+e>dq,TDWKD/7'j9?<jHd+>^#'kEP06kiZY=nsN)s*ahQfo7)Z!5_Ge>:C7\3Yc@>!D?@@"p)J)>*;UqiK9Wp@_nAt;HP:4WYQ5IoKOnrk=qsHO*ZU@M<:7Aii,ibWMQTG_PFXenY+=C'NSlr!>f@']Ki9>bf(@SMCS.iLh],,?IVECTqBgsh/d]P1tU,,f.HrpJZdDm4S7E=8kTsm.'[S!YS3LlknW7blog1dXl;gX0,R`F53j6Sr7R-s!C'++E<q_LBBV#/buG!j_a)W**Vq&Of)ZuVc@jM^D:=.b(3_IYYQk:o0tS1e\h)*&=P@tI>TShn7hctqa7DKGP_^;0&E+32gC5"<49_>fP?77!0H0]GoCG.0;enq0V5%82OJI/Sdk"/tgR*31GBD*94L&RE.VD])d;>O/-3jcEAU-XfUe$,+31BGtA%m\se4rJn2+pi0Whh";>KN*Bas%=IGaj?<:Yo&$VBa=!jui.:6s/B`Y2!hMO/"g4I@pOM&@-)3g#>3RalLdiVmh/gHhH[ahA-`i%!t2sWUeM[_c'snG)O:/QPT?U`fhZCVGB:tMOqh9rR>=XG=831cZ&#*6+b#`'Xmd%5*);TkPa0`S@bKbd),U(TQ%uVr9d\G&<EDL36uo(1E;B!gc@n5dr=ar`1B-HpQMV`n?Y:r<^_CP)*7UCA2s"@iF"K;0>m=)Qjh$K1+\:[ehT(;,sq?jiH_%(#GZ9b)4mH2PMpej%(gC@mNY)FOt>\"7u#kS&RsmKKFCR\ZZ5,IM_(l26l4#%.=*b"AjrkK!A$cOK`YLc.MLQ9T(C!R+'$AOd4>bp*bF?^;#s1\E!RiH"IX`>9V:IpLInb@P:5;J*lT(W`Vo_Mj$*?`*eqef8^c6=4\WR/((ZtTk#cgM?Y$E/1rOJmC89Al8*_BL.lbj$bq"B@-_n6XQFFE$T2><8-gGdLN30E\Jqr[p-Z_BZIt%:oc+@&,^3KZU!<R[OI1WPe$B&:(YU0&^!X:lP(WN#Di&dMArgHT/FRH;^HaMb$iqkfdr]\dN_kEA"[spWU3C>j9eWk2X>WRdd!1sX_.=:_gTAGr8NiU_MBUVpc[]=k0f)=5Rqe9P(D9So;q6W/SeGG,HfhYk^l5/ifhlc2XmAf'FpD*)$hlFB&]%<pDE>l>D:b6s5&*1"20lPUT6)leDNo[<_jJ/`X5RgA-e3tF9<c"d/+N1OBTcWZSW*))_>kYS]7<]+):sGc4>_Y<L9n3Yie>Oa5(8V*O\="c.&Go!/B\9mcM6XOgAQ>VXG(Zfhns@m%P[J'V:3j=XkKOn[1KeV_>4pk'rZYA@g<U/()f[mJ:&KsJ$Esr1^m-B*Pa+.0MjqaL]mXl\93AdJMg'VNH/*NTcSmY"$(7.A@-_GUaEHm#Ys<q5gPqO=b3E=NZ344laeLi!%q[>HSp`NWlV'a9.bLsJNqe;6(atg[?)4m&6!fhBd-Q'm;2fml8!1C@r-^A=QhY=b''JW@%>5^r:jYral7^E1jXkBJ\jL)*,+=+bod93@\Iu0Ki9s*`Z&<A.Ng!.1>I!ji7l[1XMA.>jM#ss?f6%dGo9sqAMg#2APjt6EVeh<hU_.aGP3?4,eDiFqbXu,T*;A7+1l8(k7c+5[Lf'Ja=BLf*OVnPf>H9`c180>8n62oZVjR<X86j\r\'jP^-KeTljVCa22>C'bRs_&`.TsM<\H).Fj4<N(@ES,'bD.G>[1h2JW!1.eKh<4UVfV>Z6WL,C9%s@iql;]jDOA#j0]?^cr$21H!asuP^YJV;%^(&bj_39*0hY"sUqn_.#)*77U\o4X^puVc?R`7NNqh38g0;"T4rm\apKUGk!!U,lSE_gO4"`NKE"E,6G26ZG%7X.LZK/#1!iaDmgC^eK:EO6XL](k8D#/'P5WWRQ?[/`NrkBG1ZNCS4Vc0jkp_997+!V(jq0H%7[G,qmH6]#9R>0\K^"65@&DPWDq,Bf&2%e9bgn-JSE;X;gpbP,BG.AbbE>b?9?pg\&_'#k41)dN=jlnD?fM.3oI,n9qTf2]$M<?$^]^+:EBpN24E8qaZb"4DR;\fX!o[<g?&:jlLgRk1?PCO12&tJn2bJHK!~>endstream
+endobj
+39 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1975
+>>
+stream
+Gau0D>Ar7S'RnB33"%FYko<aR`KCQ26bBeEJ>26-"+?PkJ<B(uZRdRO'uq0bhfhUgG&/\;ZZ\rKffHd9lZYOMJqnj*Ic_#gG@PmrOTP2a49ZXd&B:@#_t`TtbXiEl8BJq9-XiNu!JT@A]JC5">MTf[,kSp6#d1di_67cA_(T7p(F>F;SkjX.3+T`F6d>$YUmEe7$c]Bo#/B3Lh(fSF!ca<`0L98s6o8kWq_R60*_f/':bqV%#Y5N(T"h%e#D(:couFSK3&5Xd,$aIj?^=."LS3>f&6-npVrD_tB\r`[Z"elCmN<I9YmOQ(7TVF>6$BeM_nN,l-$7XP77]MfO'a0)$FsPJo>qdqfbpL'.!5(+IG6=<JKMoXC2F>$0ji<fC5q7b0a5P>.ENMXH)5HM)3]#f%2W/J?+fD9*roWT:iP6N`igX(odUnsN3d#53A'A16U5k*YCBg)5D`^s*.GDPnbD8<VsSWOeW(oVY'DnH#%R6<DeAJMc83,5o-(J,BK%TNbFQ=$(aX[_)LVWQ4sPa`Z@+qs49+&)qb*@#Nb4I[<on_TVrm!8ir)f8:Z/-dTJ'Y3(R6VQL3F01i*]1@*W:nQ)5+A'''&5H(FRP6!:Dr,]:-2JSF:7K5ueFuhNp#OZF^W-K60MEYSVA4`-7sQ1X?F%J?je@+5t2tM/<`TY;<%AcO'ibV9%gR&R<"0N.+(ZPK<4E,Rg4L0g%lUN"NsOm\j=nUQEDXRUjp@5-]=R@J]9Y1n'fF[`1O#c31'Jc7=s#@?b.a))%P[[PKu)4"nDmUN$]\6"(kNGZquok]R%5#U\uuB(hl$5<u.:7:G*p+2EKM3I6hjiZX+,0IXnGOgEJei,,7$of#_bLoO]'2YHHg99i1b\(QqD<g1?gHdfc&ak:2.XG`EXX?AjtgBh`D&X?!i.r9ZmVUS%o5/:].4E#?3^bI3=22AV%()7`:&A"mM\$gUF,IrD#rM5+&.7m!k#us5^F=b'p,<A<W'ifqjAO!!!FF1Yu$;lF+;2&7EXlD:mN+-AO1Y!91>pC9\P[J#(HWQMei2:XdatAg>#TM]Z5O(*?i'b\/+Y&[>7Of=(dd!YcP8\d)7NFXE8S-8'jX<>+!?Z<VMa/@DTNBb/5^1VlqXPjh7q7&q#d$O_HGZtg=dq(h!c-_Njd9276KLm9n2Xrf+ZZEF2Q2;PAlgqEjY?.dPk7>&*sCYh`!TEUV8s(-_/<o:@A#o:MP:lX$njb`RNZQ_4)IB;;^Wk7nY;F;To!RUd]ER(+LGe0<jN(,m3;.KMX9YFARj@k?BtZ\"5TDW)Vces=YL4WqUA1g9QH%[eJ*p4[W&8/7;W5[IdX2EG<BLISiSDlnjb=AOAY]#XXUo*U#i#J[%"G9n:V`AWt=I0%Pl(WY&&q`Pr83?&o/>LQo665cNc'KIS-2i#;0)d=Nk9Mic"9MlmQP3?>L=%./:)R^=OCK6I0s?D-V0moslef?![KD[7c;Rh=#i>lpVRALg%(k$eMU"duEcF+gK%Ho3p'<oYF^.UE9Cu<jb+(P5\B$9g^9h<jr*dUVPG2&quN"0FY4K,eb-:GpgqT$64>j+\L'<+)e@W4BE:Fi;9c?m?lF&2KoV)kaS0jiUQI>",71-\\)i?FtN(1o4LV<qL<E0)qV&'M\_OO`_T%Pf/TD&\As>'b:5'80e<>]\DeLus%':hoR55=QDUAE7/&cbQ6$Q*pL41[Hc]ik"8>+@]IfAO>E*ITh[G(:KO/^`VOZa8i/]n%ob4-?miO5CE`;)U7/i"%gU[]8W,7=I&4O+Jp-.s?5mmq0i*k:TG5o)ZQHc<0+9MgQ%"DB]'k'+o=d\=V+K%Tb/[D8o*.XIm;[oIEHptFtG5chPe:CEnrZ_jE@OM$7QTpTU/5%N4:e73kD-B\lLI.]36aUj<0P*&IN\f!/r/)qWW4.$a'[You#-iC=71b&Rg.tM=fL`g=2,O)=[m9,[ci9n!Z1S*er<o[>BZL~>endstream
+endobj
+40 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1682
+>>
+stream
+Gau0D;01_T&:Vs/f[B#;E&iK.D'7:i[!,+)Aoa6n*7I*9:.DJl\?TU8Z9r<'s1Kr9L'3E"OqoA]]W9TN\"@iqU!U\924m/9nFIL.k7jisj!dfk\1kXIZgklf5p[C`_2.m:IGt`kDP+f.<R14<>$6&SQdCj*N^qH8!ps?D\pt<*P!q*ln<$MW:`LgB1OtG/37-LoN;nQN7rRo42m3[95'l:K-lJbg#<uHb5##V*nskJ:9X4aeHajTtZ#P3W%dei53lKLMFO0h<e6aq8We5$g^(cX+KSB.o"FSXh*7aK@5GJca9:_`;P)K6!Qno&HVpO_;:&r"`DipF+r-]Ok%RHO/W,i$rDZ(SrrfG`$NBq&2e>?1tiSA4sHp`=OP:M@+*:^H3)(?,2%UW+UNeu,WnJt(SR>BEc_r`KIgrn:l'mV&3hE[OM>I!U\=FVs_4PGJ"",%6LFT6QHVeI<klQArb_5D7t@`;]<Lb2/9%t1"Z/6*r.+b,#d8F@QCk$las&sX4fi7C75o#]:*_5#c"2_Fr)o@W>*"2\*:gY/[<'>5245)">7M^I0NlUGo<CR&p6d[oFb8+1)3[J_5u0>h)NN4p>Tgg*kC&Nob=\Wj'mKOl#;iM:n<+/4;)BDV%lNBB1TC$Ti9'\4qaB(Yc#dldglc*::krk1Y]T>T7@BM53\:\1'9q5FP2s8!Gmkq2V%'eEkn'//D3O.Ukaqg,p3n(8oO)"`psdb'Gm1I9aCJq`JYrk-VtCJ,ZVLhh<O;rm['dG4g@\WdSOfXt[?'f[uXaiNdn\C;mS*$.@cR!'N0hB)=4Y"R#Ed62]X(RNCUBARY5mGI%7qr8Z3j%Z$J[h,EAQ(XPeUsa1V$A[niIsnqEdF=CgJYk(=AbqA,pC"FJ0Cnht#qX?b]fr.(*>k;Y9$n,V*#t=742sr7i`gu-6_K(0cqk*,Ph71gKkt?MeJpm]Na4sd#mYq*jUu"Ao3GnJ2jgsjMVJo.8-EoEU'-s?7TnZRJfbA;BLUIla_QASXWtCog6]u;n0HFL)),&fH(0k.IgL?P,;k7U9G=b+=TZZ_c4WCSOlZ%q4J+&`Eo31Ck8+S4iq6RFL!-FT'@.\50Ai.Ca-ukM2HZ0_9XN+Cl8U1?&DPiH\7=P5*Zid:NZlI9\!f<h"&U=&g/oWIVI2-U$9h0cFm/2_>VF'$#'4=nN?6bi-eGfi0eUXIRFga'>#YtPm7+9o)Cb'^91ch"Z\qR\&RRl&k;1oNS`%4>_5H$#*(K\T"l;%oIO62^\7Bk7G6R+&p']%7aJePl=3C7FasD!AZUjFcW)o+\.,@*9cQP[->,&"V<hd4(D.rOZg&'.%5!'+@OEeX:*-mL[W`3j$:J7(]HObOFR6ncqa<<jSdcqI30r_B#V%Ui>-,`K$-^E`0ms5cE<b.WZ-,":i!i@VkSF7Or3Q;+A__(&>.Vj<@,\B\d.S;ID[b_0.52gjK'tSrp8TrL23$cC*G/L"[2qYGhiY/u^F0r7KQb\niJaQ92o@XY!35Zi>reEfde!3\PCjElcZ3%G%[D4tTN8.NJVNZO=UWW'N0mU^^E.hQ!#@IIl`DI3.nPZhrac25'NV#Q\*fE#p3k8p$cZ,h0ZapmH6%q23E+2i.0CbB66l:uQoT=;h+fj,8TlQ0+Q4<qR["q)>-*`Q`>[,:V.e>a#j?'.]&fgfWdlbYX~>endstream
+endobj
+41 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2121
+>>
+stream
+Gau0DD,8nW&H9tY(f?hVZsiM$h4/f>[6TG!-s*6HknL+#lj`JnHX1t-jaR0QY3dK`8HQ"H83#;sH01N-Akg+W5H=a=.DWP5S6Sm`-Hm5jD.:EL$I38hh[Z(r?ZcLiD;'j6q6i_cs"*Tf"PTqpg,>XU$`6:1i=mU\rj[RS,0f/$(N@A14=`G9:"+`bh/T+[#\O+Pm'YR,:Y`TgaDp`<Y3uuF:Q+TcYUT6MkWa(a$uCQ`T!.:EG[>,P_-uk[o3;LP%WU!TW&F;/_?=VPQA$Agi'K,3cc<?^OVaqlBH![Yj91nuGMRA>RjPHfDCLH5<^]b2XB`W*Q.StLOE-Z+fj.aM*Ju]8R@HTI,r.YZif((qUA,mlpb=;Bpb&&EcqID[)2jHh(QPqh,'i)hQTTuV-ce<_a5qkDeH?ci/g4K*Jq]@(7"MPm/qFaPUTCOp*l2\>ET@5uKVu)>4Sip&)(tI_OiV:LI]X\)[q4MrmuXlM<%EID_F0Wuf[,conj5`ELepFT^W.KjJ/<nfi%^PB.\_kJg&tlYI]p0r3EKn%86]l*:L4RZ-h[!>4"M<@aM\%H8Ad'82I4BY1GBMgZ,&:\#DcprL=p(H!LBJ-abA?dNhZk;EKGIt<I0RbQ6FF,Htn/ORH/S)5l@qo@BFD\N_GfgZq;SgooH(f3qK+0(0CU2m\g;6aJS9iRt;ji;l1O\K+'^^<#LA*g3\!;U'@!V=,2PtgonPj<#`i@GQB*d(*ou=!hK3gYm]rN^X#,m4M1N13BLMl&+C5=*$VCV_HS]T4ihK1?HN=r%M(X,8-`t\gYc-GMYq0P=eekjYG(k4`HUj\/Ja6<81U!B)n$[]$9iGF!D='P6VFphn8X8/(oPI->i:X5eK:-V@q/o2O9l6F,3.D'07do.AT-E,*=c<tpu^s_QbdW(Jjg2$$i)->)]64po'fsW=4_8a.#J08"Mu?O6emko,+._DAW.XJdD=m_B]prhKIAF/2E[fM7B2A"_]Mtn7niL-9p!;mEn8lf.IL'K$-Q16UA8>sIc=l2p$C`%G?<s/Qa>op_C;E+S3kK0A:E#a9RRHS).s[+!Ua.`&Q@Ykj:kGd)is]T)KYQ>i/[n];i$O%X-IF]O@J37b3hnKS,OjM;:[<ihC!m(;qe5P"3a*;Pu4Fqe8s*I<XRUKo%Ri6Q"JRP4ZHair2mbA?I-n]S:Au.(Hc96')-gqpJE$5%4o[L^-/WTVU9L6lRDT-'&^r2k>AVb2A$cCOl5>'+n0'b1Q?NEHY@PP2(Y:oN8n;pFLk]./[_<5C5!P8:"Qk,p3[n2p02l%:KH4.Tk#`m.d?Q/P48Wm?)ss):;9@QZMUSt(TbogZPoU)6i=a>R4ba6X0M?F>?B/`=-s+C(F(es6?uZROJ.l8[3KIbBE>.CfCG]fm7WNT@NPlY\H:a/#$D*.C8HmF@45N2@X[#\[*"EMm9u'TMV@7'`-$o&>mG$-_YhH&18g_qK"hefa^mi7q./]VP4N?HUP\c+^J5q`hkASmI@`.kBA;if2Z>q<T/FP*Z!8'7^Vk/o,Y&6)Ba5G^$WYjJ7Y_3)54P<&0(la$F_$t9.V0a"bW*X`SjfYCs-FO(Z7QEGG!lK%0SRS6(+`4,_g9]g"j@f`Z*+"E4'Wb86<-l%K=0D(UO<pT`q/u`TW\G4$9fcPRLd"VbqY%?H>8c/Cq4"=>L^quM(iI5-WuI?*3@LV-`p"1iLG=XGnq:D4k'eZ%e^b*b[^@WEus;J5%O%4J!2LX)3j1-4h=+"TD7I@2/68gf?`5q[bZ(,'ae7a<o6KCcTRm?)Mdo/jTk^hX#-La1ZeCC/YGha*g2s+"l!u1W*S*1r>rm'Ai$KOH?[C3U@I57eA3j./Nlb?np0Z1+<XuHmJ36>#,\Sjc_;bkIUJJV1@4hCN./%<4!W_*IQH1C_*Z`>.&W#hQL@]monI30+H"Edj^Du>9'Js/Y+T[(jAKN5I>UI>WpVX[`S*T1>cG@'B_FfOA6!0:c8If0jc`^PN5GB9-Cdc!;DkX'4Q>0h't&0j8`KVIroflJh&AR_c'f_KiL]XGkF5YI6sX]]YArR-rsgRljh<2^PDVAL.ri8"kGL2FP?_P<Z:P!^k;;Xop;ec`$Q@iVKDtpH5Fbp~>endstream
+endobj
+42 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1686
+>>
+stream
+Gatm;D/\/e&H;*)EUtkdku(QH-!ANT!IJO<!a3pQ!rAT?!_/o$/i'8bFL*76J)?BOj4KMn(RpD;'(;*0ceZt_I/Hn:5@4KiR_l*]$8d9T"uISKV!%5.*F'+Y8n&**'"@``S0['\_X=Gd<e.X4K.nQm)FG&J<4iA&bqJ8L>ICP$aVFa!B3]0]=V+9"Aoj!pO!+B?dMLKQT4iVS.#QEI315j2]cI%??L_0pQHU1P]P!*2#kcRT]!8SZ]0guP@hMp??Cd'!Z&a-5C<ttc'[)K7,V(N_V@8t]k1L"<M1,X`K9FE$,<LLL;&_19pYdef,"`e#lHC4Dp]cubHrqK/6d^qZ;p01Oa9).!X5sMb6*moV]o[up\T6I9jG>X-o3f-+*P2j"B;7O+PL,#m9+%G[F?LbqOO?]/].6?S>)<g1']Y(Oi\5`L4TAqaVW6<K4,=k'7B'([P;)i&@s!T;Qu(i\$(5\,Sfe19-4N5=WrNM@[,u>e]<@ZU2^UBR>qB:+Zucg2H!W)5L6f1YFV7u2T6`MGs''X?nRp\f#?K]c>7FZ(f>%e]QtZYfjD`.>"`.eT$I+/i_/lkl-0P\hEQYpkZY7]TPiX.N'Y6#cif7<1W*TRYU0?M3<WT!(dFclD#[Ne`(@k(4Tad?CCgjLTZ#N0Fgl&lP;::Q/[o8!Zge(SnPH&bd@8c!%Fj^r%Ft;Ec2.bdD(`9?W98o"YR?Y32c3c[T=h97UHtC54N1QCEUQ97;-0,H*?YR=LA7O*.[B?_h$%1g'6C,]To-X<7*_N\*/Juc\[D[=[!ebZ+gG<u3RV!aV[[`hARC%..WOD<D#o[6@B*JlO+H$m(Ks;V5__6Gt8(agrA2iF(\^T+c4;DI8g9+V:]<u-$Ms/;"<j)3(\3=P6<!YL.+@;!?WbO5FM=PYm#?mHEZhD4Z[QC-u&E4.k#>,[X,RO@!&rp2E=5"@J'&pqT8ks3OM%8el0fCF-'2Y3N#7;b38\0Yb:crn4NZ&1!g'LH)W?#A+<g,M16pScNe.3On,;Of\Qj8Rm.58oQCg2-F>\k<Hn.a-#CrLU.b-hZ$*4?V$O6K:U:P8#t.ljh>2sAKeNp)5g?Y6Z\lFfQRQT._t04uP;.>;>ROY<*-"*HF?D%B+l`!@feXo00sH.qJt8!6sHD<>\1m!(KZ[,t+B:/Gi+lP\7YmkaInBobXN4]F;*Q@?NIb`8?-B>kZ6F8j\]?Lub,q^iQV1QnLH(hK*T*Q,rTcXq:Sjh#GE=a"^D+4b?@ICqp?*EkYMZ=_qOI->gf@/?US`s#PEl4;Ol!j@#8_8</p.g,8,@'XW"o=@'A\I@6)eS]?3UQ`tX&1"l(?)Epm`uj!Z5em(P$p$_I3k@QMWp/C*[\u*WR]m\2<FjrHrs.^Pq:b8rL"(;(g$l,^%P<Rh"[(9,MBf^d[!1;M(h#MA]BTmmT72)AR]7+kp]$=qH2aI`bIW8`rnqlmmrri&o<;6%hoI+hr@;+$P2Fnm$()"cVH]PfbZi3%X>DU(7.g9`5LW1b11+l>#<0a(bHeVWJ;6Da&#$E(_8ag(QjYHeH`>Cs;m%4FGRlSsDA)q>1t<=Ir#SS1p(`qdi^<RogNRS]hknGrJRboE4bdPePT;Ql-Mi0RiGYXnGo06p_Y%;b-f(3ilUeRr]JeAEn)FI&8&el70?Yi[_M]SpFJ3k1_r+n$4#6s~>endstream
+endobj
+43 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2004
+>>
+stream
+GatU4gMYb8&:O:S9FV]1;eMleSLOJuVG:O7%FRX5?N^K?\J!TB9:;TM\3^,-B9s=7$Yba%Jlqa7b]*:"baDUSRc5F@5GL<7he)N?%4?&ACdHig2U-.(H?OI]f'N0H,@GDqc>:h9/P_)Y`DS/S`k#m=N!Cu'%YN_%1>]aVV:YP!.a:@I^Pdf-V4bA5HF+$GK",qhZ[ZZ^9KhB24FCqcET*$mq98QkDTA&W2d?#h/?h//>WVe;CD'E^R)N>9W\1Vs;CVf$T'\S`IBo68guTFXNQY;'/@<>0QH7tm#Ee-E:/I2]b#^p,E_5!b(N6BU_`2S#*fV"Qn!$=tE<C"7@=4OJ;d]@2GF0bC9^]6d!sBalVc2aPJ\\tJ.%#rWLbP\S$&^L;6rDB9<b\EcM6ac6NX<t'E\&]_-sVU)m/rA+Bp"*BWj)GuUeN'&kX%L@MJj6s.fsc:/Lco`gSH<R]5eomBeE28`ANG5R)oE5#1u>_%#YL;34$.Q<m(r>n*mSc^<]J;(o_(A?07h[8#DcpVPBDA(u4LDE.!CD.RTtY.FWc8gdJi'fo]t>\NJ0>b>,lgW8REDJj4tslF!ekkn\1O%P$k2I&IZXR3Db3<^jT)Wldb11t(f#W>[_dCRCr&!3$\,CEXqMkDh/O;&":qWi.I4Pj:HoO3Jp(Kp']APfBV`%Fce!_'<@m@bG:k7,p%5?I>baObf-)T-*ns[MJrqV6Wd)5p;MD?U[<$V'`>,DnmoRV0&t<A-D<uNuZ*:QV+_u]uFri#[.hHLegGD]jX`J*-B@hf;e"mi%=S0:\Po@JFe7Wj"S'Y9=mHWbs$QGICORsp@`+Ld5Nri@-CESVQWFDHs0%=feFRm(@*MuGeOLmTLorNeYN](f<G[6Z>mY).o@LAG!i&7'JE@@/43=o-`r'CFqsSeK!GqLo8=:@F"g"$[rYYlctVdI'9ShL8\ie9E]_Z'4/2=jno.,<?lBkd'fg_CLkV*X@OAgGiai@:C/`.U`K:s58>TXnnh3?'8#6c*emY[0KXn?ZX(7.IktXKP#(uGuRM`brU/I-!;86<f;!!P,@#BM&G@;443+nCmkVY3^J[_F7-R>^`GM<dL&"lCg%'\fKJ"%'N!cX<!`Ykj8c0LP8S-44aW)E^E;R:En6u<4Yc5It)nkfA"0%E=N<&-X?oT"o^d-f*r)oH:$FWtTPcIp^Ra@,k#//Un`('\iPo<DIOiaW4'[=$b"HuGgHNEhj>c<)Y3ZF/8>^1@C5=$rpi:>P#E4/^8?HcHJ)\`p9"hNn2H/sN6teO?OmP!nT9g/6,\0$H)9J!E:E7u8\uS[(E-Gam=P<3EMK]N9[;G,Fg^;fp9%g5kZ)7in;!D_.oCMgca#qI@&!i@$WUV&^n+Ut^bbrb<?u6ZJrsfQ\F9.0E8-7N_jtP1@rY0j3IeVJ\R)rS:\ZmP]r7eDeaAf7^A,OtMq,s/WiDU<kEk/4?jg:Xi#l[V%D:m%tU]BXUYFK3j)?OpOiY<JNBscJp[(X:C\tJ#p!6"Eb#3FU<B=)\clg;t],P'9m:l.`a/&R$u:0im[3OrO4"_?!'PO)]lo#N>[oufWb@D1u$bt)<bY3"dS@.kWe7%kKPYT`5#:6l'r37HK42_KimC>)AtTlH['nW\2k5"_sdO_4rf*_%54[opiVmSfR]),1/,'Oa;-=1(PRs9^=Uia'qJ.G?a_s`pbZjaMC+P#oig<n'o@l<D&L*o-so-]NCO\+/cKd5m(pE+g(!)G+UI;Q8.q5\l6<g62djV5&6aobJmR>SaC]ODQV5<;EJMJ.*AFEf+(c0?hW.dDI6M.Aq/Wjk&-#%;9963K\@(m'iV2E$0\;k2:LquV_tKioiQ^@eZh'<I+6U>;@umAPa8M%^4=F@B!c,esj0n+&CUH2^OG9*@Z00uf(d"?soO)a-B<u&!H3O0ih<4Q8#e"E=QL9ZX.l=d0a85UB`cXX',^+[5V1*p)I?1A>@W1=r2i5S.OD87>dRZ-9XOXJ7R\8p35JFo%QN~>endstream
+endobj
+44 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2205
+>>
+stream
+Gau`TD/\/e&H88.EQ^%<8J>.SM^<6(J2BpN!bp5&0)A"%b/grl7]$l^:)XPsDr6\?CcRYgV_,+iM.6#::;#b]HVP8kr(uuDR01)A_=L_BVure$:lfiT3et&hhT]@i''b%(%.!f/$UW19nF0UVo`A=cmW]eHd1@:ii5TiBIQoiJdsPJt))'r-52ehKL`IjnJk\6D5(M$.(`d?)J"lIF,CbLj%6^&2kj@5&mn,dcb;iLYO5I4*m1F*.*H^>XFkn'Q6Y$j;Hh.*"$_dP9T9ebTZ2fC&$"R;Z<[n5*iraPr!plNuQcom:o-9dM$[!!%N0TL$MO,lH_#VK&_A8Q&TQ4E_$^P`fLF"pVZO7pem2jRp>5o=Nf/PG,]Te'a"W-4O3p3-aKOnfmDJU&u4G(]SBk)8Lh0^@\,e6`&'u3&o@!3'kB_dGOm)KA$6-#X)Q&5``#*slk^W,ap4W3LfGSseY^-;AYr6=F2Uaf:t4[Le)56>qe,^Irqo$BX?kadNS-MH7=S(9qcHR//1%>OBAMD,Tf[dAaXE(F5%)O)3gLQ=)+3lEmKW.W1KD,&rNW,&8a6Mq9B&5n^'cX/\gbR09:q34g^50TAq2+o6#AU/;*j.+:"%44m:q%fKuf=X:\N;_9n!>h+B$("K7?L;Y'7_WNa/$A;"(MKGYbp$4o&pT>]:65(JAb:**\54#LoV(-]?#;AO\#bd[eTK5K#Tp82T/aD:L:^F0RU(ZK3W%@lYJG=gEkcCVXC845.6jP[%XZUc#=1LpZe#=q4h,As0WT8uib\R!n0CHC'.02NDK`j'fm+Rf!C?F,&ua3qcAFMQL<VM2pnU(JN+ijQ4Ld-:)^;FWc?-jim*[/tf%?4@oThFh)BWdRQY5c1=Hj:%(*!9f),4Ct%#=g\=8=IL+nqt:!_Rj$qG2tsL4Y(AMnUsF11:?,$GT__dGg9hI,e=N6[R<E;=-D!Nd%&))-dTBRjA@o%(sNg%CPkD[foTgqe2;!::"fP:31K4(]7$04\-1,@r@+0i@V-s'(Cj65gK?46WN2YmGgMY=YBMpRsWZ*Gk^cm(V'.bQ;hh:OPj4-o^4tcI?+LoMq/2rDQdr;oOC5EnZo@$D(Gf;/[B&M'M5.1!$IclV7FRs6&c_],9noKfi!0!9sskK,;TcV*P$K9Q;>u*.T:K+2>+Dr4]@l-g22^7PjD##X_1keNYNjHnUrLTatoI3[>cV.m\)'#C!#MKGa_,\6@lMeh+$aURf8k,m'pIeK\18gXe8PCLI4e'`:Y>/kn^l\#D/gmn4a,^,_D@6\Q1-d(SgE'9IH3`JuKHtbmTK!b&qrNP"8;Td4l*IBI+*HGjcc+pH%aeaZA>3*8pcih18GdP%PGk/BSSoc_XM=fH:Sd%b=W@l<JR2c)i70E?ABq1bU$`[m1Wb1Y]OEbqu23I*4?]459E'KZP?W"W&*NRKL/XoIt#,a]3/JSA0E!Eq0,\4G,q9rVOK]*"QFb^;[+dMEuXZFe-SmEQbY0N:>-@\P?0Br6t3!b5g1j)I&fVQU-*[o&t)cFV@t_Ps6lr:U!c#gAN);MA'DYmVc,GO4H[&kh34('&&A,LtA\O@V5rCG!ClV'#tN,-?U93?(mCqo)crB8DlO@=bs'6?NrXmq_^D1[/k:k:2<tnA!^Jp]<H2hQ<DJsLPHV"+0SPjiSfriQ=5iV],AWoSEJOCA5#Z5Cl5CNjbmrV^$;m"XN)sA>u)\35,,WB2l^.$/>J+t>rl;W14s!:UD[u];_mCTp!QdWpnHj"o*PD![0e&uYq@/DemaNs9Qs7cIpGl+X<CKH;B]=FO,p@S>PQ15764"#jooP#Xo>fFdO:,VL/gRKWcU`=KDr$2L/C+@,qV4iV6iDX2>7#."k#hLNN)n,B>d1n6X9qrC<F,UhaPYn*bcbck?#4F36U@%)"[;6,pUu$e@[2#0X<*$FPIWM3#J?/.ZpZm2?r=1)P+$>Ik-T!@Xb..Uq:jS97D#QjpRqLd(,Gs2JrZh2K;$8LcG@MPbN8AFqLV(1D)Q&X@,CW./F!]U?bn.D8aIaaeAqF<d1)p(nP8]N/2DC]i2T_a_Ircg<ck,9:D7o=WO;Sl'@,He'JtMdk)8Z5MDdAU3bl>KF8ju7bo9ae)a/tD)No.[K'IqTZ]XYX4$_Dd3Fi[G@mkPR=*FlQKjQCrGKQ0MQQ>>CX\0e$R;BBbVV>"H'alX#B*[OmlqF2n'_~>endstream
+endobj
+45 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2670
+>>
+stream
+Gau0DD/\1M&cV3*0ecEl^<.C7q4=</dYiM_i6*FOML6"DXN?aGRcMmib)1PUs5%CTe2q4lBIh,sbiS9<c91^B1N[;`+34AQ'L[Eme(\Yn*)>NC3?Id*Hp^uqZcBCi,VfHV$bH5Z$R<u?B`G)FAqJL6c974KEBr;l=Lb$?0CNiCB2qo6/iA'=;d%\7-CfijM4#X0^S(,3B`+(IiX7YO/`[/@..CIW_:l4[IF`G=F<R)BVOrPXB?V6%+.0<Wh)34j;*8=%Z/k;[99K%-dlQVb"5<TBXd-&WW%(rIPJN7VSg>Sq13Y*u9%?:tSq!$5e5%irV:$e=U+B;3FX(uqbH.+qT_c4/=8=q(F8(#+Ms@H_oH/"s-Pqu)eLB+>b.O&/%dop'b/[JI9fC7lY$Wo:0m:J:N#^VG'UC<eEbD'&e6;!5-IO8=-?:m*45hXOaE'?T3W2'19ToYlH1QB7n&N)LDdP/2Gg&:.R_th]dg\HXUBJ>?$^/[F)hk!KKf!*[.1Ao,??<o\"jY3gkSXiDbsb"E4KI^1=31Q@9%L,*Cf5E%%k*oFWT[[+98Ld)HBJCB-Zb[c0jR\_4uekN>&Q+k-:ntUK0\S$f32gM-r[,fZ>+O[OYLoRM7TsMh2?Aj_-0]QY`Y2,K9<S1fT,P5I,r<XF+R`mq-Mhc4eAq2F.=qWr@@HBUkgf[Fon"T6ih@g-afc7:G:&b4O/38fNE*J`*Z<pM3[D.A**398+CB"\ufM+_2!jIomfK0Mj(c0dp7051O[Ud9g`OG<pCEXH8"f/$&6kq1)UCj0?P!T,t^g"+/_"f$]kWG[;'6E*D:tJLH?#\.<gEY'IA@6BU/ZsJdQ<[F.$+Y`<n0@*!Vqf=b@2e)g&HrcW_`&8ue\7+>K2a\-+jDkc?XC9,pg:h_"9tVdc3`HCGP&(7uUdP?\HSP8:I,61jVHLCH.sl>6=u>&>X'3GHjr3^7`>CG9rW(4!SIpYqhbHL+/Y941th3)S7"WV\r&e.H3#30dFIaI<oSBNZe?^uOPJ<b<R_W@E*3d,<;>c-#D1f\/I&,*U4+OIMp1E/Gs2\Zd3V]0rV$ghm`.0h`%)Cg]s21(f&@6!(C&6#D4VMF*TX4BIE+F/e7>na"H]GAMjTDG=B6dU14d)O]c#6I?],2+H`SG,LP0Nbr:bB]-QP?p=#iI,K*6i&;\r5lmAe"[)F6\R%DXHh%6"BVe/-dS[_Y(-[Ah\GGS2N\/`8GgKuUQH_a_1`>53XN:Ke>rn+k2g+PE`Lu$3#,@d[s&'rLr\8g(#-^N[=_J95h\d]-o`(`04[%/j#Cq8/lGr$_>fM!W_2usgLLcE-,ZK2XW-l4aG;Nbldk3HCPf$-OhF/!NrYk5lJO\#n7EPpV>bCo%gmH;LYtFPJKjK./UgBS1Ts3Q*[$s#eMdNH#rsS'7VM6Tp!Yut1H]$'g%T2(=0itA!"L852%>_D+7^,Q=5k$\KQBFnBggj"&\o$5L(:NbhLsE7c"9'T-CFgX^@UonMKWb%d^8@BhahX<L:a>CL9.G)1hYeCG&^@U8rN["2_72r!+tKeH!emRAk>?#g<G$"s>?apo(3sZ<qEq6JL><8E5sqYuV:)lVa8CBPjc4q1kS:1>hu]Pm;%T?NVpP3,m@;Y'KZp]"Fs6^&)E@g;*U_B,YQ'Z;'1E@-')>Eff,[P%))M?%;'jVk5[a4X<`Y-5d<LX/MaUQ?Ze7[gF<,g7@1I:3<UO$=rH/@B/,XO>moX@`JAnY0g*VMWqgbOQ[%9[WV6,k.,.4[ZVPb.g%f+!=Pmrd7$]YXH%>.FJ0]+`0g:n[C^K'CJ7&c0M"(hrr!E(eoYdZPR-su`h"MUFZj'M.)HfXZeOO91("s+0LlR6t&2e37[%mAg_hf/K9!nb%&F!iqJq73X'YVNL3$Q+<%]"\#_HUV<@H$)4JptI1mr:T@HqlfJ5pK&PoZo_aoaCALp<Z,s('R\fi?f'2>q6NAr62uRb[PHT\L&en!.$mR<E!+HuA_fWARIjV27^ZniPMaJ=Ss3hYPGqIDkJ+]X#Uf>]#JI$S@+sh/dd/,V_'l)j;h<S"R4*/[(e$V\[+R)p[5<X[j$j8]g?DSY@ipg.d7GD=jB-$e8&c^MS]d+qIA(i<o025JGVE]5ogKS+]8XCr.E9V)7e#EsKs\u-_pN86e^APoU/k*=FIh[-)%tZ;1d`)-5dM8pQ#ILZ%9f/\1Z6*ZQt]EjlBe:^g@Pd?Mnr"9BZ$)<0RBLLF0k*3Vcnt40#`,:3-6Tt\:/AnQ_A^)+n2n(\UFDW1Qo0gabhR7"Ve)C7bnH..$1VM15uO6>I79Sg0)nmK7#UU5jHNm!i7Zud-8Dj]u[%48s7HOYfH)5rET&LQF3V7B_f/gch`mM]:R&ihd&n[4\t'";jHN\$,L/#._9.[C"1<#f*[u>d7PjiXHP&e0X\#IU+uTiA=DrC<pd-1p$Jrkb:aIr.69="D64S[q9#*]$&1`kg[oBQ(=YlK>Nj"oOt*gmflnrZpNp+s'D-P*MrR/@e?If:=ZqcF/CpA3C4r5\ai:(C:!G`=#Kuflq<&e,qKG0+?pf'jrVA3g]9-0!)9s4^V#;I.i#ujs-s3kt7llgbPoD3s5G24Si,%1Q.@+Rg"/d]U\hBDZ>eB[S%9_2S!O/,0<?.G&gcKWle]Gc\71/\MFd89<rW='cOZ3~>endstream
+endobj
+46 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 3340
+>>
+stream
+Gau0F?#SIe(4FN4R-dPsen2uH.?`KrMJaAW"!kK,C*5/6!h($!;c=Zi6X'1IoXF;"1SdEAj,!?92IP4.Y<2L=giG+h0H]2'q,qMNqr]h`I2/u:Zg/nF+tmEWn(HI]=.`iB,:O(4hRn4'77eDO!IOZGY@p5KmEVKJ$aMeQZ%n;tD"c&5n(CKOZ^%Acg!=+V.P99^k6]o*/&?i52sgBbG5X!5nLG+<2i?d[BV*M_'[l!OQUO3%bh:H@*+*+jmdV]8&[quM&ZZ(>If&5,d6-sIH-0jSg^D0*8hr%mK5$6g&:.3>`Jg]n<e[66qK&tm%(piGZ62fR&.6GDJAZir<e^#DcHY\^B8+]@aJ8NPft]%gPXR=Hi")0gkOY)<n>[MRKl=Z=_P'.&0:Bjpl^2r@5,&10o-B48ak5r1j!h;VQOQ&KDadgOC;j0,Y\#K>STrqhHGRh$f2pp[bF',Td60W41qPHB.e1li@\)+r6+_#<h6:,"Ed"(AEkrNcPT*1=`aa4.r3!MS+YFbtr7uM:l*QqJ@pU5[5,i*?R_iS'Q7`K?ApLpmk>f,+[4KsZ\%rB3V["nY4ein8jI:(hEislg^r1kAE+H@aKrUSFQ#)kTV8db^g=;WLMPg+,cW6bq@`a>&)S))o\5[3i6)lHdm'`2@K!o_+,997jp337J@Kk,/8QnCe(k!!WrMIT\VQEiE#.!^$A]2)dQ%H4,P\2$,X!?[d`NB?2C;B.WB^U(3B5e<rjT@@;A'>cXQHql:=+)LerI'(b9nDp%p[$r:OY)f:l0aW#&Kb[q>H:1s#eDQkaQ6=L:^Oat'o]&VeggNO1\ZrY0:4ii+/f(aRJY%[o+N0TeHFAI[,EP=[Z=[Tpg-Ff9O#JGW8<TpM2<@5OZekaX0U+4l,;Wp`c.M/2Mh:$q`n/$G3hJXYk[6^\3g!%GAo-6=fS#pYhMYjlp@jc"(2]4Hsm"Fb>e_AZC&L$!oCS#H,E8E^`'cJL]\+;6FUN9i"4)3<Op/C@o0-CCuZ'seIK,+\#"HF.1?r:>t^lN/>Ep;Z2[0oeIYP#qDPM`O*1cd'hD9!$A"n`)(?4t>A1O_L?=(/]3aOYNQ<Vs1$k`V+9=uD%K<d6BTSN&>0bhOY9,DVZ>+Le)N@]2KKijWB1BSD*UZkW,%'7A3kV@)[t;[/O'P&7qn/6jD(5+r:kVkFd<0**>k\jt2R/JWn?%>[*q2j=8?9eiGt`$/EoU;iF[Md.orre%dQq?;C^@@*id,^$7?M%<)jjbah:-JW,n4(!"95:S?g.c@,6\":Le?.I($=/!0p%@9h$U3lrG<-K$J.ECfeE^KE9@t22!K`Y562>5qHaLO5P6sAkMumU%_TpBkQM(=!"Z+OGAAHGU+^VhU+7KOp(Mi:On^">Dt[uM(@MsB;f0(t?_>o7ZCnuEpB(=jk(Z8^-p^*2N4*H,+k.VIM@uU*FG&3\L]YeeA]YieYreTlVug)RXf++NJQT?lq069USO=EiPe8i:&(X`Se2;W%!saJ^AFCKZ:_YM#mPoEL&h8!nVO@`2s,o0m?h20cWL[T-#J[<.TqF9OXOY<_Y('hDdi;bUDU]H/a\6'a)K#ikFiM`O:kR7lN?UUSL<`Ttc656H8i($T`RlXfncN'XVPC31+9`&XBJQBDSkGi,'U\`/T#Sm1l^N)$Y4opteQ.%`X`7J/0\a6kP62\YLuf+#Hk3qtjQ0U7mDMG'-Yl)ZYXS[H%%haKjDsMHMu1.:`!pI5PO/kQ$F\K/EXVEE7A!eWe@oP*0]g4:!E;l<EJROR46Juid&!NY_Lio;PRBb6W<auq46a'LFU$c!1`jNt+_1ZSpNT!a3TWnkoPsC:AofVKe(G9R'$pU%LdQU"!;q6JiDr$WYm*+Ar9#1b9W/Wa(,PTpTl]%S..YfsM3B(TZE_Uh,sJ!BYge2amQ)W0IanR=Rj;=gT/BqCZJg3%@?JmLD#.QP%nMUW&*#*2UT(:R9H/[TkJn57M5g>WT7RYQ20^2##i+5i'j$_(?S2I:3Q,lbe^fHLh??#RjAV`f_Q1YabR&cZkiZCGrlG?@qKU"/>_.I\ee)ntMa='q`C+5$g3it$WdHX&!MN&S_H\$"gf64n1mRC,d*OIe4"N06bJH)&%Ja#s-84J1F!Am3W;o^:W:u$#oJf,*Vl^:,JqRaJ>2a*a03ZR?$"i+jR@??mIb5+C#g>Jqi)E,*%heU<s/Cm`blF'OJOVf&QBE(A/=SG7`_lQC6'n?G+4EO^_K^Co*5nYFcpHE!DLl0-d,O2@UG;sgQ;*<^+.&G/#Y'llAE'<hKI2O'C4abfE$gA>geH`DiR*FSLQTah#]#@Zfc`XfJim^9"_Yk*WYL6"D=H8j[t>0"q7U-5baVL=+-Mr3+$-ZTmHfG/2\%gWGEJscNg[&InNY$2BIC@oE,GL.fPSAB5LXnbl"IiVW<HPiA?W*HGIfGGWQ3i\)$E!VHkb=i=WZ'e#XV5qIB[24[U=,ibQ]\E>D`fc0VR>p/Sq"]X4irA&d5uQ5u_ToeBBk\En.0j+#i)8h"DX/Rr7P=@.ZEPjn.]W?.?ZX]:kR$lIsU6D(]V0Y/,P@+bTA2#YLq1`rPqT'&N1a+i\pPeA`qY&GAKS!&ap[-Ieb9#+/)!dLt"KbGXPE?T,$')?>L=^>0/0_B]aG9ZI6bC66_:]O:(5llHB9^aHe!jRA-_Rne<_bY,I2Oa\<D7Dm?-lnWmd4'i_&.\g*<Gs#-n8T^=`hGu(J&\:sUe<*$#dglia\`[JU?eS6[4VE`&#Si1F>/n7t-2!iAc))b0jVp9r.e]U=l"/*e6;@RdH=unh;t!bBIb;p3FRJ&CYW]Z@!ZpnVLoerl^(m:6GjHd0n!6odco]-n"[>-D[(e;Z^tf5[]e&!Z1&#;Rp-2W?gtCA1NhbLU.^:5p9^b)8FD@S#\ZKm.gFBn?2a0c,Y9/MP.nHBuHNB99Vk5Beo6SFHI'LP3Z<>pW0(ptnor^O\n#0pKc`Lqu9']ST6gkh+6![o9T0M5J5>HKH>HqC0jDCMF7;Wr>PWCH*=Vi[O?&3ITE>b)Z",,glh2r!@W#L%k?@7.S3"Zn*Y!Ud-9?b&]VtS6'@&\RO9j&gD7Y!^nCSkX)(V6ZCR!0e<Os:TUas.!)C%)p=jtO3OXCe/`Q?pbadFIK3Nb/eIoWL6#.gih_<]F=k'erPWdOGXp4a?X03c.;l!Bp_%m0@X$L;mlsU+l&3ne-=q=%h^<Vel.iE,m.Fe661EC1go>Tn\gOETF3iL&CKW&p@:XXK5qeo_d#":PbP*oX.o'Q`Gk0me_@5"T;,KC%'Z%B2qOg7]q&08f^U[h7m?jq.n_DW+_HrQL-Bg45XJMrW`fPIb4~>endstream
+endobj
+47 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2471
+>>
+stream
+Gb"/)D/\/e&H88.E@<M?.3)Ba7(m[jL3.4#FkN3A*kDjd$:Ru.26u:8E`448J)=+AIa\\$1g.*&7P'6`*fn?scQ+H3;"72b?Zu_D@LQ%>;4n?;k<O0a_tY'TNqYa+'bX.FCgn+?6oQ]'UTf0+015nGBP4nOW,2Op";T6JH$soG5=`&j+*]O<igkF)ik^:&'B[So#LqOanL#/<&RE&ec:^U]5`8<J&IY_cN@IBH!f_/mSRt>UI:WCY7EIP$7]C*@+<"R.'E;^Bc@qOV33f)^cFhYN&#(^`Hlb]-i1po;_UP3',Vqi6Zsh:`7215-PBKAE.n$$(Loh%H@/Gi,$?=:SE+Xrm(9th$@LpbVZo;GR7CL3[)Qig(h0'1,gnJCfiIlF$i5=Xh*,M0PHK+Z[K(DFpVLB4+q93A%Gkt%5ROdTsU2Zr-!@ODge.''o]6/U<GH5..6B,0X)OaNZ3o%k+0q$-LB79]Xfd`[BleBY3Ls8p03/qUJ.G5&jM\SsHMb8$@EB0FJ%Z1T8&Zp65;6.ut/;Qf5'5agF[%DjNJTp(_9CTeT?G\hq_\B8dGm`_3$tkTIFm[+GE,hj=WIO%8I_(2J>]=Wo4&\AVJAdHGH('gqaDCO,&;>BL9c"[09+38[%?&/o_V)4a?fK&7^r^t,UGYEKT>EGUErChN_]RJ:6Xf*0+pDU?ogO@*&1hfh+mMZ5n/V2.Zs]Z<A+-Je3l0!!NoHK;UU*afRmJ$%YDMc"bXka?4@s&1i>:CN)1e!!biKLLZG3G^"D==lTEDJ3]K(E;#6`<b))h-"Bi=aU=-8FaN7,S'7#pF=V@cJ)?][r-X?iX#Ka?9[f>Ip&YFG'ViiF[H'uS3l9Jr$$fKb/\'ZKp7=:&1qKu^W%ic#DdeCG/%gBKCt8'$gk1fc7be3\h@03/t<.5re_e4d1d20K4s%iqVs\'iDgAeI*%p%O[1Qgiu'pp]e@qmV'h5(],N*K%/rH/j36Mt5<%1(m,QJo^/#joMWGBG%l5Z]<=nJrTWbW#MfLrGWBreKQtm@V:`u'iP<Yf%+um8?/DIdS(+O_Fg8")+ROR<XRV]fE_="\/IW.):,S`NuOg=i.T_cKp2I08aO!=j3Lb[J%)7&\o&+^hWMJI(S^nH5Jl2D/8\oe>h+Fs"Bclm\sMV92oS*o^?V>NM:%_de-81=K`j\W)>M#Z@B6hjKu>`HDHV616=W_hAD<L'*ACLu0?Oja2W>ZgNH*c,L+"0]B>\.X>$5tU)B\1.e'sjGNg-O^1!DNBXcZWNPt>[IRFF>k)JroM$Yk)`fusd!Rc5sZ(h;PqJVQ^a1mJ]=h89%B@OH7N708!bj0Z?=`/$FdQa_lp^.>`?Y:C3%>-Ojf_tp4c^`'5!U8T:t;N!fsL6o3$::qDQ\Y'XA\hV'<-=mH0brr@82+s99A0&5W#)6QOAkD^9GWWU&m69jlZ^iPg/gnUKiUHX'k\qoW:s/Ein'!lR7RJMse8;L7l=M'/ji_O<-ct-OK%d##7*Me[bZ$#&?tYj*=gB!LU8n-MMB`:%F`UU<O]1V3j?"f!g^e)h[7/>W@(,rh'&K[EbctpEXW$P)ZQ&f%kfO8\9"mlAS6mbIPQdgs<A`8,3eB90_c:QR_s!>-1A,&*'1GEgf"7?]lJZWK\sS:SWg:j`qAh]bZ=s+qKrE]5X>T50NR_4(If:>X]l!#HQE>&MF$2X100CW>U5Yp3=ql`l4c[,M1S[B[jZQdL3Rmo1D[)qS96FJ=NhE)YJfE-C)dVCu*1Aa"h)%&Q+lu79>_;,+-R!=]UnTmFAE<b[F8M+WpRS.%%lF#6dbK9Rc0[I=>T6tAIC;"lMtBc5)m"@[(eA^;2pG>cFO#S$R,hH(NCp&j"8:K=C\c`OKopa((Qc3#:0?_$UG,ip]Lr4sV4W(Ugi:";::gZd_?eS+A[J1XBS>L'W#d"m9glB<Ja3+=hD_"1Rm+dYL=go!(V4rQn0)oRa$]SqIH8+V%bto#_-naE)P%9qS=;)U33/P,Un]hZ[s>P?R=q+FB?=$<I5'I=@(R<7XsgGH.1>SZctk$hGo,<Fa7XC]8Qe2OK6s1b%lnFno5`O"fQ[X6c!,/?4_gQ^G,gA)ju0g/?jqG[_<`GXTpd?d4^p1m":_mhEHeiK)*5PaI6U9*r&FmWeGRr_?i7gt.$_j=".og#Sb#'Fo0f8j!^PaBK75IL)OfPpW(u9H:W^B)_cdoj8SY]-GOrmT]M6mu`qFgD8U,Jh.[0ke5npAmdMTuICB3[HPVDUB_!WPS_&R&2LIl%AZ3Ltc'Z1-8:\koCYl@mZf,OYbZq!g7A=UR2p&42>gfe&dYNF)eQh/.D!2kN<B8&/qa_Ri7F\@!_VK'&EMt^dCZ`L03gfNTQp"=Y>C95SJ^+?0tp$#Y.\lPH+e[JRK=t;-!ar%j)bF0lVB%tJd0!l>%.h>J2,[)fNDHAT*)]=ZhYe4=72-WQZ#[)UX9&=,df_Yo"2B-'~>endstream
+endobj
+48 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2710
+>>
+stream
+Gb"/*h2g@"&V%R1K'5l%JdY:N?W7I::0K_M?o1DqDcKZU]=^5E3b^*YIE=kVpC8X/P'4C1`:I9;5]#)Rji7ciReb25\J,YN9@a'sH\B,H7^(ZI6lESM6.Eq=])I6:?!mNmU?gdD,K=0DNr=e2*_",AeZG?,46k&a0o\Q=!XsbNdH8&Z5+oZVp\QKX(&FE0&Oe9J_H;Kbl)d48?_Zjnd.LJ'`D=:^-PV6<,*+P(@C=IBGmJmDKOYX9iZlYl&o]JV(GNZ5$1d*nR"!9sWW]p/l2jmRK.odA#`jNYGADX"StT9RRcutN[`J&CbE8a#l1TW>%ck?gk_OVP_NSLg5<!%9g!"\&P^#0H7auGE;]:ARpp8]cbi(OIUt`SMf$Nu9p"n.Jl'I>eqm&Dt(.K/7egr*S5RX*KZ9;0P.%5X(n'^LfRQNnk@?6NL[oHUJmgq/cQ.VYj"$.(*F8>@Qljq>Qoe@%=B1B?IET9]K?*ddM-QC43fN"GH=uE0i@F^_VHgV6)>.'%&b>ahu\WtO<9,S+SK<cC1AV3nQ8c89Y<a+*5Fd#i8b!cC^Lq8GZM6pCsSe,c9,`QUF)P#Vo5Tqf(o6A^J0aSZ<!U+kB+K6-pm.c%n7!,ak,j<FFP`:6'Fpd/S[#R`AXW)baL\'#(j>#lD:/E!L%0r_J7*E`GOYj@ZjE:8i'Zifn`obV78%+n7^![hP21VHm%RB@fc.P0\=QG?=e;@5N[$(roJ5hcdTh=p\WX*SKWd0D@h;lIZeqeXEDM?()+!JXu7#fWi=V^G:UC&]e$FnLg'jsoC]EKe3o6=GWou?F%(:qb#D`*S&*p,Wq'XUM@EQ#fG*q>6+,CXH=0*diQ6&#)6a&<op,"hmhN?7k5#(r;I^65Y/T0AZN>,TgNe%3hBMgKEd2LG)o(ZgUBcNjg;>3fdBhKsskm$!7e9K6mGYF*/B-a+!mVJkLQGiUeRrmol+ocDoY/>@^8`i`_9=i&aY2Lr%[_:Z5LZ0(S'q.&S^0)!>H&E=sa/>_F)!kqqD>\Sftpeh9I"Y('893*+uO3bk==r"n#fd$*-b[MHp:U?KmI%Z2tmBYKJH%_6C!)\SpBCLd7AV!T((N&j@I*r?Kc\;A!;oIcXY4@Tg3-7/lmuP4oMHD]\f$(%KSMj3J`*(!D;5\2u(t^RbPr<#J-o!/SJ4]aH<4#ud1$L\7@Z'#Z5f-i.V<O'!p@er4?^l]&f4WH!U<&iR8mgdDU.Arf&Qd\:,*>8*^&UUCZHR5FPZV>,8Q+2l`-&hKGf[5.(?EKY@-Wf)o?/RB5=%-R/)o5Y,"YOaW+]YcQi[u5k.$Ng#$a_IN1>r.3qIh6g:]X&N!lGU`iCq=WYRMA@32&%4cW-iVF5*%(/7gL7#c(VI1eZaBD-US1l4>u81k@Fb*?sE-+8)fh4)D';PsIt!:EEb-GZo3ffZC_f,_8[F!UbQa7iWd[^9kGd)jtIrOn`m4M>NOQ!mh`OXPD9Da^t9rah@5=*TJ-NiGU,Vfck"a"&hB,U]A#L7`Tfg,fJrSW(kY#Pe&:"cg6O"T^[`r5X!t!2C)$%aocL$V<PFki]ApYk,Tpn(UCf!^1Bn2bT,mVU0c6dFPYFW:cP8n^s5<f0iSNs$cOPEMRJsW8@N3mU^CjhTf!SqO?pI@UIt]:qb]VBWm@*l]KN)4Ud*hGh28(e4tdB)Z.*O53qoMTJ)p[4(CW>4SS5j+O:;X?8rSr<+]Yd0eL^H87Wu!h:G;UN2<@t>7$EX<aF$Ia'M,=JVt`-L@g3QL*L<u$@(06_)'udP_Z9]8]]RYdBbq/lT:K"'kqRT\]I<@\*GOiWiE/ccH`:uLe9LZWXq8APc+UlgGI5Fop>86<UJ8upl'/S+"mY:k2QG`BdQ[]\$KKB$&p.Hf%Z1RD\:)sk#pN5oOI]"+F1?M*Wsn?/%57^QPI!fPe+f77VT+p!,0J#[Km&`ne#*8'fn<;/VAL$EOGXO(>%g7J,[Vjc4\n(:^\T*\i`qr+X]L14T?>:c?lh&8rmAsNB3n0GtC7hWK1O18@&@*?[=]X30e.Qo5V3E[,9bkqUCKe0p"-j=]D?qD(eQf#do1pGn9WY[(S=s#F!D"f%biETa^;XenErZ:Zj$j(<^8O^enbZZgP*TqIS_\h>3uG8T+Jr<$kcG-!dlpNSS`hhe\d`4K_#1M9K=WV4h[!IkJG"`#Lh'd-&;jL4a0)7@l`,SD"^FAmmBiR01.r`@]dhkRlJ!*(hkNP4ms7V,&0D=hZ\#nB;Ii]^F]'4R(^fpFLNphHH_ckYNLWi%>/SK0lb5R!]0#8Mn_+//)&is,nUp>ZBKZ2&Bh,iAr"o[,5(H7A\&R4RW6QNk7J<Ae9cRriEP+)V>Ko?A:i'-+I[bZn[ph2H@Cb-OpqpL@"YV</Nl;H+$(%O_=EV]YP**'"ImK9$rH!;8$!r`V<3GKTN@AC^*5\40ea;;Etj#@q#DnDgq<m,_"!m4+L%jh#a5&nZ'Mq66C_5j:Uik<11hb`!d:R;p5+9ics56Wnrcf-mtfLUY_c@nrB(dYJCJ[!>Er<B+U@GjKhWtdn;R:;C_1f`RC7E[B#C[_X5e3WM_f<<a`OM&RKtoM&mT:(D,aK"'&9MX"l:Qi8lo;h[M0@s2\kQf.@8rXjONKT4-5hNFtAG7\ffL1obHsiMc0!Wh0]2%pek$To?'QYsLS_oK?"L`_KMYe5P77X@@/<N7_^sg8Q.)p`E<,'T<~>endstream
+endobj
+49 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 2026
+>>
+stream
+Gb!;d>Ar7S'RoMS37sF!`2[shgS_,qMJ[(]XTl37!<u`%D)N$'O`VT9@D@44.JXb&C%f%NW@en2ofM%kN)(\roA0FL8bD&%?=3Nh#;fYH+*eICY%]qDnb7rZAS`/0?IHO]U3%B/5!?W[V;:'RdXrt=r(04@lp5S^K+F=#oWBZZ;/etmq1;8akr&fFWnEQ!5C#i,Y;CT;<W!3c>=!61Mc/1bL:)9p9d8Ij'7,%[H3nH&(]*/Hr1Gb:gf8>t]R"m.Pk\'qZKK"Dr2*e:*>smM;3HSG4DaA^#`9#Ia=].$k9ENo_/.(68$<:f6Bf6LAgJg'h/Q#?d"Y["qOSEGVi5>=61_K-(Pp[EiD/Nc.oe%S^#/,o:f^0*K[`sm:0\^fG\$J^Y3lm6c+/;;3#hdXokFJRAL3,EXA)&Uk+l(D1;ceaCb8=rFY.?7#cM=S4W"#^A?6njOA>6mRA]9h!G3sV4\I#<gqT)4PAU[TLdV&,O0?SH*)Y?8mEj*9B0K4a@KRUqYoGo1*lo^X:*S<XJ\/fEZ2MrqC$Gk74A5hf2:K/ONOgDqO/e%G>Bt[VTTBtCPJBshSSqdEaD\1#43tnf]q8V*Dn\o#^J-B=s%1[(5$q[R>g@fpF@3NiP*_FHhZ2/kd'k[#:1Ot_?4uoL*;S?cn("N.V*Q#`AW(f_f&8E"ejlf2E<>#o[Qa9Ob\af&8!M$OZY/]^&hcpGRZ%P3ceK4p-=.Soc74>19qJt6lpVCIa*S<%C@.We>#]Fn-eSOJ$`pFs5_<\_V6i[KjeEnmM#]EVPufp#8p\9(>KY*UP[KYh6"L/0C&-NL2C&MH:1a?6@"-,74kDjSgO>fr[E:JIk1l+CUX+p&<>$:GKNri:1:McRCfk]/);0jL0uYmMCZitATguMPN\>1Fo`aGDf?@bU-m[*DeU\Q93Up7Ki5]0o2C<La,eeIcm#F#o9')-^Eq$;8#d3Y>fB(fDZl\1<-QVq]bnW%"]gZI)m'A@qhSYU4*7e]6587(t.UQi%iFQka6/GAc5-li>B2:Db$9pCbKNXFOC@ibCVDTulkV$0gaJr]TapY5-[GEFeRXCpn]'Tc%gMNP/[\slc2qFCB_+RM>cpGfYT5e%TgY*>T)U475iXZp1NMu\9Ek/I42rpDK@(hIN4=OY<c^eEu?t]9u1(3>38DDq^/3gq(Y%Ro>5e#`1)C(M\ntIa]X$h.3gM*rYlZ;3T%Q)+g*>Pkp.7(U,h$\taY$fh"UP(@h(C[OFL%Q(/AP:"b*cK:1]sncY%G'mH0-@;N4$ugl],J-JXt.bS50N:$EJg68H?`m@'ekBFGpZX5C>'W\XPef:O9Hrk2KNhJM&2!/U+12q-6t($+i-f`^`#;@$^?4ZBE@R<MTCU:^[7.3%uS]UjeW],>&)HtL8BWKiXs7Kq0@>Z*dID+k&e+WDca$If%`^'A.PDF`NWTO)GoaOT0j`;@E!sY\i%Th99ib&TW9+4gebMe_i:%'OA,!pG%B+7N[>`T0`:0X$,"oa;-([C#G+_nG\^;;cm=BPd6^j0Z_8C.5u!l7G'Xj[(JPtkIbtabf#6C7W:*,[_hPT,>qo!dZ$as:8f($e5chE)WDI/Z\0;ha2a"[&EXmHaClu7_P:6pHY1QPQg"erQr4nA'(ScQ1G7M]sbA@p.@'.Wn+;tOi7V"@SFOe@)Rq;+Y:F_DW\s(Z6G9E.Cg)NV;TB@m,J?f8^c).3=TOY7*\%P9$QF%YQ2;7Q63d6rP/PieBV*K.u--M_ba>Rf;<JkWS2XDi:5NN>*(&#oZ]oq.L@ia2pD`cbd5U`$hj-C?114K4S&JMt_7u2)d#]F(YW:-UIZ\)kC'13W/&"5I4V#<q0:(6O<s8'YFil'cInISW<s&gP)Sp+`=PHd&=_tZG;R=en!iA,T2`r;B7Fan-i*EDh=jW"2,4$M@GqPFFFhYqY*#\L7\>e#73K?A#8gs<,nZVN615Hs.Nc`VHgGIa`ZlE@C0#QF*`Z<anLC-*L'C;_gM.DoDa7ELQ!^2r-?_u4kI?Mk0?cG&i~>endstream
+endobj
+xref
+0 50
+0000000000 65535 f 
+0000000061 00000 n 
+0000000156 00000 n 
+0000000263 00000 n 
+0000000375 00000 n 
+0000000480 00000 n 
+0000000563 00000 n 
+0000000640 00000 n 
+0000000835 00000 n 
+0000000950 00000 n 
+0000001145 00000 n 
+0000001265 00000 n 
+0000001461 00000 n 
+0000001657 00000 n 
+0000001853 00000 n 
+0000002049 00000 n 
+0000002245 00000 n 
+0000002441 00000 n 
+0000002637 00000 n 
+0000002833 00000 n 
+0000003029 00000 n 
+0000003225 00000 n 
+0000003421 00000 n 
+0000003617 00000 n 
+0000003813 00000 n 
+0000004009 00000 n 
+0000004205 00000 n 
+0000004401 00000 n 
+0000004597 00000 n 
+0000004667 00000 n 
+0000004954 00000 n 
+0000005143 00000 n 
+0000007611 00000 n 
+0000010655 00000 n 
+0000012936 00000 n 
+0000015192 00000 n 
+0000017494 00000 n 
+0000020596 00000 n 
+0000023080 00000 n 
+0000025839 00000 n 
+0000027906 00000 n 
+0000029680 00000 n 
+0000031893 00000 n 
+0000033671 00000 n 
+0000035767 00000 n 
+0000038064 00000 n 
+0000040826 00000 n 
+0000044258 00000 n 
+0000046821 00000 n 
+0000049623 00000 n 
+trailer
+<<
+/ID 
+[<448c678ec75143473aed934ad841dca0><448c678ec75143473aed934ad841dca0>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 29 0 R
+/Root 28 0 R
+/Size 50
+>>
+startxref
+51741
+%%EOF

Docus & mps/DEFENSE_04_parser_ast_semantic_icg_interpreter.md

@@ -0,0 +1,2290 @@
+# File 4 of 7: Parser, AST, Semantic, ICG, and Interpreter
+
+This section continues the defense guide after `server.py`, tokens/errors, and `lexer.py`. It covers the rest of the backend compiler pipeline up to execution.
+
+Compiler path covered here:
+
+```text
+lexer tokens -> cfg.py grammar -> Gal_Parser.py LL(1) parser -> GALsemantic.py AST builder -> GALsemantic.py semantic validator -> icg.py TAC generator -> GALinterpreter.py execution
+```
+
+Important implementation note:
+
+- `GALsemantic.py` is not only semantic analysis. In this codebase, it also defines AST node classes and contains the AST builder.
+- `icg.py` currently generates intermediate code from the validated token stream, not from the AST.
+- The GAL PDF says arrays start at index 1. The current interpreter uses Python-style index checks and access, so list/vine runtime indexing is 0-based. This is a mismatch to disclose.
+
+---
+
+## A. Backend/cfg.py
+
+### 1. FILE PURPOSE
+
+`cfg.py` stores the context-free grammar and computes the FIRST, FOLLOW, and PREDICT sets used by the LL(1) parser.
+
+It fits between lexer and parser:
+
+```text
+tokens from lexer.py + grammar sets from cfg.py -> LL1Parser in Gal_Parser.py
+```
+
+`server.py` does not directly parse the grammar. It imports `cfg`, `first_sets`, and `predict_sets`, then passes them into `LL1Parser`.
+
+### 2. IMPORTS / DEPENDENCIES
+
+Code:
+
+```python
+import sys
+from collections import defaultdict
+```
+
+Explanation:
+
+- `sys` is used to reconfigure console encoding on Windows.
+- `defaultdict` is used for grammar sets so each non-terminal can collect terminals without manually initializing every set.
+- If `defaultdict` is removed, FIRST/FOLLOW computation would need manual dictionary initialization.
+
+### 3. GLOBAL CONSTANTS / VARIABLES
+
+Code:
+
+```python
+EPSILON = "lambda symbol in source"
+cfg = {...}
+first_sets = compute_first(cfg)
+follow_sets = compute_follow(cfg, first_sets)
+predict_sets = compute_predict(cfg, first_sets, follow_sets)
+```
+
+Explanation:
+
+- `EPSILON` represents an empty production.
+- `cfg` is the grammar dictionary.
+- `first_sets` stores what terminals can begin each non-terminal.
+- `follow_sets` stores what terminals can legally follow each non-terminal.
+- `predict_sets` stores the final LL(1) decision sets.
+- If `predict_sets` is wrong, the parser will choose the wrong production or report syntax errors incorrectly.
+
+### 4. CLASSES AND FUNCTIONS
+
+`compute_first(cfg)`
+
+- Input: grammar dictionary.
+- Output: FIRST set dictionary.
+- Stage: parser preparation.
+- Purpose: Know which terminals can start each grammar rule.
+
+`compute_follow(cfg, first)`
+
+- Input: grammar and FIRST sets.
+- Output: FOLLOW set dictionary.
+- Stage: parser preparation.
+- Purpose: Know what can appear after a non-terminal, especially when epsilon is possible.
+
+`compute_predict(cfg, first, follow)`
+
+- Input: grammar, FIRST, FOLLOW.
+- Output: PREDICT set dictionary.
+- Stage: parser preparation.
+- Purpose: Build the LL(1) production-selection data.
+
+### 5. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+Code:
+
+```python
+def compute_first(cfg):
+    first = defaultdict(set)
+    epsilon = EPSILON
+```
+
+Explanation:
+
+- Defines the FIRST computation function.
+- `first` maps each non-terminal to a set of starting terminals.
+- `epsilon` stores the empty-production symbol locally for readability.
+
+Code:
+
+```python
+for lhs, productions in cfg.items():
+    for prod in productions:
+        if not prod:
+            continue
+        if prod[0] == epsilon:
+            first[lhs].add(epsilon)
+        elif prod[0] not in cfg:
+            first[lhs].add(prod[0])
+```
+
+Explanation:
+
+- Loops through every grammar rule.
+- `lhs` is the non-terminal on the left side.
+- `prod` is one right-side production.
+- Empty productions are skipped.
+- If the production directly starts with epsilon, epsilon is added.
+- If the first symbol is a terminal, that terminal is added.
+- This is the first pass before recursive dependencies are resolved.
+
+Code:
+
+```python
+changed = True
+while changed:
+    changed = False
+```
+
+Explanation:
+
+- FIRST sets depend on one another, so one pass is not enough.
+- The loop repeats until no FIRST set changes.
+- This is a fixed-point algorithm.
+
+Code:
+
+```python
+if symbol in cfg:
+    first[lhs] |= (first[symbol] - {epsilon})
+    if epsilon not in first[symbol]:
+        break
+else:
+    if symbol != epsilon:
+        first[lhs].add(symbol)
+    break
+```
+
+Explanation:
+
+- If a production symbol is a non-terminal, copy its FIRST set into the current rule.
+- Epsilon is excluded first because epsilon does not consume input.
+- If that non-terminal cannot become epsilon, stop scanning the production.
+- If the symbol is terminal, add it and stop.
+
+### 6. DEFENSE QUESTIONS
+
+Q: Why do you need FIRST and FOLLOW sets?
+
+A: They turn the grammar into parser decisions. FIRST tells what can start a rule, and FOLLOW helps decide when an empty production is allowed.
+
+Q: Why use PREDICT sets?
+
+A: PREDICT sets tell the LL(1) parser exactly which production to use based on the current non-terminal and one lookahead token.
+
+### 7. MEMORIZED EXPLANATION
+
+`cfg.py` is the grammar preparation file. It stores the GAL grammar and computes FIRST, FOLLOW, and PREDICT sets. The parser uses those sets to choose grammar productions during LL(1) parsing.
+
+---
+
+## B. Backend/Gal_Parser.py
+
+### 1. FILE PURPOSE
+
+`Gal_Parser.py` performs syntax analysis using LL(1) parsing. It also bridges syntax analysis to AST construction through `parse_and_build()`.
+
+Pipeline position:
+
+```text
+tokens -> parser.parse() -> syntax result
+tokens -> parser.parse_and_build() -> syntax result + AST + symbol table
+```
+
+### 2. IMPORTS / DEPENDENCIES
+
+Code:
+
+```python
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Set, Tuple
+```
+
+Explanation:
+
+- Future annotations simplify type hints.
+- `dataclass` is used for normalized token views.
+- `typing` makes parser inputs and outputs clearer.
+
+Code:
+
+```python
+from GALsemantic import (
+    build_ast as _build_ast,
+    symbol_table as _builder_st,
+    SemanticError as _SemanticError,
+)
+```
+
+Explanation:
+
+- `_build_ast` is called after syntax succeeds.
+- `_builder_st` is read after AST construction to serialize variables/functions.
+- `_SemanticError` catches AST-building errors.
+- This is why AST construction is connected to the parser even though AST node classes live in `GALsemantic.py`.
+
+### 3. GLOBAL CONSTANTS / VARIABLES
+
+No major global parser object is created here. The parser instance is created in `server.py`.
+
+### 4. CLASSES AND FUNCTIONS
+
+`_TokView`
+
+- Input: normalized token data.
+- Purpose: Give the parser a consistent token format.
+
+`_as_tok(token)`
+
+- Input: token object or dictionary.
+- Returns: `_TokView`.
+- Purpose: Make parser reusable from lexer objects or JSON-like dictionaries.
+
+`LL1Parser.__init__`
+
+- Receives grammar, FIRST sets, PREDICT sets, start symbol, EOF marker, skip token types, aliases.
+- Builds the parsing table.
+
+`construct_parsing_table()`
+
+- Receives no external input except parser state.
+- Returns LL(1) table.
+- Detects LL(1) conflicts.
+
+`parse(tokens)`
+
+- Input: token sequence.
+- Returns: `(success, errors)`.
+- Stage: syntax analysis.
+
+`parse_and_build(tokens)`
+
+- Input: token sequence.
+- Returns: dictionary with `success`, `errors`, `ast`, and `symbol_table`.
+- Stage: syntax + AST construction.
+
+### 5. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+Code:
+
+```python
+@dataclass(frozen=True)
+class _TokView:
+    type: str
+    value: str
+    line: int
+    col: int = 0
+```
+
+Explanation:
+
+- `_TokView` is a read-only token representation.
+- The parser only needs token type, value, line, and column.
+- `frozen=True` means parser logic cannot accidentally mutate token data.
+
+Code:
+
+```python
+def _as_tok(token):
+    if isinstance(token, Mapping):
+        return _TokView(...)
+    return _TokView(...)
+```
+
+Explanation:
+
+- If the input token is a dictionary, fields are read with `.get()`.
+- If it is a lexer `Token` object, fields are read with `getattr()`.
+- This protects the parser from depending on only one token representation.
+
+Code:
+
+```python
+class LL1Parser:
+    def __init__(self, cfg, predict_sets, first_sets, *, start_symbol="<program>", end_marker="EOF", epsilon_symbols=(...), skip_token_types=None, token_type_alias=None):
+        self.cfg = cfg
+        self.predict_sets = predict_sets
+        self.first_sets = first_sets
+```
+
+Explanation:
+
+- Defines the parser class.
+- Receives grammar and parsing sets from `cfg.py`.
+- Stores start symbol and EOF marker.
+- Allows skipped token types such as newline.
+- Allows token aliases when lexer names and grammar names differ.
+
+Code:
+
+```python
+self.skip_token_types = set(skip_token_types or {"\n"})
+self.token_type_alias = token_type_alias or {
+    'idf': 'id',
+    'dbllit': 'dblit',
+}
+self.parsing_table = self.construct_parsing_table()
+```
+
+Explanation:
+
+- Newline is skipped by default.
+- Token aliases handle naming inconsistencies.
+- The parsing table is built immediately when the parser is constructed.
+
+Code:
+
+```python
+def construct_parsing_table(self):
+    table = {}
+    for non_terminal, productions in self.cfg.items():
+        row = {}
+```
+
+Explanation:
+
+- Creates the LL(1) table.
+- Each non-terminal gets one row.
+
+Code:
+
+```python
+key = (non_terminal, tuple(production))
+terms = self.predict_sets.get(key, set())
+for terminal in terms:
+    if terminal in row and row[terminal] != production:
+        raise ValueError(...)
+    row[terminal] = production
+```
+
+Explanation:
+
+- Looks up the PREDICT set for that production.
+- For each lookahead terminal, stores which production to use.
+- If two productions claim the same lookahead, that is an LL(1) conflict.
+
+Code:
+
+```python
+def parse(self, tokens):
+    toks = [_as_tok(t) for t in tokens]
+    toks = [_TokView(self._normalize_token_type(t.type), t.value, t.line, t.col) for t in toks]
+    toks = self._ensure_eof(toks)
+```
+
+Explanation:
+
+- Converts tokens into parser view objects.
+- Normalizes token type names.
+- Ensures EOF exists.
+
+Code:
+
+```python
+stack = [self.end_marker, self.start_symbol]
+index = 0
+```
+
+Explanation:
+
+- LL(1) parsing uses a stack.
+- EOF is bottom marker.
+- `<program>` is the first grammar symbol to expand.
+- `index` points to the current input token.
+
+Code:
+
+```python
+while stack:
+    top = stack[-1]
+    tok = current_token()
+    token_type = tok.type
+```
+
+Explanation:
+
+- Main parser loop.
+- `top` is the grammar symbol currently being matched or expanded.
+- `tok` is the current lookahead token.
+
+Code:
+
+```python
+if token_type in self.skip_token_types and top != token_type:
+    index += 1
+    continue
+```
+
+Explanation:
+
+- Skips newline tokens.
+- This is the skipped token filtering requested in the defense prompt.
+- It lets the lexer keep newlines while the parser ignores them.
+
+Code:
+
+```python
+if top in self.parsing_table:
+    row = self.parsing_table[top]
+    if token_type in row:
+        production = row[token_type]
+```
+
+Explanation:
+
+- If `top` is a non-terminal, the parser uses the parsing table.
+- The lookahead token chooses one production.
+
+Code:
+
+```python
+stack.pop()
+if production is not epsilon:
+    stack.extend(reversed(production))
+continue
+```
+
+Explanation:
+
+- Removes the non-terminal.
+- Pushes the right-hand side of the chosen production.
+- Uses reverse order because stacks process last-in-first-out.
+
+Code:
+
+```python
+expected = set(row.keys())
+error_msg = self._generate_helpful_error(...)
+return False, [error_msg]
+```
+
+Explanation:
+
+- If no production matches, syntax fails.
+- The parser generates a helpful message with expected tokens.
+
+Code:
+
+```python
+if top == token_type:
+    ...
+```
+
+Explanation:
+
+- If the stack top is a terminal and equals the current token type, the parser consumes the token.
+- This is a successful match.
+
+Code:
+
+```python
+elif expecting_value_for_type is not None and token_type in {...}:
+    type_value_map = {...}
+```
+
+Explanation:
+
+- The parser includes extra validation for simple declaration assignments.
+- This is partially semantic checking inside the parser for better immediate messages.
+- Full semantic validation still happens later through `validate_ast()`.
+
+Code:
+
+```python
+def parse_and_build(self, tokens):
+    syntax_ok, syntax_errors = self.parse(tokens)
+    if not syntax_ok:
+        return {"success": False, "errors": syntax_errors, "ast": None, "symbol_table": {}}
+```
+
+Explanation:
+
+- `parse_and_build()` starts by running syntax validation.
+- If syntax fails, AST construction is skipped.
+- This protects AST builder from invalid token order.
+
+Code:
+
+```python
+filtered = [t for t in tokens if getattr(t, 'type', '') != '\n']
+ast = _build_ast(filtered)
+```
+
+Explanation:
+
+- Removes newline tokens before AST construction.
+- Calls `build_ast()` from `GALsemantic.py`.
+
+Code:
+
+```python
+st = {
+    "variables": [...],
+    "functions": {...},
+}
+```
+
+Explanation:
+
+- Converts the AST builder's symbol table into a JSON-friendly dictionary.
+- Returned to server and frontend.
+
+Code:
+
+```python
+except _SemanticError as e:
+    return {"success": False, "errors": [str(e)], "ast": None, "symbol_table": {}, "error_stage": "semantic"}
+```
+
+Explanation:
+
+- AST builder can detect semantic-like errors while building.
+- The parser reports those as semantic-stage errors, not pure syntax errors.
+
+### 6. DEFENSE QUESTIONS
+
+Q: Why does the parser skip newline tokens?
+
+A: The lexer emits newlines for display and accurate lines, but grammar matching should not depend on formatting. So the parser skips `\n`.
+
+Q: Why does `parse_and_build()` parse first before building AST?
+
+A: AST construction assumes valid structure. Parsing first prevents invalid syntax from creating a broken tree.
+
+Q: Why are there semantic checks inside the parser?
+
+A: Some checks are added for clearer early diagnostics, but the full semantic pass still runs after AST construction.
+
+### 7. WALKTHROUGH EXAMPLE
+
+For:
+
+```gal
+root() {
+    seed age = 10;
+    plant(age);
+    reclaim;
+}
+```
+
+The parser matches the grammar for `root`, parameter parentheses, function body, declaration, print statement, reclaim statement, closing brace, and EOF.
+
+### 8. MEMORIZED EXPLANATION
+
+`Gal_Parser.py` validates GAL syntax using LL(1) parsing. It uses the grammar and PREDICT sets from `cfg.py`, skips newline tokens, reports syntax errors, and only after successful parsing does it call the AST builder.
+
+---
+
+## C. Backend/GALsemantic.py: AST Nodes and AST Builder
+
+### 1. FILE PURPOSE
+
+`GALsemantic.py` has two responsibilities:
+
+1. It defines AST node classes and builds the AST from validated tokens.
+2. It validates the AST semantically.
+
+This section covers the AST-building part first.
+
+### 2. IMPORTS / DEPENDENCIES
+
+Code:
+
+```python
+import re
+```
+
+Explanation:
+
+- Used for pattern checks inside semantic parsing/validation.
+- If removed, regex-based validation would fail where used.
+
+### 3. GLOBAL CONSTANTS / VARIABLES
+
+Important state:
+
+- `symbol_table`: records variables, functions, scopes, and bundle types during AST construction.
+- `context_stack`: helps know whether parser is inside loop/switch-like contexts.
+
+Important warning:
+
+- Because `symbol_table` is shared state, `build_ast()` resets it at the start of each compilation.
+
+### 4. CLASSES AND FUNCTIONS
+
+`SemanticError`
+
+- Exception class for line-numbered semantic/syntax messages.
+
+`ASTNode`
+
+- Base class for all AST nodes.
+
+AST subclasses include:
+
+- `ProgramNode`
+- `VariableDeclarationNode`
+- `AssignmentNode`
+- `BinaryOpNode`
+- `FunctionDeclarationNode`
+- `FunctionCallNode`
+- `IfStatementNode`
+- `ForLoopNode`
+- `WhileLoopNode`
+- `DoWhileLoopNode`
+- `PrintNode`
+- `ReturnNode`
+- `SwitchNode`
+- `ListNode`
+- `ListAccessNode`
+- `MemberAccessNode`
+- `BundleDefinitionNode`
+
+`SymbolTable`
+
+- Tracks declarations and scopes during AST construction.
+
+`build_ast(tokens)`
+
+- Entry point for AST construction.
+
+`parse_function(...)`
+
+- Builds function declaration nodes for `root()` and `pollinate` functions.
+
+`parse_statement(...)`
+
+- Dispatches statements based on token type/value.
+
+### 5. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+Code:
+
+```python
+class ASTNode:
+    def __init__(self, node_type, value=None, line=None):
+        self.node_type = node_type
+        self.value = value
+        self.children = []
+        self.parent = None
+        self.line = line
+```
+
+Explanation:
+
+- All AST nodes share this structure.
+- `node_type` tells what kind of construct it is.
+- `value` stores things like identifier names, literal values, or operators.
+- `children` store nested syntax structure.
+- `parent` gives reverse navigation.
+- `line` supports error reporting.
+
+Code:
+
+```python
+def add_child(self, child):
+    child.parent = self
+    self.children.append(child)
+```
+
+Explanation:
+
+- Adds a child node.
+- Also records the parent pointer.
+- Parent pointers are used later, especially by interpreter input handling.
+
+Code:
+
+```python
+class VariableDeclarationNode(ASTNode):
+    def __init__(self, var_type, var_name, value=None, line=None):
+        super().__init__("VariableDeclaration", line=line)
+        self.add_child(ASTNode("Type", var_type, line=line))
+        self.add_child(ASTNode("Identifier", var_name, line=line))
+        if value:
+            self.add_child(value)
+```
+
+Explanation:
+
+- Represents declarations like `seed age = 10;`.
+- Child 0 is type.
+- Child 1 is identifier.
+- Optional child 2 is initializer.
+- The interpreter relies on this exact child order.
+
+Code:
+
+```python
+class FunctionDeclarationNode(ASTNode):
+    def __init__(self, return_type, name, params, line=None):
+        super().__init__("FunctionDeclaration", name, line=line)
+        self.add_child(ASTNode("ReturnType", return_type, line=line))
+        self.add_child(params)
+```
+
+Explanation:
+
+- Represents both `root()` and `pollinate` functions.
+- Function name is stored in `value`.
+- Return type and parameter list are children.
+- The function body block is added later.
+
+Code:
+
+```python
+class SymbolTable:
+    def __init__(self):
+        self.variables = {}
+        self.global_variables = {}
+        self.functions = {}
+        self.scopes = [{}]
+        self.current_func_name = None
+        self.function_variables = {}
+        self.bundle_types = {}
+```
+
+Explanation:
+
+- Tracks declared names during AST construction.
+- `variables` stores global variables.
+- `functions` stores function declarations.
+- `scopes` tracks local scopes.
+- `current_func_name` tells whether we are inside a function.
+- `function_variables` detects duplicate local variables.
+- `bundle_types` stores struct-like definitions.
+
+Code:
+
+```python
+def declare_variable(self, name, type_, value=None, is_list=False, is_fertile=False):
+    scope = self.scopes[-1]
+    current_func = self.current_func_name
+```
+
+Explanation:
+
+- Declares a variable in the active scope.
+- Uses the current function name to distinguish locals from globals.
+- Stores whether the variable is an array/list or constant.
+
+Code:
+
+```python
+if name in self.functions:
+    return f"Semantic Error: Variable '{name}' already declared as a function."
+```
+
+Explanation:
+
+- Prevents a variable from reusing a function name.
+- This is a semantic rule because the name is lexically valid but invalid in context.
+
+Code:
+
+```python
+def lookup_variable(self, name):
+    for scope in reversed(self.scopes):
+        if name in scope:
+            return scope[name]
+    if name in self.variables:
+        return self.variables[name]
+    return f"Semantic Error: Variable '{name}' used before declaration."
+```
+
+Explanation:
+
+- Searches local scope first, then globals.
+- Supports normal scoping behavior.
+- Reports declaration-before-use errors.
+
+Code:
+
+```python
+def build_ast(tokens):
+    root = ProgramNode()
+    symbol_table.variables = {}
+    symbol_table.functions = {}
+    symbol_table.scopes = [{}]
+    symbol_table.function_variables = {}
+    symbol_table.bundle_types = {}
+    index = 0
+```
+
+Explanation:
+
+- Creates the AST root.
+- Resets old compiler state.
+- Begins token scanning at index 0.
+- Resetting matters because the server may compile many programs in one run.
+
+Code:
+
+```python
+while index < len(tokens):
+    token = tokens[index]
+```
+
+Explanation:
+
+- Main AST-building loop.
+- Reads top-level program constructs: global declarations, `pollinate`, `bundle`, and `root`.
+
+Code:
+
+```python
+if tokens[index].value in {"seed", "tree", "vine", "leaf", "branch"}:
+    id_type = token.value
+    index += 1
+    if tokens[index].type != "id":
+        raise SemanticError(...)
+    id_name = tokens[index].value
+    index += 1
+    node, index = parse_variable(tokens, index, id_name, id_type)
+```
+
+Explanation:
+
+- Handles top-level variable declarations.
+- Reads data type then identifier.
+- Delegates initializer/list handling to `parse_variable()`.
+
+Code:
+
+```python
+elif tokens[index].value in {"pollinate"}:
+    index += 1
+    if tokens[index].value in {"seed", "tree", "vine", "leaf", "branch", "empty"}:
+        id_type = tokens[index].value
+        index += 1
+        id_name = tokens[index].value
+        index += 1
+        node, index = parse_function(tokens, index, id_name, id_type)
+```
+
+Explanation:
+
+- Handles user-defined function declarations.
+- `pollinate` must be followed by return type.
+- Then function name is read.
+- `parse_function()` handles parameters and body.
+
+Code:
+
+```python
+elif token.value in {"root"}:
+    func_name = token.value
+    func_type = "empty"
+    node, index = parse_function(tokens, index, func_name, func_type)
+```
+
+Explanation:
+
+- Handles the main entry point.
+- `root()` is treated as an empty-return function.
+- Later, the interpreter explicitly calls `root()`.
+
+Code:
+
+```python
+elif token.value == "bundle":
+    bundle_name = tokens[index + 1].value
+    members = {}
+```
+
+Explanation:
+
+- Handles bundle/struct definitions.
+- Collects member fields and stores the type definition.
+
+Code:
+
+```python
+def parse_function(tokens, index, func_name, func_type):
+    symbol_table.current_func_name = func_name
+```
+
+Explanation:
+
+- Begins function parsing.
+- Sets current function context so local declarations go into function scope.
+
+Code:
+
+```python
+if func_name in {"root"}:
+    symbol_table.enter_scope()
+    index += 1
+    if tokens[index].type == "(":
+        index += 1
+        if tokens[index].type != ")":
+            raise SemanticError(...)
+```
+
+Explanation:
+
+- Special handling for `root()`.
+- Enters a local scope for root body.
+- Requires empty parameter list.
+- Rejects `root(seed x)` because root should not receive parameters.
+
+Code:
+
+```python
+while tokens[index].type != ")":
+    if tokens[index].value in {"seed", "tree", "vine", "leaf", "branch", "empty"}:
+        param_type = tokens[index].value
+        ...
+        params_node.add_child(param_node)
+        symbol_table.declare_variable(param_name, param_type, is_list=is_list)
+```
+
+Explanation:
+
+- Parses pollinate function parameters.
+- Builds parameter AST nodes.
+- Declares each parameter in the function's local scope.
+
+Code:
+
+```python
+while tokens[index].type != "}":
+    stmt, index = parse_statement(tokens, index, func_type)
+    if stmt:
+        block_node.add_child(stmt)
+        if _contains_return(stmt):
+            has_any_return = True
+```
+
+Explanation:
+
+- Parses statements inside the function body.
+- Adds them to a block node.
+- Tracks whether `reclaim` appears.
+
+Code:
+
+```python
+if (func_type != "empty" and not all_paths) and func_name not in {"root"}:
+    raise SemanticError(...)
+```
+
+Explanation:
+
+- Non-empty functions must return a value on all paths.
+- This enforces `reclaim value;` for functions like `pollinate seed add(...)`.
+
+Code:
+
+```python
+if not has_any_return:
+    if func_name == "root":
+        raise SemanticError("root() must end with 'reclaim;'", line)
+```
+
+Explanation:
+
+- Enforces required termination in `root()`.
+- This matches the GAL specification.
+
+Code:
+
+```python
+def parse_statement(tokens, index, func_type=None):
+    token = tokens[index]
+    if token.type == ";":
+        return None, index + 1
+```
+
+Explanation:
+
+- Dispatches individual statements.
+- Ignores stray semicolons safely.
+
+Code:
+
+```python
+if token.value in {"seed", "tree", "vine", "leaf", "branch"}:
+    var_type = token.value
+    var_name = tokens[index + 1].value
+    node, index = parse_variable(tokens, index, var_name, var_type)
+```
+
+Explanation:
+
+- Handles local variable declarations.
+- Produces a `VariableDeclarationNode` or declaration list node.
+
+Code:
+
+```python
+elif token.type == "id" and tokens[index + 1].type == "(":
+    func_name = token.value
+    error = symbol_table.lookup_function(func_name)
+    func_call_node, index = parse_function_call(...)
+```
+
+Explanation:
+
+- Detects function calls.
+- Checks that the function exists.
+- Builds a function call AST node.
+
+### 6. DEFENSE QUESTIONS
+
+Q: Why does `GALsemantic.py` build the AST?
+
+A: In this implementation, AST node definitions and AST building are grouped with semantic logic. The parser calls it only after syntax succeeds.
+
+Q: Why reset the symbol table in `build_ast()`?
+
+A: The server can compile multiple programs. Resetting prevents old variables/functions from leaking into a new compilation.
+
+Q: Why store parent links in AST nodes?
+
+A: Parent links help when a node needs context. For example, the interpreter checks where an input node appears to determine the target variable and type.
+
+### 7. WALKTHROUGH EXAMPLE
+
+For:
+
+```gal
+seed age = 10;
+plant(age);
+reclaim;
+```
+
+The AST block contains:
+
+```text
+VariableDeclaration(Type seed, Identifier age, Value 10)
+PrintStatement(Value age)
+Return
+```
+
+### 8. MEMORIZED EXPLANATION
+
+`GALsemantic.py` defines the AST structure and builds the tree from validated tokens. It also uses a symbol table to record declarations, scopes, functions, and bundles while building that tree.
+
+---
+
+## D. Backend/GALsemantic.py: Semantic Analyzer
+
+### 1. FILE PURPOSE
+
+After the AST is built, the semantic analyzer walks the tree and validates meaning. It checks context and structure that grammar alone cannot fully guarantee.
+
+Examples of semantic concerns:
+
+- Is `prune` inside a loop or switch?
+- Is `skip` inside a loop?
+- Is a declaration structurally complete?
+- Does a function have valid return structure?
+- Are blocks and expressions well formed?
+
+### 2. CLASSES AND FUNCTIONS
+
+`ASTValidator`
+
+- Input: AST and serialized symbol table.
+- Output: dictionary containing success, errors, warnings, symbol table, and AST.
+- Stage: semantic analysis.
+
+`validate_ast(ast, symbol_table_data)`
+
+- Public API used by `server.py`.
+- Creates a validator and returns validation result.
+
+### 3. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+Code:
+
+```python
+class ASTValidator:
+    def __init__(self):
+        self.errors = []
+        self.warnings = []
+        self._in_loop = 0
+        self._in_switch = 0
+        self._in_function = False
+        self._current_func_type = None
+```
+
+Explanation:
+
+- `errors` stores semantic errors.
+- `warnings` stores non-fatal notices.
+- `_in_loop` tracks loop nesting.
+- `_in_switch` tracks harvest/switch nesting.
+- `_in_function` tracks function context.
+- `_current_func_type` tracks expected return type while walking a function.
+
+Code:
+
+```python
+def validate(self, ast, symbol_table_data):
+    self._walk(ast)
+    return {
+        "success": len(self.errors) == 0,
+        "errors": self.errors,
+        "warnings": self.warnings,
+        "symbol_table": symbol_table_data,
+        "ast": ast,
+    }
+```
+
+Explanation:
+
+- Starts validation by walking the AST root.
+- Success is true only when no errors were collected.
+- Returns the AST again so later stages can use the validated tree.
+
+Code:
+
+```python
+def _walk(self, node):
+    if node is None:
+        return
+    handler = getattr(self, f'_check_{node.node_type}', None)
+    if handler:
+        handler(node)
+    else:
+        for child in getattr(node, 'children', []):
+            self._walk(child)
+```
+
+Explanation:
+
+- This is recursive tree walking.
+- It looks for a method named after the node type, such as `_check_FunctionDeclaration`.
+- If a specific handler exists, it uses it.
+- Otherwise, it walks all children by default.
+
+Code:
+
+```python
+def _check_FunctionDeclaration(self, node):
+    if not node.value:
+        self.errors.append("Function declaration missing name")
+    prev_in_func = self._in_function
+    prev_func_type = self._current_func_type
+    self._in_function = True
+    if node.children:
+        self._current_func_type = node.children[0].value
+```
+
+Explanation:
+
+- Verifies the function has a name.
+- Saves previous context before entering this function.
+- Sets current function information while walking the body.
+
+Code:
+
+```python
+for child in node.children:
+    self._walk(child)
+self._in_function = prev_in_func
+self._current_func_type = prev_func_type
+```
+
+Explanation:
+
+- Walks return type, parameters, and body.
+- Restores previous context afterward.
+- This prevents one function's context from leaking into another.
+
+Code:
+
+```python
+def _check_ForLoop(self, node):
+    self._in_loop += 1
+    for child in node.children:
+        self._walk(child)
+    self._in_loop -= 1
+```
+
+Explanation:
+
+- Marks that validation is inside a loop.
+- Validates all loop children.
+- Decrements loop depth afterward.
+
+Code:
+
+```python
+def _check_Switch(self, node):
+    self._in_switch += 1
+    for child in node.children:
+        self._walk(child)
+    self._in_switch -= 1
+```
+
+Explanation:
+
+- Marks that validation is inside a `harvest` switch.
+- Needed because `prune` is valid inside a switch.
+
+Code:
+
+```python
+def _check_Break(self, node):
+    if self._in_loop == 0 and self._in_switch == 0:
+        self.errors.append("'prune' used outside a loop or switch")
+```
+
+Explanation:
+
+- `prune` is only valid in loops or harvest/switch blocks.
+- If there is no loop or switch context, it is a semantic error.
+
+Code:
+
+```python
+def _check_Continue(self, node):
+    if self._in_loop == 0:
+        self.errors.append("'skip' used outside a loop")
+```
+
+Explanation:
+
+- `skip` only makes sense inside loops.
+- Using it elsewhere is syntactically possible but semantically wrong.
+
+Code:
+
+```python
+def validate_ast(ast, symbol_table_data):
+    validator = ASTValidator()
+    return validator.validate(ast, symbol_table_data)
+```
+
+Explanation:
+
+- This is the public function called by `server.py`.
+- It creates a fresh validator for every compilation.
+- It returns a dictionary that the server can send as JSON.
+
+### 4. DEFENSE QUESTIONS
+
+Q: Why validate semantics after AST construction?
+
+A: The AST gives structured meaning. It is easier to validate loops, functions, returns, and nested statements after syntax is organized as a tree.
+
+Q: Why use counters like `_in_loop` instead of booleans?
+
+A: Loops can be nested. A counter correctly handles multiple levels of nesting.
+
+Q: Why collect errors instead of immediately throwing?
+
+A: The validator can gather semantic issues in a structured result and return them to the frontend.
+
+### 5. MEMORIZED EXPLANATION
+
+`validate_ast()` is the semantic validation phase. It walks the AST and checks context-sensitive rules, such as whether `prune` and `skip` are used in valid locations and whether AST structures are complete.
+
+---
+
+## E. Backend/icg.py
+
+### 1. FILE PURPOSE
+
+`icg.py` generates intermediate code, specifically three-address code or TAC. This is a lower-level representation of the program.
+
+Pipeline position:
+
+```text
+validated token stream -> generate_icg() -> TAC list + TAC text
+```
+
+Important implementation detail:
+
+- The ICG module reads tokens directly.
+- The server validates lexer, parser, AST, and semantic stages before calling ICG.
+
+### 2. IMPORTS / DEPENDENCIES
+
+Code:
+
+```python
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+```
+
+Explanation:
+
+- Future annotations support cleaner type hints.
+- `dataclass` is used for token views and TAC instructions.
+- `typing` documents the structures passed around.
+- `field` appears possibly unused in this file; do not remove during defense unless verified.
+
+### 3. GLOBAL CONSTANTS / VARIABLES
+
+Code:
+
+```python
+GAL_TYPE_MAP = {
+    "seed": "int",
+    "tree": "float",
+    "leaf": "char",
+    "branch": "bool",
+    "vine": "string",
+    "empty": "void",
+}
+DATA_TYPE_TOKENS = set(GAL_TYPE_MAP.keys())
+ASSIGN_OPS = {"=", "+=", "-=", "*=", "/=", "%="}
+```
+
+Explanation:
+
+- `GAL_TYPE_MAP` converts GAL type names into conventional intermediate-code type names.
+- `DATA_TYPE_TOKENS` lets the generator quickly ask whether a token is a type.
+- `ASSIGN_OPS` lists assignment operators that ICG can translate.
+
+### 4. CLASSES AND FUNCTIONS
+
+`_Tok`
+
+- Normalized token view for ICG.
+
+`_as_tok(raw)`
+
+- Converts lexer tokens or dictionaries into `_Tok`.
+
+`TACInstruction`
+
+- Represents one intermediate instruction with `op`, `arg1`, `arg2`, and `result`.
+
+`ICGenerator`
+
+- Main class that reads tokens and emits TAC.
+
+`generate_icg(tokens)`
+
+- Public API used by `server.py`.
+
+### 5. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+Code:
+
+```python
+@dataclass(frozen=True)
+class _Tok:
+    type: str
+    value: str
+    line: int
+    col: int = 0
+```
+
+Explanation:
+
+- Gives ICG a stable token format.
+- Prevents ICG from depending on the exact lexer `Token` class.
+
+Code:
+
+```python
+@dataclass
+class TACInstruction:
+    op: str
+    arg1: Optional[str] = None
+    arg2: Optional[str] = None
+    result: Optional[str] = None
+```
+
+Explanation:
+
+- Stores one TAC instruction.
+- `op` is the operation.
+- `arg1` and `arg2` are operands.
+- `result` is destination or label depending on the instruction.
+
+Code:
+
+```python
+def __str__(self):
+    if self.op == "LABEL":
+        return f"{self.result}:"
+    if self.op == "GOTO":
+        return f"goto {self.result}"
+    if self.op == "PRINT":
+        return f"print {self.arg1}"
+```
+
+Explanation:
+
+- Converts TAC objects into human-readable TAC text.
+- This is what `/api/icg` can display in the frontend.
+
+Code:
+
+```python
+class ICGenerator:
+    def __init__(self, tokens):
+        self.tokens = self._prepare(tokens)
+        self.pos = 0
+        self.code = []
+        self.errors = []
+        self._temp_counter = 0
+        self._label_counter = 0
+```
+
+Explanation:
+
+- Prepares tokens by normalizing and skipping newlines.
+- `pos` tracks current token index.
+- `code` stores generated instructions.
+- `errors` stores ICG errors.
+- Counters generate temporary names and labels.
+
+Code:
+
+```python
+def _prepare(self, raw_tokens):
+    toks = []
+    for t in raw_tokens:
+        tv = _as_tok(t)
+        if tv.type == "\n":
+            continue
+        toks.append(tv)
+```
+
+Explanation:
+
+- Filters newline tokens, similar to parser and AST builder.
+- ICG does not need newline tokens to generate code.
+
+Code:
+
+```python
+if not toks or toks[-1].type != "EOF":
+    toks.append(_Tok("EOF", "EOF", last_line))
+```
+
+Explanation:
+
+- Ensures the token stream has EOF.
+- EOF prevents reading beyond the input.
+
+Code:
+
+```python
+def _emit(self, op, arg1=None, arg2=None, result=None):
+    self.code.append(TACInstruction(op, arg1, arg2, result))
+```
+
+Explanation:
+
+- Central helper for creating TAC.
+- Every declaration, expression, loop, and statement uses this to append instructions.
+
+Code:
+
+```python
+def _new_temp(self):
+    name = f"t{self._temp_counter}"
+    self._temp_counter += 1
+    return name
+```
+
+Explanation:
+
+- Generates temporary variables like `t0`, `t1`.
+- Used for intermediate expression results.
+
+Code:
+
+```python
+def _new_label(self):
+    name = f"L{self._label_counter}"
+    self._label_counter += 1
+    return name
+```
+
+Explanation:
+
+- Generates labels like `L0`, `L1`.
+- Used for jumps in loops and conditionals.
+
+Code:
+
+```python
+def generate(self):
+    try:
+        self._program()
+    except Exception as exc:
+        self.errors.append(f"ICG internal error: {exc}")
+    return self.code, self.errors
+```
+
+Explanation:
+
+- Starts generating TAC from the whole program.
+- Catches unexpected generator failures.
+- Returns generated code and errors.
+
+Code:
+
+```python
+def _program(self):
+    self._global_declaration()
+    self._function_definition()
+    self._expect("root")
+    self._expect("(")
+    self._expect(")")
+    self._expect("{")
+    self._emit("FUNC", "root")
+```
+
+Explanation:
+
+- Follows GAL program structure.
+- Handles globals and pollinate functions before `root`.
+- Emits a TAC function start for root.
+
+Code:
+
+```python
+self._declaration()
+self._statement()
+```
+
+Explanation:
+
+- Emits declarations first.
+- Emits executable statements next.
+- Mirrors the GAL rule that local declarations come before statements.
+
+Code:
+
+```python
+if self._peek().type == "reclaim":
+    self._advance()
+    if self._peek().type != ";":
+        val = self._expression()
+        self._emit("RETURN", val)
+    else:
+        self._emit("RETURN")
+```
+
+Explanation:
+
+- Converts `reclaim;` or `reclaim expression;` into TAC return.
+- For `root()`, return usually has no value.
+
+Code:
+
+```python
+def _simple_stmt(self):
+    if tok.type == "id":
+        self._id_stmt()
+    elif tok.type in ("water", "plant"):
+        self._io_stmt()
+    elif tok.type == "spring":
+        self._conditional_stmt()
+    elif tok.type in ("grow", "cultivate", "tend"):
+        self._loop_stmt()
+```
+
+Explanation:
+
+- Dispatches based on statement starter token.
+- Each GAL construct has its own TAC generation path.
+
+Code:
+
+```python
+if op_tok.type == "=":
+    self._emit("=", rhs, None, lhs)
+else:
+    base_op = op_tok.type[0]
+    tmp = self._new_temp()
+    self._emit(base_op, lhs, rhs, tmp)
+    self._emit("=", tmp, None, lhs)
+```
+
+Explanation:
+
+- Assignment becomes one TAC instruction.
+- Compound assignment becomes operation plus assignment.
+- Example: `x += y` becomes `t0 = x + y`, then `x = t0`.
+
+Code:
+
+```python
+def _while_loop(self):
+    start_label = self._new_label()
+    end_label = self._new_label()
+    self._emit("LABEL", None, None, start_label)
+    cond = self._expression()
+    self._emit("IFFALSE", cond, None, end_label)
+    self._statement()
+    self._emit("GOTO", None, None, start_label)
+    self._emit("LABEL", None, None, end_label)
+```
+
+Explanation:
+
+- `grow` loop is translated into labels and jumps.
+- If condition is false, jump to end.
+- After body, jump back to start.
+
+Code:
+
+```python
+def _expression(self):
+    return self._logic_or()
+```
+
+Explanation:
+
+- Expression generation starts at the lowest precedence level.
+- Deeper functions handle logical, relational, arithmetic, and factor parsing.
+
+Code:
+
+```python
+def generate_icg(tokens):
+    gen = ICGenerator(tokens)
+    code, errors = gen.generate()
+    tac_dicts = [instr.to_dict() for instr in code]
+    tac_text = "\n".join(str(instr) for instr in code)
+    return {...}
+```
+
+Explanation:
+
+- Public API called by `server.py`.
+- Creates a generator, runs it, converts instructions to JSON-friendly dictionaries and readable text.
+
+### 6. DEFENSE QUESTIONS
+
+Q: Why have ICG if the interpreter can run the AST?
+
+A: ICG shows an intermediate compiler representation. It can be used for future optimization or target-code generation, while the interpreter is for immediate execution.
+
+Q: Why use temporary variables?
+
+A: TAC breaks complex expressions into simple operations with at most two operands.
+
+Q: Why use labels?
+
+A: Loops and conditionals need jump targets. Labels represent those targets.
+
+### 7. WALKTHROUGH EXAMPLE
+
+For the sample program, ICG output is:
+
+```text
+func root:
+declare age : int
+age = 10
+print age
+return
+endfunc
+```
+
+### 8. MEMORIZED EXPLANATION
+
+`icg.py` converts validated GAL tokens into three-address code. It emits declarations, assignments, labels, jumps, input/output, function calls, and returns. It is separate from execution because it represents the compiler's intermediate form.
+
+---
+
+## F. Backend/GALinterpreter.py
+
+### 1. FILE PURPOSE
+
+`GALinterpreter.py` is the execution engine. It walks the validated AST and performs the actual program behavior.
+
+Pipeline position:
+
+```text
+validated AST -> Interpreter.interpret(ast) -> runtime output / input / errors
+```
+
+### 2. IMPORTS / DEPENDENCIES
+
+Code:
+
+```python
+from GALsemantic import (ProgramNode, VariableDeclarationNode, AssignmentNode, ...)
+import threading
+import sys
+sys.setrecursionlimit(10000)
+```
+
+Explanation:
+
+- Imports AST node classes so the interpreter can identify node types.
+- `threading` is fallback support for input waiting.
+- `sys.setrecursionlimit(10000)` allows deeper recursive interpretation/function calls.
+
+Code:
+
+```python
+try:
+    import eventlet.event as _ev
+    _USE_EVENTLET = True
+except ImportError:
+    _USE_EVENTLET = False
+```
+
+Explanation:
+
+- Uses eventlet events when available.
+- Eventlet lets `water()` wait without blocking the whole Socket.IO server.
+- Falls back to threading events if eventlet is unavailable.
+
+### 3. GLOBAL CONSTANTS / VARIABLES
+
+There are no major global compiler constants here. The runtime state is inside each `Interpreter` object:
+
+- variables
+- functions
+- scopes
+- bundle types
+- input events
+- output socket
+- loop flags
+
+### 4. CLASSES AND FUNCTIONS
+
+`ReturnValue`
+
+- Internal exception used to implement `reclaim`.
+- Carries return value out of a function body.
+
+`_CancelledError`
+
+- Raised when a previous interpreter is cancelled by a new run.
+
+`InterpreterError`
+
+- Runtime error with line-numbered message.
+
+`Interpreter`
+
+- Main runtime class.
+- Executes AST nodes.
+- Stores variables, functions, scopes, bundle types, loop flags, and input state.
+
+### 5. LINE-BY-LINE / BLOCK-BY-BLOCK EXPLANATION
+
+Code:
+
+```python
+class Interpreter:
+    def __init__(self, socketio=None):
+        self.output = []
+        self.loop_stack = []
+        self.break_flag = False
+        self.continue_flag = False
+        self.input_required = False
+        self.socketio = socketio
+```
+
+Explanation:
+
+- Creates one runtime environment.
+- `output` stores printed output in compatibility paths.
+- `loop_stack`, `break_flag`, and `continue_flag` implement `prune` and `skip`.
+- `input_required` marks whether `water()` is waiting.
+- `socketio` receives output and input events.
+
+Code:
+
+```python
+self.input_events = {}
+self.input_values = {}
+self.variables = {}
+self.global_variables = {}
+self.functions = {}
+self.scopes = [{}]
+self.current_func_name = None
+self.function_variables = {}
+self.bundle_types = {}
+```
+
+Explanation:
+
+- `input_events` stores waiting input requests.
+- `input_values` stores input that arrived early.
+- `variables` and `global_variables` store runtime values.
+- `functions` stores function declarations.
+- `scopes` models local scope stack.
+- `bundle_types` stores struct-like type definitions.
+
+Code:
+
+```python
+def declare_variable(self, name, type_, value=None, is_list=False, is_fertile=False):
+    scope = self.scopes[-1]
+    if name not in self.scopes[-1]:
+        scope[name] = {
+            "type": type_,
+            "value": value,
+            "is_list": is_list,
+            "is_fertile": is_fertile
+        }
+```
+
+Explanation:
+
+- Stores a variable in the current runtime scope.
+- Keeps type, value, array/list flag, and constant flag.
+
+Code:
+
+```python
+def lookup_variable(self, name):
+    for scope in reversed(self.scopes):
+        if name in scope:
+            return scope[name]
+    if name in self.variables:
+        return self.variables[name]
+    return f"Semantic Error: Variable '{name}' used before declaration."
+```
+
+Explanation:
+
+- Searches from innermost scope outward.
+- Falls back to global variables.
+- Returns an error string if variable does not exist.
+
+Code:
+
+```python
+def interpret(self, node):
+    if isinstance(node, ProgramNode):
+        return self.eval_program(node)
+    elif isinstance(node, VariableDeclarationNode):
+        return self.eval_variable_declaration(node)
+    elif isinstance(node, AssignmentNode):
+        return self.eval_assignment(node)
+```
+
+Explanation:
+
+- This is the main AST dispatcher.
+- Each node type is routed to the correct evaluator.
+- This is how the interpreter walks and executes the AST.
+
+Code:
+
+```python
+elif node.node_type == "Identifier":
+    var_info = self.lookup_variable(node.value)
+    if isinstance(var_info, str):
+        raise InterpreterError(var_info, node.line)
+    return var_info["value"]
+```
+
+Explanation:
+
+- Identifier evaluation means reading the current runtime value.
+- If the variable is missing, execution stops with an error.
+
+Code:
+
+```python
+def eval_program(self, node):
+    for child in node.children:
+        self.interpret(child)
+    main_call = FunctionCallNode("root", [], node.line)
+    return self.interpret(main_call)
+```
+
+Explanation:
+
+- First registers global declarations, bundles, and functions.
+- Then creates a call to `root()`.
+- This implements GAL's entry point rule.
+
+Code:
+
+```python
+def eval_variable_declaration(self, node):
+    var_type = node.children[0].value
+    var_name = node.children[1].value
+    value_node = node.children[2] if len(node.children) > 2 else None
+```
+
+Explanation:
+
+- Reads type, name, and optional initializer from AST children.
+- The interpreter relies on the AST layout created by `VariableDeclarationNode`.
+
+Code:
+
+```python
+default_values = {
+    "seed": 0,
+    "tree": 0.0,
+    "leaf": '',
+    "vine": "",
+    "branch": False,
+}
+```
+
+Explanation:
+
+- Provides default values for declarations without initializers.
+- Example: `seed x;` becomes `x = 0` at runtime.
+
+Code:
+
+```python
+if value_node:
+    value = self.interpret(value_node)
+    if var_type == "seed" and isinstance(value, float):
+        value = int(value)
+else:
+    value = default_values.get(var_type, None)
+```
+
+Explanation:
+
+- If there is an initializer, evaluate it.
+- If the variable is `seed` and value is float, convert to int.
+- If there is no initializer, use default value.
+
+Code:
+
+```python
+self.declare_variable(var_name, var_type, value, is_list=is_list)
+```
+
+Explanation:
+
+- Stores the variable in the current runtime scope.
+- After this line, later statements can access the variable.
+
+Code:
+
+```python
+def eval_assignment(self, node):
+    target_node = node.children[0]
+    value_node = node.children[1]
+    value = self.interpret(value_node)
+```
+
+Explanation:
+
+- Evaluates the right-hand side first.
+- Then assigns it to the target.
+- The target can be a normal variable, list element, or bundle member.
+
+Code:
+
+```python
+if target_node.node_type == "ListAccess":
+    indices = []
+    current = target_node
+    while current.node_type == "ListAccess":
+        idx = self.interpret(current.children[1].children[0])
+        if not isinstance(idx, int):
+            raise InterpreterError(...)
+        indices.append(idx)
+```
+
+Explanation:
+
+- Handles assignment to array/list elements.
+- Evaluates each index expression.
+- Requires indexes to be integers.
+
+Code:
+
+```python
+if final_idx < 0 or final_idx >= len(target):
+    raise InterpreterError("Index out of bounds", node.line)
+target[final_idx] = value
+```
+
+Explanation:
+
+- Performs runtime bounds check.
+- Writes the new value.
+- Current implementation uses 0-based indexing. This differs from the GAL PDF's 1-based rule.
+
+Code:
+
+```python
+def eval_binary_op(self, node):
+    left = self.interpret(node.children[0])
+    right = self.interpret(node.children[1])
+    operator = node.value
+```
+
+Explanation:
+
+- Evaluates both operands recursively.
+- Reads the operator from the AST node.
+
+Code:
+
+```python
+if operator == '`':
+    result = str(left) + str(right)
+    return result
+```
+
+Explanation:
+
+- Implements GAL string concatenation using backtick.
+- Converts both operands to string.
+
+Code:
+
+```python
+elif operator == '/':
+    if right == 0:
+        raise InterpreterError("Runtime Error: Division by zero is undefined", node.line)
+    return left / right
+```
+
+Explanation:
+
+- Executes division.
+- Checks division by zero at runtime because actual values are known only during execution.
+
+Code:
+
+```python
+def eval_block(self, block_node):
+    for statement in block_node.children:
+        self.interpret(statement)
+        if self.break_triggered():
+            return
+        if self.continue_flag:
+            return
+```
+
+Explanation:
+
+- Executes statements in source order.
+- Stops block execution if `prune` or `skip` changes control flow.
+
+Code:
+
+```python
+def plant(self, value):
+    self.socketio.emit('output', {'output': str(value)})
+```
+
+Explanation:
+
+- Implements output.
+- The interpreter emits to whatever socket-like object it was given.
+- In Socket.IO mode, output goes live to the frontend.
+- In REST mode, `OutputCollector` catches it.
+
+Code:
+
+```python
+def eval_return(self, node):
+    value = self.interpret(node.children[0]) if node.children else None
+    raise ReturnValue(value)
+```
+
+Explanation:
+
+- Implements `reclaim`.
+- Raises `ReturnValue` to immediately exit the current function.
+- Carries return value if present.
+
+Code:
+
+```python
+def eval_function_call(self, node):
+    function_name = node.value
+    args = [self.interpret(arg.children[0]) for arg in node.children]
+    func_info = self.lookup_function(function_name)
+```
+
+Explanation:
+
+- Evaluates function call arguments.
+- Looks up the function declaration.
+
+Code:
+
+```python
+self.enter_scope()
+try:
+    for i, param in enumerate(expected_params):
+        self.declare_variable(param_name, param_type, arg_value, is_list=is_list)
+    self.eval_block(function_node.children[2])
+except ReturnValue as ret:
+    return ret.value
+finally:
+    self.exit_scope()
+```
+
+Explanation:
+
+- Function call creates a new local scope.
+- Parameters become local variables.
+- Function body executes.
+- `ReturnValue` captures `reclaim`.
+- Scope is cleaned up after the call.
+
+Code:
+
+```python
+def provide_input(self, var_name, input_value):
+    evt = self.input_events.get(var_name)
+    if evt is None:
+        self.input_values[var_name] = input_value
+        return
+```
+
+Explanation:
+
+- Receives input from `server.py`.
+- If interpreter is not waiting yet, stores the value.
+- Prevents lost input.
+
+Code:
+
+```python
+def wait_for_input(self, var_name):
+    if var_name in self.input_values:
+        return self.input_values.pop(var_name)
+```
+
+Explanation:
+
+- If input already arrived, returns it immediately.
+- Otherwise waits for eventlet/threading event.
+
+Code:
+
+```python
+def eval_input(self, node):
+    parent_node = node.parent
+    if isinstance(parent_node, VariableDeclarationNode):
+        var_name = parent_node.children[1].value
+        var_type = parent_node.children[0].value
+```
+
+Explanation:
+
+- Figures out where `water()` is being used.
+- If it is inside a declaration, the target variable and type come from the parent declaration.
+
+Code:
+
+```python
+self.emit_input_request(var_name, prompt)
+input_value = self.wait_for_input(var_name)
+```
+
+Explanation:
+
+- Tells the frontend input is needed.
+- Waits until the user responds.
+
+Code:
+
+```python
+if var_type == "seed":
+    if input_value.startswith('-'):
+        raise InterpreterError("GAL uses '~' for negative numbers", node.line)
+    if input_value.startswith('~'):
+        input_value = '-' + input_value[1:]
+    input_value = int(float(input_value))
+```
+
+Explanation:
+
+- Converts input string to integer.
+- Enforces GAL negative syntax using `~` instead of `-`.
+- Raises runtime error if conversion fails.
+
+### 6. DEFENSE QUESTIONS
+
+Q: Why execute the AST instead of tokens?
+
+A: Tokens are flat. The AST already shows program structure, so execution can naturally follow blocks, expressions, functions, and control flow.
+
+Q: Why does `reclaim` use an exception?
+
+A: A return must immediately exit the current function, even from nested blocks. `ReturnValue` carries the return value out cleanly.
+
+Q: How does `plant()` output reach the frontend?
+
+A: The interpreter calls `self.socketio.emit('output', ...)`. In live mode this is Socket.IO; in REST mode it is an `OutputCollector`.
+
+Q: How does `water()` work?
+
+A: The interpreter emits an input request, waits on an event, and `server.py` later calls `provide_input()` when the frontend sends user input.
+
+Q: What array indexing issue should you mention?
+
+A: The GAL document says arrays are 1-based, but the interpreter currently checks `index < 0` and accesses `list_value[index]`, so runtime behavior is 0-based.
+
+### 7. WALKTHROUGH EXAMPLE
+
+For:
+
+```gal
+root() {
+    seed age = 10;
+    plant(age);
+    reclaim;
+}
+```
+
+Execution steps:
+
+1. `eval_program()` registers declarations and functions.
+2. It creates a `FunctionCallNode("root", [])`.
+3. `eval_function_call()` enters a scope for root.
+4. `eval_variable_declaration()` stores `age` as a `seed` with value `10`.
+5. `eval_print()` reads `age` and emits `10`.
+6. `eval_return()` raises `ReturnValue(None)`.
+7. The function call catches return and exits.
+8. `server.py` returns output to frontend.
+
+### 8. MEMORIZED EXPLANATION
+
+`GALinterpreter.py` is the runtime engine. It walks the AST, stores variables in scopes, registers functions, evaluates expressions, executes loops and conditionals, handles `plant()` output, handles `water()` input, and uses `ReturnValue` to implement `reclaim`.
+
+---
+
+# Final Full-Pipeline Defense Explanation
+
+`server.py` receives source code from the frontend. It sends the raw text to `lexer.py`, which converts characters into tokens and reports lexical errors. Those tokens go to `Gal_Parser.py`, which uses the grammar and PREDICT sets from `cfg.py` to validate syntax with LL(1) parsing. If syntax succeeds, `parse_and_build()` calls the AST builder in `GALsemantic.py`. The AST builder creates structured nodes and a symbol table. Then `validate_ast()` walks the AST for semantic checks. If the user requests ICG, `icg.py` generates three-address code. If the user runs the program, `GALinterpreter.py` walks the AST, calls `root()`, executes declarations, statements, expressions, functions, loops, `plant()`, `water()`, and `reclaim`, then sends the output back through the server.
+
+# Common Panel Questions For The Whole System
+
+Q: Why did you separate the compiler into files?
+
+A: Each file represents a compiler responsibility. Lexer handles characters, parser handles grammar, AST/semantic handles meaning, ICG handles intermediate representation, and interpreter handles execution.
+
+Q: What happens if lexical analysis fails?
+
+A: The server stops immediately and returns lexical errors. Parser does not run because invalid tokens would make syntax analysis unreliable.
+
+Q: What happens if syntax analysis fails?
+
+A: AST construction does not happen. The server returns syntax errors from the parser.
+
+Q: What happens if semantic analysis fails?
+
+A: ICG and interpreter are skipped. The server returns semantic errors.
+
+Q: What happens if runtime execution fails?
+
+A: The interpreter raises `InterpreterError`; `server.py` catches it and sends a runtime error to the frontend.
+
+Q: Why is `root()` called by the interpreter instead of just executing top to bottom?
+
+A: Top-level declarations and function definitions must be registered first. Actual program execution begins at `root()`, as required by the GAL specification.
+
+Q: What is one known implementation/spec mismatch?
+
+A: The GAL PDF specifies 1-based arrays, but the current interpreter uses 0-based indexing for lists/vines. That should be acknowledged honestly during defense.

Docus & mps/cfg_to_pred_extracted.txt

@@ -0,0 +1,943 @@
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+78 
+X. CONTEXT-FREE GRAMMAR 
+ 
+# Production  Production Set 
+1 <program> -> <global_declaration> <function_definition> root ( ) { <statement> } 
+2 <global_declaration> -> bundle id <bundle_or_var> <global_declaration> 
+3 <global_declaration> -> <data_type> id <array_dec> <var_value> ; <global_declaration> 
+4 <global_declaration> -> fertile <data_type> id = <init_val> <const_next> ; <global_declaration> 
+5 <global_declaration> -> λ 
+6 <bundle_or_var> -> { <bundle_members> } ; 
+7 <bundle_or_var> -> <bundle_mem_dec> ; 
+8 <declaration> -> <var_dec> ; <declaration> 
+9 <declaration> -> <const_dec> ; <declaration> 
+10 <declaration> -> λ 
+11 <data_type> -> seed 
+12 <data_type> -> tree 
+13 <data_type> -> leaf 
+14 <data_type> -> branch 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+79 
+15 <data_type> -> vine 
+16 <const_dec> -> fertile <data_type> id = <init_val> <const_next> 
+17 <const_next> -> , id = <init_val> <const_next> 
+18 <const_next> -> λ 
+19 <var_dec> -> <data_type> id <array_dec> <var_value> 
+20 <var_dec> -> bundle id <bundle_mem_dec> 
+21 <bundle_mem_dec> -> id <array_dec> <var_value_next> 
+22 <bundle_mem_dec> -> , id <var_value_next> 
+23 <bundle_mem_dec> -> λ 
+24 <var_value> -> = <init_val> <var_value_next> 
+25 <var_value> -> <var_value_next> 
+26 <var_value_next> -> , id <array_dec> <var_value> 
+27 <var_value_next> -> λ 
+28 <init_val> -> <array_init_opt> 
+29 <init_val> -> water ( <water_arg> ) 
+30 <init_val> -> <expression> 
+31 <array_dec> -> [ <array_dim_opt> ] <array_dec> 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+80 
+32 <array_dec> -> λ 
+33 <array_dim_opt> -> intlit 
+34 <array_dim_opt> -> dblit 
+35 <array_dim_opt> -> λ 
+36 <array_init_opt> -> { <init_vals> } 
+37 <array_init_opt> -> λ 
+38 <init_vals> -> <init_val_item> <init_vals_next> 
+39 <init_vals> -> λ 
+40 <init_vals_next> -> , <init_val_item> <init_vals_next> 
+41 <init_vals_next> -> λ 
+42 <init_val_item> -> { <init_vals> } 
+43 <init_val_item> -> <expression> 
+44 <bundle_declaration> -> bundle id { <bundle_members> } 
+45 <bundle_members> -> <data_type> id ; <bundle_members> 
+46 <bundle_members> -> id id ; <bundle_members> 
+47 <bundle_members> -> λ 
+48 <function_definition> -> pollinate <return_type> id ( <parameters> ) { <statement> } <function_definition> 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+81 
+49 <function_definition> -> λ 
+50 <return_type> -> <data_type> 
+51 <return_type> -> empty 
+52 <return_type> -> id 
+53 <parameters> -> λ 
+54 <parameters> -> <param> <param_next> 
+55 <param> -> <data_type> id <param_array> 
+56 <param> -> id id 
+57 <param_array> -> λ 
+58 <param_array> -> [ ] 
+59 <param_next> -> λ 
+60 <param_next> -> , <param> <param_next> 
+61 <reclaim_opt> -> reclaim <reclaim_value> 
+62 <reclaim_opt> -> λ 
+63 <reclaim_value> -> <expression> ; 
+64 <reclaim_value> -> ; 
+65 <statement> -> <simple_stmt> <statement> 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+82 
+66 <statement> -> λ 
+67 <simple_stmt> -> id <id_stmt> 
+68 <simple_stmt> -> <inc_dec_op> id ; 
+69 <simple_stmt> -> <io_stmt> 
+70 <simple_stmt> -> <conditional_stmt> 
+71 <simple_stmt> -> <loop_stmt> 
+72 <simple_stmt> -> <switch_stmt> 
+73 <simple_stmt> -> <control_stmt> 
+74 <simple_stmt> -> reclaim <reclaim_value> 
+75 <simple_stmt> -> <var_dec> ; 
+76 <simple_stmt> -> <const_dec> ; 
+77 <id_stmt> -> <id_next> <assign_op> <assign_rhs> ; 
+78 <id_stmt> -> <inc_dec_op> ; 
+79 <id_stmt> -> ( <arguments> ) ; 
+80 <assignment_stmt> -> <value> <assign_op> <assign_rhs> ; 
+81 <assign_rhs> -> water ( <water_arg> ) 
+82 <assign_rhs> -> <expression> 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+83 
+83 <assign_op> -> = 
+84 <assign_op> -> += 
+85 <assign_op> -> -= 
+86 <assign_op> -> *= 
+87 <assign_op> -> /= 
+88 <assign_op> -> %= 
+89 <value> -> id <id_next> 
+90 <id_next> -> <array_access> <post_array_access> 
+91 <id_next> -> <struct_access> 
+92 <id_next> -> λ 
+93 <array_access> -> [ <expression> ] <array_access_more> 
+94 <array_access_more> -> [ <expression> ] <array_access_more> 
+95 <array_access_more> -> λ 
+96 <struct_access> -> . id <struct_access_more> 
+97 <struct_access_more> -> . id <struct_access_more> 
+98 <struct_access_more> -> λ 
+99 <post_array_access> -> . id <post_array_access> 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+84 
+100 <post_array_access> -> λ 
+101 <io_stmt> -> plant ( <arguments> ) ; 
+102 <io_stmt> -> water ( <water_arg> ) ; 
+103 <water_arg> -> <data_type> 
+104 <water_arg> -> id <water_id_tail> 
+105 <water_arg> -> λ 
+106 <water_id_tail> -> [ <expression> ] <water_id_tail> 
+107 <water_id_tail> -> λ 
+108 <arguments> -> <expression> <arg_next> 
+109 <arguments> -> λ 
+110 <arg_next> -> , <expression> <arg_next> 
+111 <arg_next> -> λ 
+112 <conditional_stmt> -> spring ( <expression> ) { <statement> } <elseif_chain> <else_opt> 
+113 <elseif_chain> -> bud ( <expression> ) { <statement> } <elseif_chain> 
+114 <elseif_chain> -> λ 
+115 <else_opt> -> wither { <statement> } 
+116 <else_opt> -> λ 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+85 
+117 <loop_stmt> -> grow ( <expression> ) { <statement> } 
+118 <loop_stmt> -> cultivate ( <for_init> ; <expression> ; <for_update> ) { <statement> } 
+119 <loop_stmt> -> tend { <statement> } grow ( <expression> ) ; 
+120 <for_init> -> <data_type> id <array_dec> <var_value> 
+121 <for_init> -> id <id_next> <assign_op> <expression> 
+122 <for_init> -> λ 
+123 <for_update> ->  id <for_update_type> 
+124 <for_update> -> λ 
+125 <for_update_type> -> <inc_dec_op> 
+126 <for_update_type> -> <id_next> <assign_op> <expression> 
+127 <unary_stmt> -> id <inc_dec_op> ; 
+128 <inc_dec_op> -> ++ 
+129 <inc_dec_op> -> -- 
+130 <switch_stmt> -> harvest ( <expression> ) { <case_list> <default_opt> } 
+131 <case_list> -> variety <case_literal> : <case_statements> <case_list> 
+132 <case_list> -> λ 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+86 
+133 <case_literal> -> intlit 
+134 <case_literal> -> dblit 
+135 <case_literal> -> chrlit 
+136 <case_literal> -> stringlit 
+137 <case_literal> -> sunshine 
+138 <case_literal> -> frost 
+139 <case_statements> -> <case_statement> <case_statements> 
+140 <case_statements> -> λ 
+141 <case_statement> -> id <id_stmt> 
+142 <case_statement> -> <inc_dec_op> id ; 
+143 <case_statement> -> <var_dec> ; 
+144 <case_statement> -> <io_stmt> 
+145 <case_statement> -> <conditional_stmt> 
+146 <case_statement> -> <loop_stmt> 
+147 <case_statement> -> <switch_stmt> 
+148 <case_statement> -> { <case_statements> } 
+149 <case_statement> -> prune ; 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+87 
+150 <case_statement> -> skip ; 
+151 <case_statement> -> reclaim <reclaim_value> 
+152 <default_opt> -> soil : <case_statements> 
+153 <default_opt> -> λ 
+154 <control_stmt> -> prune ; 
+155 <control_stmt> -> skip ; 
+156 <function_call> -> id ( <arguments> ) ; 
+157 <expression> -> <logic_or> 
+158 <logic_or> -> <logic_and> <logic_or_next> 
+159 <logic_or_next> -> || <logic_and> <logic_or_next> 
+160 <logic_or_next> -> λ 
+161 <logic_and> -> <relational> <logic_and_next> 
+162 <logic_and_next> -> && <relational> <logic_and_next> 
+163 <logic_and_next> -> λ 
+164 <relational> -> <arithmetic> <relational_next> 
+165 <relational_next> -> <relational_op> <arithmetic> 
+166 <relational_next> -> λ 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+88 
+167 <relational_op> -> > 
+168 <relational_op> -> < 
+169 <relational_op> -> >= 
+170 <relational_op> -> <= 
+171 <relational_op> -> == 
+172 <relational_op> -> != 
+173 <arithmetic> -> <term> <arithmetic_next> 
+174 <arithmetic_next> -> + <term> <arithmetic_next> 
+175 <arithmetic_next> -> - <term> <arithmetic_next> 
+176 <arithmetic_next> -> ` <term> <arithmetic_next> 
+177 <arithmetic_next> -> λ 
+178 <term> -> <factor> <term_next> 
+179 <term_next> -> * <factor> <term_next> 
+180 <term_next> -> / <factor> <term_next> 
+181 <term_next> -> % <factor> <term_next> 
+182 <term_next> -> λ 
+183 <factor> -> ( <paren_expr> 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+89 
+184 <factor> -> <unary_op> <factor> 
+185 <factor> -> id <factor_id_next> 
+186 <factor> -> intlit 
+187 <factor> -> dblit 
+188 <factor> -> chrlit 
+189 <factor> -> stringlit 
+190 <factor> -> sunshine 
+191 <factor> -> frost 
+192 <paren_expr> -> <data_type> ) <factor> 
+193 <paren_expr> -> <expression> ) 
+194 <unary_op> -> ~ 
+195 <unary_op> -> ! 
+196 <factor_id_next> -> <array_access> <post_array_access> 
+197 <factor_id_next> -> <struct_access> 
+198 <factor_id_next> -> ( <arguments> ) 
+199 <factor_id_next> -> λ 
+ 
+ 
+ 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+90 
+XI. FIRST SET 
+ 
+# Nonterminal -> First Set 
+1 <global_declaration> -> { branch, bundle, fertile, leaf, seed, tree, vine, λ } 
+2 <bundle_or_var> -> { ,, ;, id, { } 
+3 <declaration> -> { branch, bundle, fertile, leaf, seed, tree, vine, λ } 
+4 <data_type> -> { branch, leaf, seed, tree, vine } 
+5 <const_dec> -> { fertile } 
+6 <const_next> -> { ,, λ } 
+7 <var_dec> -> { branch, bundle, leaf, seed, tree, vine } 
+8 <bundle_mem_dec> -> { ,, id, λ } 
+9 <var_value> -> { ,, =, λ } 
+10 <var_value_next> -> { ,, λ } 
+11 <init_val> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, water, {, 
+~, λ } 
+12 <array_dec> -> { [, λ } 
+13 <array_dim_opt> -> { dblit, intlit, λ } 
+14 <array_init_opt> -> { {, λ } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+91 
+15 <init_vals> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, {, ~, λ } 
+16 <init_vals_next> -> { ,, λ } 
+17 <init_val_item> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, {, ~ } 
+18 <bundle_declaration> -> { bundle } 
+19 <bundle_members> -> { branch, id, leaf, seed, tree, vine, λ } 
+20 <function_definition> -> { pollinate, λ } 
+21 <return_type> -> { branch, empty, id, leaf, seed, tree, vine } 
+22 <parameters> -> { branch, id, leaf, seed, tree, vine, λ } 
+23 <param> -> { branch, id, leaf, seed, tree, vine } 
+24 <param_array> -> { [, λ } 
+25 <param_next> -> { ,, λ } 
+26 <reclaim_opt> -> { reclaim, λ } 
+27 <reclaim_value> -> { !, (, ;, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ } 
+28 <statement> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, 
+vine, water, λ } 
+29 <simple_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, 
+vine, water } 
+30 <id_stmt> -> { %=, (, *=, ++, +=, --, -=, ., /=, =, [ } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+92 
+31 <assign_rhs> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, water, ~ 
+} 
+32 <assign_op> -> { %=, *=, +=, -=, /=, = } 
+33 <value> -> { id } 
+34 <id_next> -> { ., [, λ } 
+35 <array_access> -> { [ } 
+36 <array_access_more> -> { [, λ } 
+37 <struct_access> -> { . } 
+38 <struct_access_more> -> { ., λ } 
+39 <post_array_access> -> { ., λ } 
+40 <io_stmt> -> { plant, water } 
+41 <water_arg> -> { branch, id, leaf, seed, tree, vine, λ } 
+42 <water_id_tail> -> { [, λ } 
+43 <arguments> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~, λ } 
+44 <arg_next> -> { ,, λ } 
+45 <conditional_stmt> -> { spring } 
+46 <elseif_chain> -> { bud, λ } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+93 
+47 <else_opt> -> { wither, λ } 
+48 <loop_stmt> -> { cultivate, grow, tend } 
+49 <for_init> -> { branch, id, leaf, seed, tree, vine, λ } 
+50 <for_update> -> { id, λ } 
+51 <unary_stmt> -> { id } 
+52 <inc_dec_op> -> { ++, -- } 
+53 <switch_stmt> -> { harvest } 
+54 <case_list> -> { variety, λ } 
+55 <case_literal> -> { chrlit, dblit, frost, intlit, stringlit, sunshine } 
+56 <case_statements> -> 
+{ ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, 
+plant, prune, reclaim, seed, skip, spring, tend, tree, vine, 
+water, {, λ } 
+57 <case_statement> -> 
+{ ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, 
+plant, prune, reclaim, seed, skip, spring, tend, tree, vine, 
+water, { } 
+58 <default_opt> -> { soil, λ } 
+59 <control_stmt> -> { prune, skip } 
+60 <function_call> -> { id } 
+61 <logic_or_next> -> { ||, λ } 
+62 <logic_and_next> -> { &&, λ } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+94 
+63 <relational_next> -> { !=, <, <=, ==, >, >=, λ } 
+64 <relational_op> -> { !=, <, <=, ==, >, >= } 
+65 <arithmetic_next> -> { +, -, `, λ } 
+66 <term_next> -> { %, *, /, λ } 
+67 <factor> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ } 
+ 
+ 
+XII. FOLLOW SET 
+ 
+# Nonterminal -> Follow Set 
+1 <program> -> { EOF } 
+2 <global_declaration> -> { pollinate, root } 
+3 <function_definition> -> { root } 
+4 <statement> -> { } } 
+5 <bundle_or_var> -> { branch, bundle, fertile, leaf, pollinate, root, seed, tree, 
+vine } 
+6 <data_type> -> { ), id } 
+7 <array_dec> -> { ,, ;, = } 
+8 <var_value> -> { ; } 
+9 <init_val> -> { ,, ; } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+95 
+10 <const_next> -> { ; } 
+11 <bundle_members> -> { } } 
+12 <bundle_mem_dec> -> { ; } 
+13 <var_dec> -> { ; } 
+14 <declaration> -> {  } 
+15 <const_dec> -> { ; } 
+16 <var_value_next> -> { ; } 
+17 <array_init_opt> -> { ,, ; } 
+18 <water_arg> -> { ) } 
+19 <expression> -> { ), ,, ;, ], } } 
+20 <array_dim_opt> -> { ] } 
+21 <init_vals> -> { } } 
+22 <init_val_item> -> { ,, } } 
+23 <init_vals_next> -> { } } 
+24 <return_type> -> { id } 
+25 <parameters> -> { ) } 
+26 <param> -> { ), , } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+96 
+27 <param_next> -> { ) } 
+28 <param_array> -> { ), , } 
+29 <reclaim_value> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+30 <reclaim_opt> -> {  } 
+31 <simple_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, 
+vine, water, } } 
+32 <id_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+33 <inc_dec_op> -> { ), ;, id } 
+34 <io_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+35 <conditional_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+36 <loop_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+37 <switch_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+38 <control_stmt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, 
+vine, water, } } 
+39 <id_next> -> { %=, *=, +=, -=, /=, = } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+97 
+40 <assign_op> -> { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, water, ~ 
+} 
+41 <assign_rhs> -> { ; } 
+42 <arguments> -> { ) } 
+43 <value> -> { %=, *=, +=, -=, /=, = } 
+44 <array_access> -> { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, ., /, /=, ;, <, <=, =, ==, 
+>, >=, ], `, ||, } } 
+45 <post_array_access> -> { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, 
+>=, ], `, ||, } } 
+46 <struct_access> -> { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, 
+>=, ], `, ||, } } 
+47 <array_access_more> -> { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, ., /, /=, ;, <, <=, =, ==, 
+>, >=, ], `, ||, } } 
+48 <struct_access_more> -> { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, 
+>=, ], `, ||, } } 
+49 <water_id_tail> -> { ) } 
+50 <arg_next> -> { ) } 
+51 <elseif_chain> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, wither, {, } } 
+52 <else_opt> -> 
+{ ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, 
+leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, 
+tree, variety, vine, water, {, } } 
+53 <for_init> -> { ; } 
+54 <for_update> -> { ) } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+98 
+55 <for_update_type> -> { ) } 
+56 <case_list> -> { soil, } } 
+57 <default_opt> -> { } } 
+58 <case_literal> -> { : } 
+59 <case_statements> -> { soil, variety, } } 
+60 <case_statement> -> 
+{ ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, 
+plant, prune, reclaim, seed, skip, soil, spring, tend, tree, 
+variety, vine, water, {, } } 
+61 <logic_or> -> { ), ,, ;, ], } } 
+62 <logic_and> -> { ), ,, ;, ], ||, } } 
+63 <logic_or_next> -> { ), ,, ;, ], } } 
+64 <relational> -> { &&, ), ,, ;, ], ||, } } 
+65 <logic_and_next> -> { ), ,, ;, ], ||, } } 
+66 <arithmetic> -> { !=, &&, ), ,, ;, <, <=, ==, >, >=, ], ||, } } 
+67 <relational_next> -> { &&, ), ,, ;, ], ||, } } 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+99 
+XIII. PREDICT SET 
+ 
+No. FIRST / Expression Form Basis Predict Set 
+1 
+first(<global_declaration> 
+<function_definition> root ( ) { 
+<statement> }) 
+first(<global_declaration>) 
+{ branch, bundle, fertile, 
+leaf, pollinate, root, seed, 
+tree, vine } 
+2 first(bundle id <bundle_or_var> 
+<global_declaration>) first(bundle) { bundle } 
+3 
+first(<data_type> id <array_dec> 
+<var_value> ; 
+<global_declaration>) 
+first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+4 
+first(fertile <data_type> id = 
+<init_val> <const_next> ; 
+<global_declaration>) 
+first(fertile) { fertile } 
+5 first(λ) ∪ 
+follow(<global_declaration>) follow(<global_declaration>) { pollinate, root } 
+6 first({ <bundle_members> } ;) first({) { { } 
+7 first(<bundle_mem_dec> ;) first(<bundle_mem_dec>) { ,, ;, id } 
+8 first(<var_dec> ; <declaration>) first(<var_dec>) { branch, bundle, leaf, 
+seed, tree, vine } 
+9 first(<const_dec> ; <declaration>) first(<const_dec>) { fertile } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+100 
+10 first(λ) ∪ follow(<declaration>) follow(<declaration>) {  } 
+11 first(seed) first(seed) { seed } 
+12 first(tree) first(tree) { tree } 
+13 first(leaf) first(leaf) { leaf } 
+14 first(branch) first(branch) { branch } 
+15 first(vine) first(vine) { vine } 
+16 first(fertile <data_type> id = 
+<init_val> <const_next>) first(fertile) { fertile } 
+17 first(, id = <init_val> <const_next>) first(,) { , } 
+18 first(λ) ∪ follow(<const_next>) follow(<const_next>) { ; } 
+19 first(<data_type> id <array_dec> 
+<var_value>) first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+20 first(bundle id 
+<bundle_mem_dec>) first(bundle) { bundle } 
+21 first(id <array_dec> 
+<var_value_next>) first(id) { id } 
+22 first(, id <var_value_next>) first(,) { , } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+101 
+23 first(λ) ∪ 
+follow(<bundle_mem_dec>) follow(<bundle_mem_dec>) { ; } 
+24 first(= <init_val> 
+<var_value_next>) first(=) { = } 
+25 first(<var_value_next>) first(<var_value_next>) { ,, ;, λ } 
+26 first(, id <array_dec> <var_value>) first(,) { , } 
+27 first(λ) ∪ follow(<var_value_next>) follow(<var_value_next>) { ; } 
+28 first(<array_init_opt>) first(<array_init_opt>) { ,, ;, {, λ } 
+29 first(water ( <water_arg> )) first(water) { water } 
+30 first(<expression>) first(<expression>) { !, (, chrlit, dblit, frost, id, 
+intlit, stringlit, sunshine, ~ } 
+31 first([ <array_dim_opt> ] 
+<array_dec>) first([) { [ } 
+32 first(λ) ∪ follow(<array_dec>) follow(<array_dec>) { ,, ;, = } 
+33 first(intlit) first(intlit) { intlit } 
+34 first(dblit) first(dblit) { dblit } 
+35 first(λ) ∪ follow(<array_dim_opt>) follow(<array_dim_opt>) { ] } 
+36 first({ <init_vals> }) first({) { { } 
+37 first(λ) ∪ follow(<array_init_opt>) follow(<array_init_opt>) { ,, ; } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+102 
+38 first(<init_val_item> 
+<init_vals_next>) first(<init_val_item>) 
+{ !, (, chrlit, dblit, frost, id, 
+intlit, stringlit, sunshine, {, 
+~ } 
+39 first(λ) ∪ follow(<init_vals>) follow(<init_vals>) { } } 
+40 first(, <init_val_item> 
+<init_vals_next>) first(,) { , } 
+41 first(λ) ∪ follow(<init_vals_next>) follow(<init_vals_next>) { } } 
+42 first({ <init_vals> }) first({) { { } 
+43 first(<expression>) first(<expression>) { !, (, chrlit, dblit, frost, id, 
+intlit, stringlit, sunshine, ~ } 
+44 first(bundle id { 
+<bundle_members> }) first(bundle) { bundle } 
+45 first(<data_type> id ; 
+<bundle_members>) first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+46 first(id id ; <bundle_members>) first(id) { id } 
+47 first(λ) ∪ 
+follow(<bundle_members>) follow(<bundle_members>) { } } 
+48 
+first(pollinate <return_type> id ( 
+<parameters> ) { <statement> } 
+<function_definition>) 
+first(pollinate) { pollinate } 
+49 first(λ) ∪ 
+follow(<function_definition>) follow(<function_definition>) { root } 
+50 first(<data_type>) first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+103 
+51 first(empty) first(empty) { empty } 
+52 first(id) first(id) { id } 
+53 first(λ) ∪ follow(<parameters>) follow(<parameters>) { ) } 
+54 first(<param> <param_next>) first(<param>) { branch, id, leaf, seed, 
+tree, vine } 
+55 first(<data_type> id 
+<param_array>) first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+56 first(id id) first(id) { id } 
+57 first(λ) ∪ follow(<param_array>) follow(<param_array>) { ), , } 
+58 first([ ]) first([) { [ } 
+59 first(λ) ∪ follow(<param_next>) follow(<param_next>) { ) } 
+60 first(, <param> <param_next>) first(,) { , } 
+61 first(reclaim <reclaim_value>) first(reclaim) { reclaim } 
+62 first(λ) ∪ follow(<reclaim_opt>) follow(<reclaim_opt>) {  } 
+63 first(<expression> ;) first(<expression>) { !, (, chrlit, dblit, frost, id, 
+intlit, stringlit, sunshine, ~ } 
+64 first(;) first(;) { ; } 
+65 first(<simple_stmt> <statement>) first(<simple_stmt>) { ++, --, branch, bundle, 
+cultivate, fertile, grow, 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+104 
+harvest, id, leaf, plant, 
+prune, reclaim, seed, skip, 
+spring, tend, tree, vine, 
+water } 
+66 first(λ) ∪ follow(<statement>) follow(<statement>) { } } 
+67 first(id <id_stmt>) first(id) { id } 
+68 first(<inc_dec_op> id ;) first(<inc_dec_op>) { ++, -- } 
+69 first(<io_stmt>) first(<io_stmt>) { plant, water } 
+70 first(<conditional_stmt>) first(<conditional_stmt>) { spring } 
+71 first(<loop_stmt>) first(<loop_stmt>) { cultivate, grow, tend } 
+72 first(<switch_stmt>) first(<switch_stmt>) { harvest } 
+73 first(<control_stmt>) first(<control_stmt>) { prune, skip } 
+74 first(reclaim <reclaim_value>) first(reclaim) { reclaim } 
+75 first(<var_dec> ;) first(<var_dec>) { branch, bundle, leaf, 
+seed, tree, vine } 
+76 first(<const_dec> ;) first(<const_dec>) { fertile } 
+77 first(<id_next> <assign_op> 
+<assign_rhs> ;) first(<id_next>) { %=, *=, +=, -=, ., /=, =, [ } 
+78 first(<inc_dec_op> ;) first(<inc_dec_op>) { ++, -- } 
+79 first(( <arguments> ) ;) first(() { ( } 
+80 first(<value> <assign_op> 
+<assign_rhs> ;) first(<value>) { id } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+105 
+81 first(water ( <water_arg> )) first(water) { water } 
+82 first(<expression>) first(<expression>) { !, (, chrlit, dblit, frost, id, 
+intlit, stringlit, sunshine, ~ } 
+83 first(=) first(=) { = } 
+84 first(+=) first(+=) { += } 
+85 first(-=) first(-=) { -= } 
+86 first(*=) first(*=) { *= } 
+87 first(/=) first(/=) { /= } 
+88 first(%=) first(%=) { %= } 
+89 first(id <id_next>) first(id) { id } 
+90 first(<array_access> 
+<post_array_access>) first(<array_access>) { [ } 
+91 first(<struct_access>) first(<struct_access>) { . } 
+92 first(λ) ∪ follow(<id_next>) follow(<id_next>) { %=, *=, +=, -=, /=, = } 
+93 first([ <expression> ] 
+<array_access_more>) first([) { [ } 
+94 first([ <expression> ] 
+<array_access_more>) first([) { [ } 
+95 first(λ) ∪ 
+follow(<array_access_more>) follow(<array_access_more>) 
+{ !=, %, %=, &&, ), *, *=, +, 
++=, ,, -, -=, ., /, /=, ;, <, <=, 
+=, ==, >, >=, ], `, ||, } } 
+96 first(. id <struct_access_more>) first(.) { . } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+106 
+97 first(. id <struct_access_more>) first(.) { . } 
+98 first(λ) ∪ 
+follow(<struct_access_more>) follow(<struct_access_more>) 
+{ !=, %, %=, &&, ), *, *=, +, 
++=, ,, -, -=, /, /=, ;, <, <=, =, 
+==, >, >=, ], `, ||, } } 
+99 first(. id <post_array_access>) first(.) { . } 
+100 first(λ) ∪ 
+follow(<post_array_access>) follow(<post_array_access>) 
+{ !=, %, %=, &&, ), *, *=, +, 
++=, ,, -, -=, /, /=, ;, <, <=, =, 
+==, >, >=, ], `, ||, } } 
+101 first(plant ( <arguments> ) ;) first(plant) { plant } 
+102 first(water ( <water_arg> ) ;) first(water) { water } 
+103 first(<data_type>) first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+104 first(id <water_id_tail>) first(id) { id } 
+105 first(λ) ∪ follow(<water_arg>) follow(<water_arg>) { ) } 
+106 first([ <expression> ] 
+<water_id_tail>) first([) { [ } 
+107 first(λ) ∪ follow(<water_id_tail>) follow(<water_id_tail>) { ) } 
+108 first(<expression> <arg_next>) first(<expression>) { !, (, chrlit, dblit, frost, id, 
+intlit, stringlit, sunshine, ~ } 
+109 first(λ) ∪ follow(<arguments>) follow(<arguments>) { ) } 
+110 first(, <expression> <arg_next>) first(,) { , } 
+111 first(λ) ∪ follow(<arg_next>) follow(<arg_next>) { ) } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+107 
+112 
+first(spring ( <expression> ) { 
+<statement> } <elseif_chain> 
+<else_opt>) 
+first(spring) { spring } 
+113 first(bud ( <expression> ) { 
+<statement> } <elseif_chain>) first(bud) { bud } 
+114 first(λ) ∪ follow(<elseif_chain>) follow(<elseif_chain>) 
+{ ++, --, branch, bundle, 
+cultivate, fertile, grow, 
+harvest, id, leaf, plant, 
+prune, reclaim, seed, skip, 
+soil, spring, tend, tree, 
+variety, vine, water, 
+wither, {, } } 
+115 first(wither { <statement> }) first(wither) { wither } 
+116 first(λ) ∪ follow(<else_opt>) follow(<else_opt>) 
+{ ++, --, branch, bundle, 
+cultivate, fertile, grow, 
+harvest, id, leaf, plant, 
+prune, reclaim, seed, skip, 
+soil, spring, tend, tree, 
+variety, vine, water, {, } } 
+117 first(grow ( <expression> ) { 
+<statement> }) first(grow) { grow } 
+118 
+first(cultivate ( <for_init> ; 
+<expression> ; <for_update> ) { 
+<statement> }) 
+first(cultivate) { cultivate } 
+119 first(tend { <statement> } grow ( 
+<expression> ) ;) first(tend) { tend } 
+120 first(<data_type> id <array_dec> 
+<var_value>) first(<data_type>) { branch, leaf, seed, tree, 
+vine } 
+121 first(id <id_next> <assign_op> 
+<expression>) first(id) { id } 
+122 first(λ) ∪ follow(<for_init>) follow(<for_init>) { ; } 
+123 first(id <for_update_type>) first(id) { id } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+108 
+124 first(λ) ∪ follow(<for_update>) follow(<for_update>) { ) } 
+125 first(<inc_dec_op>) first(<inc_dec_op>) { ++, -- } 
+126 first(<id_next> <assign_op> 
+<expression>) first(<id_next>) { %=, *=, +=, -=, ., /=, =, [ } 
+127 first(id <inc_dec_op> ;) first(id) { id } 
+128 first(++) first(++) { ++ } 
+129 first(--) first(--) { -- } 
+130 first(harvest ( <expression> ) { 
+<case_list> <default_opt> }) first(harvest) { harvest } 
+131 first(variety <case_literal> : 
+<case_statements> <case_list>) first(variety) { variety } 
+132 first(λ) ∪ follow(<case_list>) follow(<case_list>) { soil, } } 
+133 first(intlit) first(intlit) { intlit } 
+134 first(dblit) first(dblit) { dblit } 
+135 first(chrlit) first(chrlit) { chrlit } 
+136 first(stringlit) first(stringlit) { stringlit } 
+137 first(sunshine) first(sunshine) { sunshine } 
+138 first(frost) first(frost) { frost } 
+139 first(<case_statement> 
+<case_statements>) first(<case_statement>) 
+{ ++, --, branch, bundle, 
+cultivate, grow, harvest, id, 
+leaf, plant, prune, reclaim, 
+seed, skip, spring, tend, 
+tree, vine, water, { } 
+BERCASIO, E. M. S.                  MIRALLES, K. L.  
+BAYNA, C. L.                              TARINO, J. L. A. 
+HULIGANGA, S. K. E.  TOMINIO, M. 
+RAMOS, J.                                                                                      GrowALanguage 
+ 
+ 
+ 
+109 
+140 first(λ) ∪ 
+follow(<case_statements>) follow(<case_statements>) { soil, variety, } } 
+141 first(id <id_stmt>) first(id) { id } 
+142 first(<inc_dec_op> id ;) first(<inc_dec_op>) { ++, -- } 
+143 first(<var_dec> ;) first(<var_dec>) { branch, bundle, leaf, 
+seed, tree, vine } 
+144 first(<io_stmt>) first(<io_stmt>) { plant, water } 
+145 first(<conditional_stmt>) first(<conditional_stmt>) { spring } 
+146 first(<loop_stmt>) first(<loop_stmt>) { cultivate, grow, tend } 
+147 first(<switch_stmt>) first(<switch_stmt>) { harvest } 
+148 first({ <case_statements> }) first({) { { } 
+149 first(prune ;) first(prune) { prune } 
+150 first(skip ;) first(skip) { skip } 
+151 first(reclaim <reclaim_value>) first(reclaim) { reclaim } 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+XIV.  Lexical Test Scripts 
+ 

Docus & mps/gal_server_codex.err.log

@@ -0,0 +1,10 @@
+C:\Users\clarence\Downloads\AUTOMATA-COMPILER-main (1)\AUTOMATA-COMPILER-main\my GAL code\Backend\server.py:23: DeprecationWarning: 
+Eventlet is deprecated. It is currently being maintained in bugfix mode, and
+we strongly recommend against using it for new projects.
+
+If you are already using Eventlet, we recommend migrating to a different
+framework.  For more detail see
+https://eventlet.readthedocs.io/en/latest/asyncio/migration.html
+
+  import eventlet
+1 RLock(s) were not greened, to fix this error make sure you run eventlet.monkey_patch() before importing any other modules.

Docus & mps/system_cfg_first_follow_predict_current.txt

@@ -0,0 +1,559 @@
+CFG PRODUCTIONS
+1. <program> -> <global_declaration> <function_definition> root ( ) { <statement> }
+2. <global_declaration> -> bundle id <bundle_or_var> <global_declaration>
+3. <global_declaration> -> <data_type> id <array_dec> <var_value> ; <global_declaration>
+4. <global_declaration> -> fertile <data_type> id = <init_val> <const_next> ; <global_declaration>
+5. <global_declaration> -> λ
+6. <bundle_or_var> -> { <bundle_members> } ;
+7. <bundle_or_var> -> <bundle_mem_dec> ;
+8. <declaration> -> <var_dec> ; <declaration>
+9. <declaration> -> <const_dec> ; <declaration>
+10. <declaration> -> λ
+11. <data_type> -> seed
+12. <data_type> -> tree
+13. <data_type> -> leaf
+14. <data_type> -> branch
+15. <data_type> -> vine
+16. <const_dec> -> fertile <data_type> id = <init_val> <const_next>
+17. <const_next> -> , id = <init_val> <const_next>
+18. <const_next> -> λ
+19. <var_dec> -> <data_type> id <array_dec> <var_value>
+20. <var_dec> -> bundle id <bundle_mem_dec>
+21. <bundle_mem_dec> -> id <array_dec> <var_value_next>
+22. <bundle_mem_dec> -> , id <var_value_next>
+23. <bundle_mem_dec> -> λ
+24. <var_value> -> = <init_val> <var_value_next>
+25. <var_value> -> <var_value_next>
+26. <var_value_next> -> , id <array_dec> <var_value>
+27. <var_value_next> -> λ
+28. <init_val> -> <array_init_opt>
+29. <init_val> -> water ( <water_arg> )
+30. <init_val> -> <expression>
+31. <array_dec> -> [ <array_dim_opt> ] <array_dec>
+32. <array_dec> -> λ
+33. <array_dim_opt> -> intlit
+34. <array_dim_opt> -> dblit
+35. <array_dim_opt> -> λ
+36. <array_init_opt> -> { <init_vals> }
+37. <array_init_opt> -> λ
+38. <init_vals> -> <init_val_item> <init_vals_next>
+39. <init_vals> -> λ
+40. <init_vals_next> -> , <init_val_item> <init_vals_next>
+41. <init_vals_next> -> λ
+42. <init_val_item> -> { <init_vals> }
+43. <init_val_item> -> <expression>
+44. <bundle_declaration> -> bundle id { <bundle_members> }
+45. <bundle_members> -> <data_type> id ; <bundle_members>
+46. <bundle_members> -> id id ; <bundle_members>
+47. <bundle_members> -> λ
+48. <function_definition> -> pollinate <return_type> id ( <parameters> ) { <statement> } <function_definition>
+49. <function_definition> -> λ
+50. <return_type> -> <data_type>
+51. <return_type> -> empty
+52. <return_type> -> id
+53. <parameters> -> λ
+54. <parameters> -> <param> <param_next>
+55. <param> -> <data_type> id <param_array>
+56. <param> -> id id
+57. <param_array> -> λ
+58. <param_array> -> [ ]
+59. <param_next> -> λ
+60. <param_next> -> , <param> <param_next>
+61. <reclaim_opt> -> reclaim <reclaim_value>
+62. <reclaim_opt> -> λ
+63. <reclaim_value> -> <expression> ;
+64. <reclaim_value> -> ;
+65. <statement> -> <simple_stmt> <statement>
+66. <statement> -> λ
+67. <simple_stmt> -> id <id_stmt>
+68. <simple_stmt> -> <inc_dec_op> id ;
+69. <simple_stmt> -> <io_stmt>
+70. <simple_stmt> -> <conditional_stmt>
+71. <simple_stmt> -> <loop_stmt>
+72. <simple_stmt> -> <switch_stmt>
+73. <simple_stmt> -> <control_stmt>
+74. <simple_stmt> -> reclaim <reclaim_value>
+75. <simple_stmt> -> <var_dec> ;
+76. <simple_stmt> -> <const_dec> ;
+77. <id_stmt> -> <id_next> <assign_op> <assign_rhs> ;
+78. <id_stmt> -> <inc_dec_op> ;
+79. <id_stmt> -> ( <arguments> ) ;
+80. <assignment_stmt> -> <value> <assign_op> <assign_rhs> ;
+81. <assign_rhs> -> water ( <water_arg> )
+82. <assign_rhs> -> <expression>
+83. <assign_op> -> =
+84. <assign_op> -> +=
+85. <assign_op> -> -=
+86. <assign_op> -> *=
+87. <assign_op> -> /=
+88. <assign_op> -> %=
+89. <value> -> id <id_next>
+90. <id_next> -> <array_access> <post_array_access>
+91. <id_next> -> <struct_access>
+92. <id_next> -> λ
+93. <array_access> -> [ <expression> ] <array_access_more>
+94. <array_access_more> -> [ <expression> ] <array_access_more>
+95. <array_access_more> -> λ
+96. <struct_access> -> . id <struct_access_more>
+97. <struct_access_more> -> . id <struct_access_more>
+98. <struct_access_more> -> λ
+99. <post_array_access> -> . id <post_array_access>
+100. <post_array_access> -> λ
+101. <io_stmt> -> plant ( <arguments> ) ;
+102. <io_stmt> -> water ( <water_arg> ) ;
+103. <water_arg> -> <data_type>
+104. <water_arg> -> id <water_id_tail>
+105. <water_arg> -> λ
+106. <water_id_tail> -> [ <expression> ] <water_id_tail>
+107. <water_id_tail> -> λ
+108. <arguments> -> <expression> <arg_next>
+109. <arguments> -> λ
+110. <arg_next> -> , <expression> <arg_next>
+111. <arg_next> -> λ
+112. <conditional_stmt> -> spring ( <expression> ) { <statement> } <elseif_chain> <else_opt>
+113. <elseif_chain> -> bud ( <expression> ) { <statement> } <elseif_chain>
+114. <elseif_chain> -> λ
+115. <else_opt> -> wither { <statement> }
+116. <else_opt> -> λ
+117. <loop_stmt> -> grow ( <expression> ) { <statement> }
+118. <loop_stmt> -> cultivate ( <for_init> ; <expression> ; <for_update> ) { <statement> }
+119. <loop_stmt> -> tend { <statement> } grow ( <expression> ) ;
+120. <for_init> -> <data_type> id <array_dec> <var_value>
+121. <for_init> -> id <id_next> <assign_op> <expression>
+122. <for_init> -> λ
+123. <for_update> -> id <for_update_type>
+124. <for_update> -> λ
+125. <for_update_type> -> <inc_dec_op>
+126. <for_update_type> -> <id_next> <assign_op> <expression>
+127. <unary_stmt> -> id <inc_dec_op> ;
+128. <inc_dec_op> -> ++
+129. <inc_dec_op> -> --
+130. <switch_stmt> -> harvest ( <expression> ) { <case_list> <default_opt> }
+131. <case_list> -> variety <case_literal> : <case_statements> <case_list>
+132. <case_list> -> λ
+133. <case_literal> -> intlit
+134. <case_literal> -> dblit
+135. <case_literal> -> chrlit
+136. <case_literal> -> stringlit
+137. <case_literal> -> sunshine
+138. <case_literal> -> frost
+139. <case_statements> -> <case_statement> <case_statements>
+140. <case_statements> -> λ
+141. <case_statement> -> id <id_stmt>
+142. <case_statement> -> <inc_dec_op> id ;
+143. <case_statement> -> <var_dec> ;
+144. <case_statement> -> <io_stmt>
+145. <case_statement> -> <conditional_stmt>
+146. <case_statement> -> <loop_stmt>
+147. <case_statement> -> <switch_stmt>
+148. <case_statement> -> { <case_statements> }
+149. <case_statement> -> prune ;
+150. <case_statement> -> skip ;
+151. <case_statement> -> reclaim <reclaim_value>
+152. <default_opt> -> soil : <case_statements>
+153. <default_opt> -> λ
+154. <control_stmt> -> prune ;
+155. <control_stmt> -> skip ;
+156. <function_call> -> id ( <arguments> ) ;
+157. <expression> -> <logic_or>
+158. <logic_or> -> <logic_and> <logic_or_next>
+159. <logic_or_next> -> || <logic_and> <logic_or_next>
+160. <logic_or_next> -> λ
+161. <logic_and> -> <relational> <logic_and_next>
+162. <logic_and_next> -> && <relational> <logic_and_next>
+163. <logic_and_next> -> λ
+164. <relational> -> <arithmetic> <relational_next>
+165. <relational_next> -> <relational_op> <arithmetic>
+166. <relational_next> -> λ
+167. <relational_op> -> >
+168. <relational_op> -> <
+169. <relational_op> -> >=
+170. <relational_op> -> <=
+171. <relational_op> -> ==
+172. <relational_op> -> !=
+173. <arithmetic> -> <term> <arithmetic_next>
+174. <arithmetic_next> -> + <term> <arithmetic_next>
+175. <arithmetic_next> -> - <term> <arithmetic_next>
+176. <arithmetic_next> -> ` <term> <arithmetic_next>
+177. <arithmetic_next> -> λ
+178. <term> -> <factor> <term_next>
+179. <term_next> -> * <factor> <term_next>
+180. <term_next> -> / <factor> <term_next>
+181. <term_next> -> % <factor> <term_next>
+182. <term_next> -> λ
+183. <factor> -> ( <paren_expr>
+184. <factor> -> <unary_op> <factor>
+185. <factor> -> id <factor_id_next>
+186. <factor> -> intlit
+187. <factor> -> dblit
+188. <factor> -> chrlit
+189. <factor> -> stringlit
+190. <factor> -> sunshine
+191. <factor> -> frost
+192. <paren_expr> -> <data_type> ) <factor>
+193. <paren_expr> -> <expression> )
+194. <unary_op> -> ~
+195. <unary_op> -> !
+196. <factor_id_next> -> <array_access> <post_array_access>
+197. <factor_id_next> -> <struct_access>
+198. <factor_id_next> -> ( <arguments> )
+199. <factor_id_next> -> λ
+
+FIRST SETS
+First(<global_declaration>) = { branch, bundle, fertile, leaf, seed, tree, vine, λ }
+First(<bundle_or_var>) = { ,, ;, id, { }
+First(<declaration>) = { branch, bundle, fertile, leaf, seed, tree, vine, λ }
+First(<data_type>) = { branch, leaf, seed, tree, vine }
+First(<const_dec>) = { fertile }
+First(<const_next>) = { ,, λ }
+First(<var_dec>) = { branch, bundle, leaf, seed, tree, vine }
+First(<bundle_mem_dec>) = { ,, id, λ }
+First(<var_value>) = { ,, =, λ }
+First(<var_value_next>) = { ,, λ }
+First(<init_val>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, water, {, ~, λ }
+First(<array_dec>) = { [, λ }
+First(<array_dim_opt>) = { dblit, intlit, λ }
+First(<array_init_opt>) = { {, λ }
+First(<init_vals>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, {, ~, λ }
+First(<init_vals_next>) = { ,, λ }
+First(<init_val_item>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, {, ~ }
+First(<bundle_declaration>) = { bundle }
+First(<bundle_members>) = { branch, id, leaf, seed, tree, vine, λ }
+First(<function_definition>) = { pollinate, λ }
+First(<return_type>) = { branch, empty, id, leaf, seed, tree, vine }
+First(<parameters>) = { branch, id, leaf, seed, tree, vine, λ }
+First(<param>) = { branch, id, leaf, seed, tree, vine }
+First(<param_array>) = { [, λ }
+First(<param_next>) = { ,, λ }
+First(<reclaim_opt>) = { reclaim, λ }
+First(<reclaim_value>) = { !, (, ;, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<statement>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, λ }
+First(<simple_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+First(<id_stmt>) = { %=, (, *=, ++, +=, --, -=, ., /=, =, [ }
+First(<assign_rhs>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, water, ~ }
+First(<assign_op>) = { %=, *=, +=, -=, /=, = }
+First(<value>) = { id }
+First(<id_next>) = { ., [, λ }
+First(<array_access>) = { [ }
+First(<array_access_more>) = { [, λ }
+First(<struct_access>) = { . }
+First(<struct_access_more>) = { ., λ }
+First(<post_array_access>) = { ., λ }
+First(<io_stmt>) = { plant, water }
+First(<water_arg>) = { branch, id, leaf, seed, tree, vine, λ }
+First(<water_id_tail>) = { [, λ }
+First(<arguments>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~, λ }
+First(<arg_next>) = { ,, λ }
+First(<conditional_stmt>) = { spring }
+First(<elseif_chain>) = { bud, λ }
+First(<else_opt>) = { wither, λ }
+First(<loop_stmt>) = { cultivate, grow, tend }
+First(<for_init>) = { branch, id, leaf, seed, tree, vine, λ }
+First(<for_update>) = { id, λ }
+First(<unary_stmt>) = { id }
+First(<inc_dec_op>) = { ++, -- }
+First(<switch_stmt>) = { harvest }
+First(<case_list>) = { variety, λ }
+First(<case_literal>) = { chrlit, dblit, frost, intlit, stringlit, sunshine }
+First(<case_statements>) = { ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, {, λ }
+First(<case_statement>) = { ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, { }
+First(<default_opt>) = { soil, λ }
+First(<control_stmt>) = { prune, skip }
+First(<function_call>) = { id }
+First(<logic_or_next>) = { ||, λ }
+First(<logic_and_next>) = { &&, λ }
+First(<relational_next>) = { !=, <, <=, ==, >, >=, λ }
+First(<relational_op>) = { !=, <, <=, ==, >, >= }
+First(<arithmetic_next>) = { +, -, `, λ }
+First(<term_next>) = { %, *, /, λ }
+First(<factor>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<unary_op>) = { !, ~ }
+First(<factor_id_next>) = { (, ., [, λ }
+First(<program>) = { branch, bundle, fertile, leaf, pollinate, root, seed, tree, vine }
+First(<expression>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<assignment_stmt>) = { id }
+First(<for_update_type>) = { %=, *=, ++, +=, --, -=, ., /=, =, [ }
+First(<logic_or>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<logic_and>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<relational>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<arithmetic>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<term>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+First(<paren_expr>) = { !, (, branch, chrlit, dblit, frost, id, intlit, leaf, seed, stringlit, sunshine, tree, vine, ~ }
+
+FOLLOW SETS
+Follow(<program>) = { EOF }
+Follow(<global_declaration>) = { pollinate, root }
+Follow(<function_definition>) = { root }
+Follow(<statement>) = { } }
+Follow(<bundle_or_var>) = { branch, bundle, fertile, leaf, pollinate, root, seed, tree, vine }
+Follow(<data_type>) = { ), id }
+Follow(<array_dec>) = { ,, ;, = }
+Follow(<var_value>) = { ; }
+Follow(<init_val>) = { ,, ; }
+Follow(<const_next>) = { ; }
+Follow(<bundle_members>) = { } }
+Follow(<bundle_mem_dec>) = { ; }
+Follow(<var_dec>) = { ; }
+Follow(<declaration>) = {  }
+Follow(<const_dec>) = { ; }
+Follow(<var_value_next>) = { ; }
+Follow(<array_init_opt>) = { ,, ; }
+Follow(<water_arg>) = { ) }
+Follow(<expression>) = { ), ,, ;, ], } }
+Follow(<array_dim_opt>) = { ] }
+Follow(<init_vals>) = { } }
+Follow(<init_val_item>) = { ,, } }
+Follow(<init_vals_next>) = { } }
+Follow(<return_type>) = { id }
+Follow(<parameters>) = { ) }
+Follow(<param>) = { ), , }
+Follow(<param_next>) = { ) }
+Follow(<param_array>) = { ), , }
+Follow(<reclaim_value>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<reclaim_opt>) = {  }
+Follow(<simple_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, } }
+Follow(<id_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<inc_dec_op>) = { ), ;, id }
+Follow(<io_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<conditional_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<loop_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<switch_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<control_stmt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, } }
+Follow(<id_next>) = { %=, *=, +=, -=, /=, = }
+Follow(<assign_op>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, water, ~ }
+Follow(<assign_rhs>) = { ; }
+Follow(<arguments>) = { ) }
+Follow(<value>) = { %=, *=, +=, -=, /=, = }
+Follow(<array_access>) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, ., /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Follow(<post_array_access>) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Follow(<struct_access>) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Follow(<array_access_more>) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, ., /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Follow(<struct_access_more>) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Follow(<water_id_tail>) = { ) }
+Follow(<arg_next>) = { ) }
+Follow(<elseif_chain>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, wither, {, } }
+Follow(<else_opt>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<for_init>) = { ; }
+Follow(<for_update>) = { ) }
+Follow(<for_update_type>) = { ) }
+Follow(<case_list>) = { soil, } }
+Follow(<default_opt>) = { } }
+Follow(<case_literal>) = { : }
+Follow(<case_statements>) = { soil, variety, } }
+Follow(<case_statement>) = { ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Follow(<logic_or>) = { ), ,, ;, ], } }
+Follow(<logic_and>) = { ), ,, ;, ], ||, } }
+Follow(<logic_or_next>) = { ), ,, ;, ], } }
+Follow(<relational>) = { &&, ), ,, ;, ], ||, } }
+Follow(<logic_and_next>) = { ), ,, ;, ], ||, } }
+Follow(<arithmetic>) = { !=, &&, ), ,, ;, <, <=, ==, >, >=, ], ||, } }
+Follow(<relational_next>) = { &&, ), ,, ;, ], ||, } }
+Follow(<relational_op>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Follow(<term>) = { !=, &&, ), +, ,, -, ;, <, <=, ==, >, >=, ], `, ||, } }
+Follow(<arithmetic_next>) = { !=, &&, ), ,, ;, <, <=, ==, >, >=, ], ||, } }
+Follow(<factor>) = { !=, %, &&, ), *, +, ,, -, /, ;, <, <=, ==, >, >=, ], `, ||, } }
+Follow(<term_next>) = { !=, &&, ), +, ,, -, ;, <, <=, ==, >, >=, ], `, ||, } }
+Follow(<paren_expr>) = { !=, %, &&, ), *, +, ,, -, /, ;, <, <=, ==, >, >=, ], `, ||, } }
+Follow(<unary_op>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Follow(<factor_id_next>) = { !=, %, &&, ), *, +, ,, -, /, ;, <, <=, ==, >, >=, ], `, ||, } }
+
+PREDICT SETS
+Predict(<program> -> <global_declaration> <function_definition> root ( ) { <statement> }) = { branch, bundle, fertile, leaf, pollinate, root, seed, tree, vine }
+Predict(<global_declaration> -> bundle id <bundle_or_var> <global_declaration>) = { bundle }
+Predict(<global_declaration> -> <data_type> id <array_dec> <var_value> ; <global_declaration>) = { branch, leaf, seed, tree, vine }
+Predict(<global_declaration> -> fertile <data_type> id = <init_val> <const_next> ; <global_declaration>) = { fertile }
+Predict(<global_declaration> -> λ) = { pollinate, root }
+Predict(<bundle_or_var> -> { <bundle_members> } ;) = { { }
+Predict(<bundle_or_var> -> <bundle_mem_dec> ;) = { ,, ;, id }
+Predict(<declaration> -> <var_dec> ; <declaration>) = { branch, bundle, leaf, seed, tree, vine }
+Predict(<declaration> -> <const_dec> ; <declaration>) = { fertile }
+Predict(<declaration> -> λ) = {  }
+Predict(<data_type> -> seed) = { seed }
+Predict(<data_type> -> tree) = { tree }
+Predict(<data_type> -> leaf) = { leaf }
+Predict(<data_type> -> branch) = { branch }
+Predict(<data_type> -> vine) = { vine }
+Predict(<const_dec> -> fertile <data_type> id = <init_val> <const_next>) = { fertile }
+Predict(<const_next> -> , id = <init_val> <const_next>) = { , }
+Predict(<const_next> -> λ) = { ; }
+Predict(<var_dec> -> <data_type> id <array_dec> <var_value>) = { branch, leaf, seed, tree, vine }
+Predict(<var_dec> -> bundle id <bundle_mem_dec>) = { bundle }
+Predict(<bundle_mem_dec> -> id <array_dec> <var_value_next>) = { id }
+Predict(<bundle_mem_dec> -> , id <var_value_next>) = { , }
+Predict(<bundle_mem_dec> -> λ) = { ; }
+Predict(<var_value> -> = <init_val> <var_value_next>) = { = }
+Predict(<var_value> -> <var_value_next>) = { ,, ;, λ }
+Predict(<var_value_next> -> , id <array_dec> <var_value>) = { , }
+Predict(<var_value_next> -> λ) = { ; }
+Predict(<init_val> -> <array_init_opt>) = { ,, ;, {, λ }
+Predict(<init_val> -> water ( <water_arg> )) = { water }
+Predict(<init_val> -> <expression>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<array_dec> -> [ <array_dim_opt> ] <array_dec>) = { [ }
+Predict(<array_dec> -> λ) = { ,, ;, = }
+Predict(<array_dim_opt> -> intlit) = { intlit }
+Predict(<array_dim_opt> -> dblit) = { dblit }
+Predict(<array_dim_opt> -> λ) = { ] }
+Predict(<array_init_opt> -> { <init_vals> }) = { { }
+Predict(<array_init_opt> -> λ) = { ,, ; }
+Predict(<init_vals> -> <init_val_item> <init_vals_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, {, ~ }
+Predict(<init_vals> -> λ) = { } }
+Predict(<init_vals_next> -> , <init_val_item> <init_vals_next>) = { , }
+Predict(<init_vals_next> -> λ) = { } }
+Predict(<init_val_item> -> { <init_vals> }) = { { }
+Predict(<init_val_item> -> <expression>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<bundle_declaration> -> bundle id { <bundle_members> }) = { bundle }
+Predict(<bundle_members> -> <data_type> id ; <bundle_members>) = { branch, leaf, seed, tree, vine }
+Predict(<bundle_members> -> id id ; <bundle_members>) = { id }
+Predict(<bundle_members> -> λ) = { } }
+Predict(<function_definition> -> pollinate <return_type> id ( <parameters> ) { <statement> } <function_definition>) = { pollinate }
+Predict(<function_definition> -> λ) = { root }
+Predict(<return_type> -> <data_type>) = { branch, leaf, seed, tree, vine }
+Predict(<return_type> -> empty) = { empty }
+Predict(<return_type> -> id) = { id }
+Predict(<parameters> -> λ) = { ) }
+Predict(<parameters> -> <param> <param_next>) = { branch, id, leaf, seed, tree, vine }
+Predict(<param> -> <data_type> id <param_array>) = { branch, leaf, seed, tree, vine }
+Predict(<param> -> id id) = { id }
+Predict(<param_array> -> λ) = { ), , }
+Predict(<param_array> -> [ ]) = { [ }
+Predict(<param_next> -> λ) = { ) }
+Predict(<param_next> -> , <param> <param_next>) = { , }
+Predict(<reclaim_opt> -> reclaim <reclaim_value>) = { reclaim }
+Predict(<reclaim_opt> -> λ) = {  }
+Predict(<reclaim_value> -> <expression> ;) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<reclaim_value> -> ;) = { ; }
+Predict(<statement> -> <simple_stmt> <statement>) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water }
+Predict(<statement> -> λ) = { } }
+Predict(<simple_stmt> -> id <id_stmt>) = { id }
+Predict(<simple_stmt> -> <inc_dec_op> id ;) = { ++, -- }
+Predict(<simple_stmt> -> <io_stmt>) = { plant, water }
+Predict(<simple_stmt> -> <conditional_stmt>) = { spring }
+Predict(<simple_stmt> -> <loop_stmt>) = { cultivate, grow, tend }
+Predict(<simple_stmt> -> <switch_stmt>) = { harvest }
+Predict(<simple_stmt> -> <control_stmt>) = { prune, skip }
+Predict(<simple_stmt> -> reclaim <reclaim_value>) = { reclaim }
+Predict(<simple_stmt> -> <var_dec> ;) = { branch, bundle, leaf, seed, tree, vine }
+Predict(<simple_stmt> -> <const_dec> ;) = { fertile }
+Predict(<id_stmt> -> <id_next> <assign_op> <assign_rhs> ;) = { %=, *=, +=, -=, ., /=, =, [ }
+Predict(<id_stmt> -> <inc_dec_op> ;) = { ++, -- }
+Predict(<id_stmt> -> ( <arguments> ) ;) = { ( }
+Predict(<assignment_stmt> -> <value> <assign_op> <assign_rhs> ;) = { id }
+Predict(<assign_rhs> -> water ( <water_arg> )) = { water }
+Predict(<assign_rhs> -> <expression>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<assign_op> -> =) = { = }
+Predict(<assign_op> -> +=) = { += }
+Predict(<assign_op> -> -=) = { -= }
+Predict(<assign_op> -> *=) = { *= }
+Predict(<assign_op> -> /=) = { /= }
+Predict(<assign_op> -> %=) = { %= }
+Predict(<value> -> id <id_next>) = { id }
+Predict(<id_next> -> <array_access> <post_array_access>) = { [ }
+Predict(<id_next> -> <struct_access>) = { . }
+Predict(<id_next> -> λ) = { %=, *=, +=, -=, /=, = }
+Predict(<array_access> -> [ <expression> ] <array_access_more>) = { [ }
+Predict(<array_access_more> -> [ <expression> ] <array_access_more>) = { [ }
+Predict(<array_access_more> -> λ) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, ., /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Predict(<struct_access> -> . id <struct_access_more>) = { . }
+Predict(<struct_access_more> -> . id <struct_access_more>) = { . }
+Predict(<struct_access_more> -> λ) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Predict(<post_array_access> -> . id <post_array_access>) = { . }
+Predict(<post_array_access> -> λ) = { !=, %, %=, &&, ), *, *=, +, +=, ,, -, -=, /, /=, ;, <, <=, =, ==, >, >=, ], `, ||, } }
+Predict(<io_stmt> -> plant ( <arguments> ) ;) = { plant }
+Predict(<io_stmt> -> water ( <water_arg> ) ;) = { water }
+Predict(<water_arg> -> <data_type>) = { branch, leaf, seed, tree, vine }
+Predict(<water_arg> -> id <water_id_tail>) = { id }
+Predict(<water_arg> -> λ) = { ) }
+Predict(<water_id_tail> -> [ <expression> ] <water_id_tail>) = { [ }
+Predict(<water_id_tail> -> λ) = { ) }
+Predict(<arguments> -> <expression> <arg_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<arguments> -> λ) = { ) }
+Predict(<arg_next> -> , <expression> <arg_next>) = { , }
+Predict(<arg_next> -> λ) = { ) }
+Predict(<conditional_stmt> -> spring ( <expression> ) { <statement> } <elseif_chain> <else_opt>) = { spring }
+Predict(<elseif_chain> -> bud ( <expression> ) { <statement> } <elseif_chain>) = { bud }
+Predict(<elseif_chain> -> λ) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, wither, {, } }
+Predict(<else_opt> -> wither { <statement> }) = { wither }
+Predict(<else_opt> -> λ) = { ++, --, branch, bundle, cultivate, fertile, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, soil, spring, tend, tree, variety, vine, water, {, } }
+Predict(<loop_stmt> -> grow ( <expression> ) { <statement> }) = { grow }
+Predict(<loop_stmt> -> cultivate ( <for_init> ; <expression> ; <for_update> ) { <statement> }) = { cultivate }
+Predict(<loop_stmt> -> tend { <statement> } grow ( <expression> ) ;) = { tend }
+Predict(<for_init> -> <data_type> id <array_dec> <var_value>) = { branch, leaf, seed, tree, vine }
+Predict(<for_init> -> id <id_next> <assign_op> <expression>) = { id }
+Predict(<for_init> -> λ) = { ; }
+Predict(<for_update> -> id <for_update_type>) = { id }
+Predict(<for_update> -> λ) = { ) }
+Predict(<for_update_type> -> <inc_dec_op>) = { ++, -- }
+Predict(<for_update_type> -> <id_next> <assign_op> <expression>) = { %=, *=, +=, -=, ., /=, =, [ }
+Predict(<unary_stmt> -> id <inc_dec_op> ;) = { id }
+Predict(<inc_dec_op> -> ++) = { ++ }
+Predict(<inc_dec_op> -> --) = { -- }
+Predict(<switch_stmt> -> harvest ( <expression> ) { <case_list> <default_opt> }) = { harvest }
+Predict(<case_list> -> variety <case_literal> : <case_statements> <case_list>) = { variety }
+Predict(<case_list> -> λ) = { soil, } }
+Predict(<case_literal> -> intlit) = { intlit }
+Predict(<case_literal> -> dblit) = { dblit }
+Predict(<case_literal> -> chrlit) = { chrlit }
+Predict(<case_literal> -> stringlit) = { stringlit }
+Predict(<case_literal> -> sunshine) = { sunshine }
+Predict(<case_literal> -> frost) = { frost }
+Predict(<case_statements> -> <case_statement> <case_statements>) = { ++, --, branch, bundle, cultivate, grow, harvest, id, leaf, plant, prune, reclaim, seed, skip, spring, tend, tree, vine, water, { }
+Predict(<case_statements> -> λ) = { soil, variety, } }
+Predict(<case_statement> -> id <id_stmt>) = { id }
+Predict(<case_statement> -> <inc_dec_op> id ;) = { ++, -- }
+Predict(<case_statement> -> <var_dec> ;) = { branch, bundle, leaf, seed, tree, vine }
+Predict(<case_statement> -> <io_stmt>) = { plant, water }
+Predict(<case_statement> -> <conditional_stmt>) = { spring }
+Predict(<case_statement> -> <loop_stmt>) = { cultivate, grow, tend }
+Predict(<case_statement> -> <switch_stmt>) = { harvest }
+Predict(<case_statement> -> { <case_statements> }) = { { }
+Predict(<case_statement> -> prune ;) = { prune }
+Predict(<case_statement> -> skip ;) = { skip }
+Predict(<case_statement> -> reclaim <reclaim_value>) = { reclaim }
+Predict(<default_opt> -> soil : <case_statements>) = { soil }
+Predict(<default_opt> -> λ) = { } }
+Predict(<control_stmt> -> prune ;) = { prune }
+Predict(<control_stmt> -> skip ;) = { skip }
+Predict(<function_call> -> id ( <arguments> ) ;) = { id }
+Predict(<expression> -> <logic_or>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<logic_or> -> <logic_and> <logic_or_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<logic_or_next> -> || <logic_and> <logic_or_next>) = { || }
+Predict(<logic_or_next> -> λ) = { ), ,, ;, ], } }
+Predict(<logic_and> -> <relational> <logic_and_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<logic_and_next> -> && <relational> <logic_and_next>) = { && }
+Predict(<logic_and_next> -> λ) = { ), ,, ;, ], ||, } }
+Predict(<relational> -> <arithmetic> <relational_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<relational_next> -> <relational_op> <arithmetic>) = { !=, <, <=, ==, >, >= }
+Predict(<relational_next> -> λ) = { &&, ), ,, ;, ], ||, } }
+Predict(<relational_op> -> >) = { > }
+Predict(<relational_op> -> <) = { < }
+Predict(<relational_op> -> >=) = { >= }
+Predict(<relational_op> -> <=) = { <= }
+Predict(<relational_op> -> ==) = { == }
+Predict(<relational_op> -> !=) = { != }
+Predict(<arithmetic> -> <term> <arithmetic_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<arithmetic_next> -> + <term> <arithmetic_next>) = { + }
+Predict(<arithmetic_next> -> - <term> <arithmetic_next>) = { - }
+Predict(<arithmetic_next> -> ` <term> <arithmetic_next>) = { ` }
+Predict(<arithmetic_next> -> λ) = { !=, &&, ), ,, ;, <, <=, ==, >, >=, ], ||, } }
+Predict(<term> -> <factor> <term_next>) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<term_next> -> * <factor> <term_next>) = { * }
+Predict(<term_next> -> / <factor> <term_next>) = { / }
+Predict(<term_next> -> % <factor> <term_next>) = { % }
+Predict(<term_next> -> λ) = { !=, &&, ), +, ,, -, ;, <, <=, ==, >, >=, ], `, ||, } }
+Predict(<factor> -> ( <paren_expr>) = { ( }
+Predict(<factor> -> <unary_op> <factor>) = { !, ~ }
+Predict(<factor> -> id <factor_id_next>) = { id }
+Predict(<factor> -> intlit) = { intlit }
+Predict(<factor> -> dblit) = { dblit }
+Predict(<factor> -> chrlit) = { chrlit }
+Predict(<factor> -> stringlit) = { stringlit }
+Predict(<factor> -> sunshine) = { sunshine }
+Predict(<factor> -> frost) = { frost }
+Predict(<paren_expr> -> <data_type> ) <factor>) = { branch, leaf, seed, tree, vine }
+Predict(<paren_expr> -> <expression> )) = { !, (, chrlit, dblit, frost, id, intlit, stringlit, sunshine, ~ }
+Predict(<unary_op> -> ~) = { ~ }
+Predict(<unary_op> -> !) = { ! }
+Predict(<factor_id_next> -> <array_access> <post_array_access>) = { [ }
+Predict(<factor_id_next> -> <struct_access>) = { . }
+Predict(<factor_id_next> -> ( <arguments> )) = { ( }
+Predict(<factor_id_next> -> λ) = { !=, %, &&, ), *, +, ,, -, /, ;, <, <=, ==, >, >=, ], `, ||, } }