prequel.urc

COMMENT FP class available at https://github.com/simoesh/FixPointCS/tree/urcode
VAR `fp = [NULL]

CLASS `ResourceIds:

  METHOD_INIT():
    THIS.`_ids = []
    THIS.`_cur_id = 1+`trunc(0.5+`random()*1000)
    THIS.`_free_ids = []

  METHOD `alloc():
    VAR `an_id
    IF `length(THIS.`_free_ids) > 0:
      `an_id = `pop(THIS.`_free_ids)
    ELSE:
      `an_id = THIS.`_cur_id
      THIS.`_cur_id += 1
    ENDIF
    `queue(THIS.`_ids, `an_id)
    return `an_id

  METHOD `free(`an_id):
    VAR `index = `indexof(THIS.`_ids, `an_id)
    IF `index < 0:
      `warning("Prequel"+" "+"ResourceIds"+" "+"free"+":"+" "+"id"+" "+"does"+" "+"not"+" "+"exist"+":", `an_id)
      return
    ENDIF
    `push(THIS.`_free_ids, THIS.`_ids[`index])
    `pick(THIS.`_ids, `index)

ENDCLASS

VAR `ARG_TYPE_NUMBER = 0
VAR `ARG_TYPE_LIST = 1
VAR `ARG_TYPE_STRING = 2
VAR `ARG_TYPE_VARNAME = 3
VAR `ARG_TYPE_MODNAME = 4

VAR `key_limits_instructions = 0
VAR `key_limits_max_memory = 1
VAR `key_limits_memory = 2
VAR `key_limits_memory_n = 3
VAR `key_limits_memory_l = 4

VAR `key_interp_boolean = 0
VAR `key_interp_by_ref = 1
VAR `key_interp_number = 2
VAR `key_interp_list = 3
VAR `key_interp_module_name = 4
VAR `key_interp_procedure = 5
VAR `key_interp_string = 6

CLASS `Utils:

  METHOD_INIT():
    VAR `x = NULL

  METHOD `deepCopy(`val):
    VAR `val_type = `get_type(`val)
    VAR `arr
    VAR `obj
    VAR `j
    VAR `k
    IF `is_type_list(`val_type):
      `arr = []
      FORINCR `j(0 `length(`val)):
        `push(`arr, THIS.`deepCopy(`val[`j]))
      ENDFOR
      return `arr
    ENDIF
    IF `is_type_dict(`val_type):
      `obj = {}
      FOREACH `k(`val):
        `obj[`k] = THIS.`deepCopy(`val[`k])
      ENDFOR
      return `obj
    ENDIF
    return `val

  METHOD `isValidErrorMessage(`error_message):
    IF `not(`is_type_str(`get_type(`error_message))):
      return FALSE
    ENDIF
    IF `length(`error_message) == 0:
      return FALSE
    ENDIF
    IF `length(`error_message) != `length(`strip(`error_message)):
      return FALSE
    ENDIF
    VAR `j
    VAR `code
    FORINCR `j(0 `length(`error_message)):
      `code = `char_code_at(`error_message, `j)
      IF (`code < 32) OR (`code > 126):
        return FALSE
      ENDIF
    ENDFOR
    return TRUE

  METHOD `isValidArgsSynopsis(`args_synopsis):
    IF `not(`is_type_list(`get_type(`args_synopsis))):
      return FALSE
    ENDIF
    VAR `j
    FORINCR `j(0 `length(`args_synopsis)):
      IF `not(THIS.`isValidErrorMessage(`args_synopsis[`j])):
        return FALSE
      ENDIF
    ENDFOR
    return TRUE

  METHOD `isInt32b(`val):
    return (`is_type_num(`get_type(`val)) AND (`val == `trunc(`val)) AND (`val == `int32(`val)))

  METHOD `isArgData(`arg):
    return (`is_type_list(`get_type(`arg)) AND `length(`arg) == 2 AND `is_type_num(`get_type(`arg[0])) AND `arg[0] >= `ARG_TYPE_NUMBER AND `arg[0] <= `ARG_TYPE_MODNAME)

  METHOD `getNormalizedLimits(`limits_):
    VAR `limits = {}
    `limits[`key_limits_instructions] = NULL
    `limits[`key_limits_memory] = NULL
    `limits[`key_limits_memory_n] = NULL
    `limits[`key_limits_memory_l] = NULL
    IF `is_type_dict(`get_type(`limits_)):
      IF "instructions" in `limits_:
        IF `not(THIS.`isInt32b(`limits_["instructions"])):
          return NULL
        ENDIF
        `limits[`key_limits_instructions] = `limits_["instructions"]
      ENDIF
      IF "memory" in `limits_:
        IF `not(THIS.`isInt32b(`limits_["memory"])):
          return NULL
        ENDIF
        `limits[`key_limits_memory] = `limits_["memory"]
      ENDIF
      IF "memory_n" in `limits_:
        IF `not(THIS.`isInt32b(`limits_["memory_n"])):
          return NULL
        ENDIF
        `limits[`key_limits_memory_n] = `limits_["memory_n"]
      ENDIF
      IF "memory_l" in `limits_:
        IF `not(THIS.`isInt32b(`limits_["memory_l"])):
          return NULL
        ENDIF
        `limits[`key_limits_memory_l] = `limits_["memory_l"]
      ENDIF
    ELSIF `not(`isnull(`limits_)):
      return NULL
    ENDIF
    return `limits

  METHOD `setNormalizedLimits(`limits_):
    VAR `limits = {}
    `limits["instructions"] = `limits_[`key_limits_instructions]
    `limits["max_memory"] = `limits_[`key_limits_max_memory]
    `limits["memory"] = `limits_[`key_limits_memory]
    `limits["memory_n"] = `limits_[`key_limits_memory_n]
    `limits["memory_l"] = `limits_[`key_limits_memory_l]
    return `limits

  METHOD `elemEqElem(`xs `ys):
    VAR `j
    IF `is_type_list(`get_type(`xs)):
      IF `not(`is_type_list(`get_type(`ys))):
        return FALSE
      ENDIF
      IF `length(`xs) != `length(`ys):
        return FALSE
      ENDIF
      FORINCR `j(0 `length(`xs)):
        IF `not(THIS.`elemEqElem(`xs[`j], `ys[`j])):
          return FALSE
        ENDIF
      ENDFOR
      return TRUE
    ENDIF
    IF `is_type_list(`get_type(`ys)):
      return FALSE
    ENDIF
    return (`xs == `ys)

  METHOD `structuralIndexOf(`l `e `from):
    VAR `j
    IF `from >= 0:
      FORINCR `j(`from `length(`l)):
        IF THIS.`elemEqElem(`l[`j], `e):
          return `j
        ENDIF
      ENDFOR
    ELSE:
      FORDECR `j(`length(`l)+`from 0):
        IF THIS.`elemEqElem(`l[`j], `e):
          return `j
        ENDIF
      ENDFOR
    ENDIF
    return -1

  METHOD `nsizeEvalue(`evalue):
    return `evalue[3]

  METHOD `lsizeEvalue(`evalue):
    return `evalue[2]

  METHOD `encodeProcedure(`args_synopsis):
    IF `not(THIS.`isValidArgsSynopsis(`args_synopsis)):
      return NULL
    ENDIF
    return [`key_interp_procedure, THIS.`deepCopy(`args_synopsis)]

  METHOD `encodeData(`data):
    VAR `data_type = `get_type(`data)
    VAR `nsize
    VAR `lsize
    VAR `elist
    VAR `evalue
    IF `is_type_num(`data_type):
      `nsize = 1
      `lsize = 0
      return [`key_interp_number, `data, `lsize, `nsize]
    ENDIF
    VAR `j
    IF `is_type_list(`data_type):
      `nsize = 0
      `lsize = 1
      `elist = []
      FORINCR `j(0 `length(`data)):
        `evalue = THIS.`encodeData(`data[`j])
        IF `isnull(`evalue):
          return NULL
        ENDIF
        `push(`elist, `evalue)
        `nsize += THIS.`nsizeEvalue(`evalue)
        `lsize += THIS.`lsizeEvalue(`evalue)
      ENDFOR
      return [`key_interp_list, `elist, `lsize, `nsize]
    ENDIF
    IF `is_type_bool(`data_type):
      `nsize = 1
      `lsize = 0
      return [`key_interp_number, `fp[0].FromFloat(`data), `lsize, `nsize]
    ENDIF
    `warning("Prequel"+" "+"Utils"+" "+"encodeData"+":"+" "+"invalid"+" "+"data"+":", `data)
    return NULL

  METHOD `encodeOverwriteData(`evalue `data):
    VAR `data_type = `get_type(`data)
    VAR `nsize
    VAR `lsize
    VAR `elist
    VAR `j
    VAR `evalueE
    IF `is_type_num(`data_type):
      IF `length(`evalue) == 0:
        `nsize = 1
        `lsize = 0
        `push(`evalue, `key_interp_number)
        `push(`evalue, `data)
        `push(`evalue, `lsize)
        `push(`evalue, `nsize)
      ELSE:
        IF `evalue[0] != `key_interp_number:
          `nsize = 1
          `lsize = 0
          `evalue[0] = `key_interp_number
          `evalue[2] = `lsize
          `evalue[3] = `nsize
        ENDIF
        `evalue[1] = `data
      ENDIF
      return TRUE
    ENDIF
    IF `is_type_list(`data_type):
      `nsize = 0
      `lsize = 1
      IF `length(`evalue) == 0:
        `elist = []
        FORINCR `j(0 `length(`data)):
          `evalueE = THIS.`encodeData(`data[`j])
          IF `isnull(`evalueE):
            return FALSE
          ENDIF
          `push(`elist, `evalueE)
          `nsize += THIS.`nsizeEvalue(`evalueE)
          `lsize += THIS.`lsizeEvalue(`evalueE)
        ENDFOR
        `push(`evalue, `key_interp_list)
        `push(`evalue, `elist)
        `push(`evalue, `lsize)
        `push(`evalue, `nsize)
      ELSIF `evalue[0] != `key_interp_list:
        `elist = []
        FORINCR `j(0 `length(`data)):
          `evalueE = THIS.`encodeData(`data[`j])
          IF `isnull(`evalueE):
            return FALSE
          ENDIF
          `push(`elist, `evalueE)
          `nsize += THIS.`nsizeEvalue(`evalueE)
          `lsize += THIS.`lsizeEvalue(`evalueE)
        ENDFOR
        `evalue[0] = `key_interp_list
        `evalue[1] = `elist
        `evalue[2] = `lsize
        `evalue[3] = `nsize
      ELSE:
        IF `length(`evalue[1]) == `length(`data):
          FORINCR `j(0 `length(`data)):
            IF `not(THIS.`encodeOverwriteData(`evalue[1][`j], `data[`j])):
              return FALSE
            ENDIF
            `nsize += THIS.`nsizeEvalue(`evalue[1][`j])
            `lsize += THIS.`lsizeEvalue(`evalue[1][`j])
          ENDFOR
        ELSIF `length(`evalue[1]) > `length(`data):
          FORDECR `j(`length(`evalue[1])-`length(`data)-1 0):
            `pick(`evalue[1], `length(`data))
          ENDFOR
          FORINCR `j(0 `length(`data)):
            IF `not(THIS.`encodeOverwriteData(`evalue[1][`j], `data[`j])):
              return FALSE
            ENDIF
            `nsize += THIS.`nsizeEvalue(`evalue[1][`j])
            `lsize += THIS.`lsizeEvalue(`evalue[1][`j])
          ENDFOR
        ELSE:
          FORINCR `j(0 `length(`evalue[1])):
            IF `not(THIS.`encodeOverwriteData(`evalue[1][`j], `data[`j])):
              return FALSE
            ENDIF
            `nsize += THIS.`nsizeEvalue(`evalue[1][`j])
            `lsize += THIS.`lsizeEvalue(`evalue[1][`j])
          ENDFOR
          FORINCR `j(`length(`evalue[1]) `length(`data)):
            `evalueE = THIS.`encodeData(`data[`j])
            IF `isnull(`evalueE):
              return FALSE
            ENDIF
            `push(`evalue[1], `evalueE)
            `nsize += THIS.`nsizeEvalue(`evalueE)
            `lsize += THIS.`lsizeEvalue(`evalueE)
          ENDFOR
        ENDIF
        `evalue[2] = `lsize
        `evalue[3] = `nsize
      ENDIF
      return TRUE
    ENDIF
    IF `is_type_bool(`data_type):
      IF `length(`evalue) == 0:
        `nsize = 1
        `lsize = 0
        `push(`evalue, `key_interp_number)
        `push(`evalue, `fp[0].FromFloat(`data))
        `push(`evalue, `lsize)
        `push(`evalue, `nsize)
      ELSE:
        IF `evalue[0] != `key_interp_number:
          `nsize = 1
          `lsize = 0
          `evalue[0] = `key_interp_number
          `evalue[2] = `lsize
          `evalue[3] = `nsize
        ENDIF
        `evalue[1] = `fp[0].FromFloat(`data)
      ENDIF
      return TRUE
    ENDIF
    `warning("Prequel"+" "+"Utils"+" "+"encodeOverwriteData"+":"+" "+"invalid"+" "+"data"+":", `data)
    return FALSE

  METHOD `decodeData(`edata):
    VAR `dlist
    VAR `j
    VAR `dvalue
    IF `not(`is_type_list(`get_type(`edata))) OR `length(`edata) < 2:
      `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
      return NULL
    ENDIF
    IF `edata[0] == `key_interp_number:
      return [`ARG_TYPE_NUMBER, `edata[1]]
    ENDIF
    IF `edata[0] == `key_interp_list:
      IF `not(`is_type_list(`get_type(`edata[1]))):
        `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
        return NULL
      ENDIF
      `dlist = []
      FORINCR `j(0 `length(`edata[1])):
        `dvalue = THIS.`decodeData(`edata[1][`j])
        IF `isnull(`dvalue):
          return NULL
        ENDIF
        `push(`dlist, `dvalue[1])
      ENDFOR
      return [`ARG_TYPE_LIST, `dlist]
    ENDIF
    IF `edata[0] == `key_interp_by_ref:
      IF `not(`is_type_list(`get_type(`edata[1]))) OR `length(`edata[1]) <= 1:
        `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
        return NULL
      ENDIF
      IF `not(`is_type_str(`get_type(`edata[1][0]))):
        `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
        return NULL
      ENDIF
      IF `not(`isnull(`edata[1][1])) AND `not(`is_type_str(`get_type(`edata[1][1]))):
        `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
        return NULL
      ENDIF
      `dlist = [`edata[1][0], `edata[1][1]]
      FORINCR `j(2 `length(`edata[1])):
        `push(`dlist, `trunc(`edata[1][`j]))
      ENDFOR
      return [`ARG_TYPE_VARNAME, `dlist]
    ENDIF
    IF `edata[0] == `key_interp_module_name:
      IF `not(`is_type_str(`get_type(`edata[1]))):
        `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
        return NULL
      ENDIF
      return [`ARG_TYPE_MODNAME, `edata[1]]
    ENDIF
    IF `edata[0] == `key_interp_string:
      IF `not(`is_type_str(`get_type(`edata[1]))):
        `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
        return NULL
      ENDIF
      return [`ARG_TYPE_STRING, `edata[1]]
    ENDIF
    `warning("Prequel"+" "+"Utils"+" "+"decodeData"+":"+" "+"invalid"+" "+"data"+":", `edata)
    return NULL

  METHOD `stringify(`evalue):
    VAR `lstr
    VAR `j
    IF `isnull(`evalue):
      return "<NULL>"
    ENDIF
    IF `evalue[0] == `key_interp_number:
      return `str(`fp[0].ToFloat(`evalue[1]))
    ENDIF
    IF `evalue[0] == `key_interp_list:
      IF `length(`evalue[1]) == 0:
        return "[]"
      ENDIF
      `lstr = "["
      `lstr += THIS.`stringify(`evalue[1][0])
      FORINCR `j(1 `length(`evalue[1])):
        `lstr += ","+" "+THIS.`stringify(`evalue[1][`j])
      ENDFOR
      `lstr += "]"
      return `lstr
    ENDIF
    IF `evalue[0] == `key_interp_boolean:
      return TERNARY{`evalue[1]}{"<TRUE>"}{"<FALSE>"}
    ENDIF
    IF `evalue[0] == `key_interp_procedure:
      return "<PROCEDURE>"
    ENDIF
    `warning("Prequel"+" "+"Utils"+" "+"stringify"+":"+" "+"unknown"+" "+"value"+":", `evalue)
    return "<UNKNOWN>"

ENDCLASS

VAR `utils = NEW `Utils()

VAR `parse_a_count = 4
VAR `key_parse_a_accept = 0
VAR `key_parse_a_reduce = 1
VAR `key_parse_a_shift = 2
VAR `key_parse_a_goto = 3

VAR `parse_y_count = 144
VAR `key_token__UNKNOWN_ = 0
VAR `key_token_ERROR = 1
VAR `key_token_POSTERROR = 2
VAR `key_token_INDENT = 3
VAR `key_token_SPACES = 4
VAR `key_token_COMMENT = 5
VAR `key_token__END_ = 6
VAR `key_token_NEWLINE = 7
VAR `key_token_ASSIGN_OP = 8
VAR `key_token_POP = 9
VAR `key_token_LPAR = 10
VAR `key_token_RPAR = 11
VAR `key_token_UNQUEUE = 12
VAR `key_token_ASSIGN_OP_INCR = 13
VAR `key_token_ASSIGN_OP_DECR = 14
VAR `key_token_ASSIGN_OP_TOGGLE = 15
VAR `key_token_ASSIGN_OP_PLUS = 16
VAR `key_token_ASSIGN_OP_MINUS = 17
VAR `key_token_ASSIGN_OP_MUL = 18
VAR `key_token_ASSIGN_OP_DIV = 19
VAR `key_token_ASSIGN_OP_MOD = 20
VAR `key_token_ASSIGN_OP_IDV = 21
VAR `key_token_ASSIGN_OP_BIT_AND = 22
VAR `key_token_ASSIGN_OP_BIT_OR = 23
VAR `key_token_ASSIGN_OP_BIT_XOR = 24
VAR `key_token_ASSIGN_OP_BIT_SHL = 25
VAR `key_token_ASSIGN_OP_BIT_SHR = 26
VAR `key_token_ASSIGN_OP_RANDOM = 27
VAR `key_token_RANDOM = 28
VAR `key_token_UNASSIGN = 29
VAR `key_token_PUSH = 30
VAR `key_token_COMMA = 31
VAR `key_token_QUEUE = 32
VAR `key_token_IF = 33
VAR `key_token_ELSIF = 34
VAR `key_token_ELSE = 35
VAR `key_token_ENDIF = 36
VAR `key_token_REPEAT = 37
VAR `key_token_IVAR = 38
VAR `key_token_REPNEXT = 39
VAR `key_token_REPSTOP = 40
VAR `key_token_ENDREP = 41
VAR `key_token_DEBUGL = 42
VAR `key_token_LSQR = 43
VAR `key_token_RSQR = 44
VAR `key_token_OR = 45
VAR `key_token_AND = 46
VAR `key_token_NOT = 47
VAR `key_token_IS = 48
VAR `key_token_IS_NOT = 49
VAR `key_token_EQ = 50
VAR `key_token_NE = 51
VAR `key_token_LT = 52
VAR `key_token_LE = 53
VAR `key_token_GT = 54
VAR `key_token_GE = 55
VAR `key_token_PLUS = 56
VAR `key_token_MINUS = 57
VAR `key_token_MUL = 58
VAR `key_token_DIV = 59
VAR `key_token_MOD = 60
VAR `key_token_IDV = 61
VAR `key_token_BIT_NOT = 62
VAR `key_token_BIT_OR = 63
VAR `key_token_BIT_XOR = 64
VAR `key_token_BIT_AND = 65
VAR `key_token_BIT_SHL = 66
VAR `key_token_BIT_SHR = 67
VAR `key_token_EVAR = 68
VAR `key_token_LENGTH = 69
VAR `key_token_SIZE = 70
VAR `key_token_NSIZE = 71
VAR `key_token_LSIZE = 72
VAR `key_token_INDEXOF = 73
VAR `key_token_DECIMAL = 74
VAR `key_token_BINARY = 75
VAR `key_token_HEXADECIMAL = 76
VAR `key_token_MATH_ABS = 77
VAR `key_token_MATH_ACOS = 78
VAR `key_token_MATH_ASIN = 79
VAR `key_token_MATH_ATAN = 80
VAR `key_token_MATH_ATAN2 = 81
VAR `key_token_MATH_CEIL = 82
VAR `key_token_MATH_COS = 83
VAR `key_token_MATH_E = 84
VAR `key_token_MATH_EXP = 85
VAR `key_token_MATH_EXP2 = 86
VAR `key_token_MATH_FLOOR = 87
VAR `key_token_MATH_LOG = 88
VAR `key_token_MATH_LOG2 = 89
VAR `key_token_MATH_MAX = 90
VAR `key_token_MATH_MIN = 91
VAR `key_token_MATH_PI = 92
VAR `key_token_MATH_POW = 93
VAR `key_token_MATH_ROUND = 94
VAR `key_token_MATH_SIGN = 95
VAR `key_token_MATH_SIN = 96
VAR `key_token_MATH_SQRT = 97
VAR `key_token_MATH_TAN = 98
VAR `key_token_NUMBER = 99
VAR `key_token_LIST = 100
VAR `key_token_EMPTY = 101
VAR `key_token_PROCEDURE = 102
VAR `key_token_UNDEFINED = 103
VAR `key_token_CALL = 104
VAR `key_token_RETURN = 105
VAR `key_token_MODULE_NAME = 106
VAR `key_token_STRING = 107
VAR `key_token_CSVAR = 108
VAR `key_tokennt__ACCEPT = 109
VAR `key_tokennt_prequel_line = 110
VAR `key_tokennt_instruction = 111
VAR `key_tokennt_assignment = 112
VAR `key_tokennt_assignment_random = 113
VAR `key_tokennt_unassign = 114
VAR `key_tokennt_push = 115
VAR `key_tokennt_queue = 116
VAR `key_tokennt_pop = 117
VAR `key_tokennt_unqueue = 118
VAR `key_tokennt_if = 119
VAR `key_tokennt_repeat = 120
VAR `key_tokennt_procedure_call = 121
VAR `key_tokennt_debugl = 122
VAR `key_tokennt_opt_indexes = 123
VAR `key_tokennt_indexes = 124
VAR `key_tokennt_index = 125
VAR `key_tokennt_expr = 126
VAR `key_tokennt_number = 127
VAR `key_tokennt_math_factor = 128
VAR `key_tokennt_opt_expr = 129
VAR `key_tokennt_opt_exprs = 130
VAR `key_tokennt_exprs = 131
VAR `key_tokennt_opt_comma = 132
VAR `key_tokennt_expr_type = 133
VAR `key_tokennt_procedure_name = 134
VAR `key_tokennt_opt_args = 135
VAR `key_tokennt_args = 136
VAR `key_tokennt_arg = 137
VAR `key_tokennt_mvar_ref = 138
VAR `key_tokennt_retvars = 139
VAR `key_tokennt_retvar = 140
VAR `key_tokennt_mvar = 141
VAR `key_tokennt_debugl_args = 142
VAR `key_tokennt_debugl_arg = 143

VAR `parse_y_t_strings = []
`push(`parse_y_t_strings, "_UNKNOWN_")
`push(`parse_y_t_strings, "ERROR")
`push(`parse_y_t_strings, "POSTERROR")
`push(`parse_y_t_strings, "INDENT")
`push(`parse_y_t_strings, "SPACES")
`push(`parse_y_t_strings, "COMMENT")
`push(`parse_y_t_strings, "_END_")
`push(`parse_y_t_strings, "NEWLINE")
`push(`parse_y_t_strings, "ASSIGN_OP")
`push(`parse_y_t_strings, "POP")
`push(`parse_y_t_strings, "LPAR")
`push(`parse_y_t_strings, "RPAR")
`push(`parse_y_t_strings, "UNQUEUE")
`push(`parse_y_t_strings, "ASSIGN_OP_INCR")
`push(`parse_y_t_strings, "ASSIGN_OP_DECR")
`push(`parse_y_t_strings, "ASSIGN_OP_TOGGLE")
`push(`parse_y_t_strings, "ASSIGN_OP_PLUS")
`push(`parse_y_t_strings, "ASSIGN_OP_MINUS")
`push(`parse_y_t_strings, "ASSIGN_OP_MUL")
`push(`parse_y_t_strings, "ASSIGN_OP_DIV")
`push(`parse_y_t_strings, "ASSIGN_OP_MOD")
`push(`parse_y_t_strings, "ASSIGN_OP_IDV")
`push(`parse_y_t_strings, "ASSIGN_OP_BIT_AND")
`push(`parse_y_t_strings, "ASSIGN_OP_BIT_OR")
`push(`parse_y_t_strings, "ASSIGN_OP_BIT_XOR")
`push(`parse_y_t_strings, "ASSIGN_OP_BIT_SHL")
`push(`parse_y_t_strings, "ASSIGN_OP_BIT_SHR")
`push(`parse_y_t_strings, "ASSIGN_OP_RANDOM")
`push(`parse_y_t_strings, "RANDOM")
`push(`parse_y_t_strings, "UNASSIGN")
`push(`parse_y_t_strings, "PUSH")
`push(`parse_y_t_strings, "COMMA")
`push(`parse_y_t_strings, "QUEUE")
`push(`parse_y_t_strings, "IF")
`push(`parse_y_t_strings, "ELSIF")
`push(`parse_y_t_strings, "ELSE")
`push(`parse_y_t_strings, "ENDIF")
`push(`parse_y_t_strings, "REPEAT")
`push(`parse_y_t_strings, "IVAR")
`push(`parse_y_t_strings, "REPNEXT")
`push(`parse_y_t_strings, "REPSTOP")
`push(`parse_y_t_strings, "ENDREP")
`push(`parse_y_t_strings, "DEBUGL")
`push(`parse_y_t_strings, "LSQR")
`push(`parse_y_t_strings, "RSQR")
`push(`parse_y_t_strings, "OR")
`push(`parse_y_t_strings, "AND")
`push(`parse_y_t_strings, "NOT")
`push(`parse_y_t_strings, "IS")
`push(`parse_y_t_strings, "IS_NOT")
`push(`parse_y_t_strings, "EQ")
`push(`parse_y_t_strings, "NE")
`push(`parse_y_t_strings, "LT")
`push(`parse_y_t_strings, "LE")
`push(`parse_y_t_strings, "GT")
`push(`parse_y_t_strings, "GE")
`push(`parse_y_t_strings, "PLUS")
`push(`parse_y_t_strings, "MINUS")
`push(`parse_y_t_strings, "MUL")
`push(`parse_y_t_strings, "DIV")
`push(`parse_y_t_strings, "MOD")
`push(`parse_y_t_strings, "IDV")
`push(`parse_y_t_strings, "BIT_NOT")
`push(`parse_y_t_strings, "BIT_OR")
`push(`parse_y_t_strings, "BIT_XOR")
`push(`parse_y_t_strings, "BIT_AND")
`push(`parse_y_t_strings, "BIT_SHL")
`push(`parse_y_t_strings, "BIT_SHR")
`push(`parse_y_t_strings, "EVAR")
`push(`parse_y_t_strings, "LENGTH")
`push(`parse_y_t_strings, "SIZE")
`push(`parse_y_t_strings, "NSIZE")
`push(`parse_y_t_strings, "LSIZE")
`push(`parse_y_t_strings, "INDEXOF")
`push(`parse_y_t_strings, "DECIMAL")
`push(`parse_y_t_strings, "BINARY")
`push(`parse_y_t_strings, "HEXADECIMAL")
`push(`parse_y_t_strings, "MATH_ABS")
`push(`parse_y_t_strings, "MATH_ACOS")
`push(`parse_y_t_strings, "MATH_ASIN")
`push(`parse_y_t_strings, "MATH_ATAN")
`push(`parse_y_t_strings, "MATH_ATAN2")
`push(`parse_y_t_strings, "MATH_CEIL")
`push(`parse_y_t_strings, "MATH_COS")
`push(`parse_y_t_strings, "MATH_E")
`push(`parse_y_t_strings, "MATH_EXP")
`push(`parse_y_t_strings, "MATH_EXP2")
`push(`parse_y_t_strings, "MATH_FLOOR")
`push(`parse_y_t_strings, "MATH_LOG")
`push(`parse_y_t_strings, "MATH_LOG2")
`push(`parse_y_t_strings, "MATH_MAX")
`push(`parse_y_t_strings, "MATH_MIN")
`push(`parse_y_t_strings, "MATH_PI")
`push(`parse_y_t_strings, "MATH_POW")
`push(`parse_y_t_strings, "MATH_ROUND")
`push(`parse_y_t_strings, "MATH_SIGN")
`push(`parse_y_t_strings, "MATH_SIN")
`push(`parse_y_t_strings, "MATH_SQRT")
`push(`parse_y_t_strings, "MATH_TAN")
`push(`parse_y_t_strings, "NUMBER")
`push(`parse_y_t_strings, "LIST")
`push(`parse_y_t_strings, "EMPTY")
`push(`parse_y_t_strings, "PROCEDURE")
`push(`parse_y_t_strings, "UNDEFINED")
`push(`parse_y_t_strings, "CALL")
`push(`parse_y_t_strings, "RETURN")
`push(`parse_y_t_strings, "MODULE_NAME")
`push(`parse_y_t_strings, "STRING")
`push(`parse_y_t_strings, "CSVAR")

VAR `parse_s_count = 325

VAR `parse_t_count = 6770
VAR `parse_t_entries = []
VAR `parse_t_actions = []
`parse_t_entries = `concat(`parse_t_entries, [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 68, 104, 105, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 134, 139, 140, 141, 206])
`parse_t_actions = `concat(`parse_t_actions, [6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 63, 67, 71, 75, 79, 83, 87, 91, 95, 99, 103, 107, 111, 115, 119, 123, 127, 130])
`parse_t_entries = `concat(`parse_t_entries, [200, 201, 191, 154, 182, 187, 212, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242])
`parse_t_actions = `concat(`parse_t_actions, [134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254])
`parse_t_entries = `concat(`parse_t_entries, [252, 270, 271, 272, 285, 350, 344, 345, 335, 298, 326, 331, 356, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380])
`parse_t_actions = `concat(`parse_t_actions, [58, 259, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230])
`parse_t_entries = `concat(`parse_t_entries, [381, 382, 383, 384, 385, 386, 396, 414, 415, 416, 429, 439, 583, 758, 912, 913, 909, 910, 927, 928, 929, 930, 931, 914, 915, 916, 917, 918, 919, 920, 921, 922])
`parse_t_actions = `concat(`parse_t_actions, [234, 238, 242, 246, 250, 254, 58, 275, 263, 267, 271, 165, 169, 278, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597])
`parse_t_entries = `concat(`parse_t_entries, [923, 924, 925, 871, 872, 873, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 893, 894, 895, 896, 907, 908, 933, 934, 935])
`parse_t_actions = `concat(`parse_t_actions, [597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597])
`parse_t_entries = `concat(`parse_t_entries, [936, 937, 1015, 1159, 1303, 1450, 1594, 1738, 1882, 2064, 2065, 2061, 2062, 2079, 2080, 2081, 2082, 2083, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2023, 2024])
`parse_t_actions = `concat(`parse_t_actions, [597, 597, 177, 181, 185, 282, 537, 541, 545, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601])
`parse_t_entries = `concat(`parse_t_entries, [2025, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2045, 2046, 2047, 2048, 2059, 2060, 2085, 2086, 2087, 2088, 2089, 2166, 2311, 2455])
`parse_t_actions = `concat(`parse_t_actions, [601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 601, 0, 290, 9])
`parse_t_entries = `concat(`parse_t_entries, [2599, 2743, 2887, 3031, 3175, 3319, 3463, 3607, 3751, 3895, 4042, 4184, 4351, 4328, 4452, 4493, 4507, 4472, 4473, 4476, 4477, 4478, 4479, 4480, 4481, 4482, 4483, 4484, 4485, 4486, 4487, 4488])
`parse_t_actions = `concat(`parse_t_actions, [13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 294, 298, 302, 509, 307, 310, 314, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [4489, 4490, 4491, 4494, 4495, 4496, 4587, 4588, 4589, 4670, 4664, 4665, 4655, 4618, 4646, 4651, 4676, 4682, 4683, 4684, 4685, 4686, 4687, 4688, 4689, 4690, 4691, 4692, 4693, 4694, 4695, 4696])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 319, 323, 327, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214])
`parse_t_entries = `concat(`parse_t_entries, [4697, 4698, 4699, 4700, 4701, 4702, 4703, 4704, 4705, 4706, 4716, 4734, 4735, 4736, 4749, 4814, 4808, 4809, 4799, 4762, 4790, 4795, 4820, 4826, 4827, 4828, 4829, 4830, 4831, 4832, 4833, 4834])
`parse_t_actions = `concat(`parse_t_actions, [218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 331, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190])
`parse_t_entries = `concat(`parse_t_entries, [4835, 4836, 4837, 4838, 4839, 4840, 4841, 4842, 4843, 4844, 4845, 4846, 4847, 4848, 4849, 4850, 4860, 4878, 4879, 4880, 4893, 4958, 4952, 4953, 4943, 4906, 4934, 4939, 4964, 4970, 4971, 4972])
`parse_t_actions = `concat(`parse_t_actions, [194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 335, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166])
`parse_t_entries = `concat(`parse_t_entries, [4973, 4974, 4975, 4976, 4977, 4978, 4979, 4980, 4981, 4982, 4983, 4984, 4985, 4986, 4987, 4988, 4989, 4990, 4991, 4992, 4993, 4994, 5004, 5022, 5023, 5024, 5037, 5102, 5096, 5097, 5087, 5050])
`parse_t_actions = `concat(`parse_t_actions, [170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 339, 263, 267, 271, 130, 134, 138, 142, 146])
`parse_t_entries = `concat(`parse_t_entries, [5078, 5083, 5108, 5114, 5115, 5116, 5117, 5118, 5119, 5120, 5121, 5122, 5123, 5124, 5125, 5126, 5127, 5128, 5129, 5130, 5131, 5132, 5133, 5134, 5135, 5136, 5137, 5138, 5148, 5166, 5167, 5168])
`parse_t_actions = `concat(`parse_t_actions, [26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 343, 263, 267])
`parse_t_entries = `concat(`parse_t_entries, [5181, 5246, 5240, 5241, 5231, 5194, 5222, 5227, 5252, 5258, 5259, 5260, 5261, 5262, 5263, 5264, 5265, 5266, 5267, 5268, 5269, 5270, 5271, 5272, 5273, 5274, 5275, 5276, 5277, 5278, 5279, 5280])
`parse_t_actions = `concat(`parse_t_actions, [271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246])
`parse_t_entries = `concat(`parse_t_entries, [5281, 5282, 5292, 5310, 5311, 5312, 5325, 5390, 5384, 5385, 5375, 5338, 5366, 5371, 5396, 5402, 5403, 5404, 5405, 5406, 5407, 5408, 5409, 5410, 5411, 5412, 5413, 5414, 5415, 5416, 5417, 5418])
`parse_t_actions = `concat(`parse_t_actions, [250, 254, 58, 347, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222])
`parse_t_entries = `concat(`parse_t_entries, [5419, 5420, 5421, 5422, 5423, 5424, 5425, 5426, 5436, 5372, 5454, 5455, 5456, 5458, 5459, 5469, 5515, 5520, 5521, 5517, 5518, 5535, 5536, 5537, 5538, 5539, 5522, 5523, 5524, 5525, 5526, 5527])
`parse_t_actions = `concat(`parse_t_actions, [226, 230, 234, 238, 242, 246, 250, 254, 58, 493, 351, 263, 267, 355, 359, 271, 314, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [5528, 5529, 5530, 5531, 5532, 5533, 5479, 5483, 5503, 5516, 5541, 5542, 5543, 5544, 5545, 5595, 5596, 5597, 5664, 5665, 5661, 5662, 5679, 5680, 5681, 5682, 5683, 5666, 5667, 5668, 5669, 5670])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 363, 323, 327, 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, 385])
`parse_t_entries = `concat(`parse_t_entries, [5671, 5672, 5673, 5674, 5675, 5676, 5677, 5623, 5627, 5647, 5660, 5808, 5809, 5805, 5806, 5823, 5824, 5825, 5826, 5827, 5810, 5811, 5812, 5813, 5814, 5815, 5816, 5817, 5818, 5819, 5820, 5821])
`parse_t_actions = `concat(`parse_t_actions, [385, 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389])
`parse_t_entries = `concat(`parse_t_entries, [5767, 5771, 5791, 5804, 5952, 5953, 5949, 5950, 5967, 5968, 5969, 5970, 5971, 5954, 5955, 5956, 5957, 5958, 5959, 5960, 5961, 5962, 5963, 5964, 5965, 5911, 5915, 5935, 5948, 6058, 6202, 6346])
`parse_t_actions = `concat(`parse_t_actions, [389, 389, 389, 389, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 366, 370, 374])
`parse_t_entries = `concat(`parse_t_entries, [6490, 6634, 6778, 6922, 7104, 7105, 7101, 7102, 7119, 7120, 7121, 7122, 7123, 7106, 7107, 7108, 7109, 7110, 7111, 7112, 7113, 7114, 7115, 7116, 7117, 7063, 7067, 7087, 7100, 7210, 7354, 7498])
`parse_t_actions = `concat(`parse_t_actions, [378, 382, 386, 390, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 425, 394, 398, 402])
`parse_t_entries = `concat(`parse_t_entries, [7642, 7786, 7930, 8074, 8256, 8257, 8253, 8254, 8271, 8272, 8273, 8274, 8275, 8258, 8259, 8260, 8261, 8262, 8263, 8264, 8265, 8266, 8267, 8268, 8269, 8215, 8219, 8239, 8252, 8362, 8506, 8650])
`parse_t_actions = `concat(`parse_t_actions, [406, 410, 414, 418, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 457, 422, 426, 430])
`parse_t_entries = `concat(`parse_t_entries, [8794, 8938, 9082, 9264, 9265, 9261, 9262, 9279, 9280, 9281, 9282, 9283, 9266, 9267, 9268, 9269, 9270, 9271, 9272, 9273, 9274, 9275, 9276, 9277, 9223, 9408, 9409, 9405, 9406, 9423, 9424, 9425])
`parse_t_actions = `concat(`parse_t_actions, [434, 438, 442, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 157, 321, 321, 321, 321, 321, 321, 321])
`parse_t_entries = `concat(`parse_t_entries, [9426, 9427, 9410, 9411, 9412, 9413, 9414, 9415, 9416, 9417, 9418, 9419, 9420, 9421, 9367, 9371, 9391, 9404, 9552, 9553, 9549, 9550, 9567, 9568, 9569, 9570, 9571, 9554, 9555, 9556, 9557, 9558])
`parse_t_actions = `concat(`parse_t_actions, [321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 321, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381])
`parse_t_entries = `concat(`parse_t_entries, [9559, 9560, 9561, 9562, 9563, 9564, 9565, 9511, 9515, 9535, 9548, 9691, 9696, 9697, 9693, 9694, 9711, 9712, 9713, 9714, 9715, 9698, 9699, 9700, 9701, 9702, 9703, 9704, 9705, 9706, 9707, 9708])
`parse_t_actions = `concat(`parse_t_actions, [381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 314, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [9709, 9655, 9659, 9679, 9692, 9717, 9718, 9719, 9720, 9721, 9771, 9772, 9773, 9840, 9841, 9837, 9838, 9855, 9856, 9857, 9858, 9859, 9842, 9843, 9844, 9845, 9846, 9847, 9848, 9849, 9850, 9851])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 531, 323, 327, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518])
`parse_t_entries = `concat(`parse_t_entries, [9852, 9853, 9799, 9943, 10142, 10136, 10137, 10127, 10090, 10118, 10123, 10148, 10154, 10155, 10156, 10157, 10158, 10159, 10160, 10161, 10162, 10163, 10164, 10165, 10166, 10167, 10168, 10169, 10170, 10171, 10172, 10173])
`parse_t_actions = `concat(`parse_t_actions, [522, 526, 161, 173, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234])
`parse_t_entries = `concat(`parse_t_entries, [10174, 10175, 10176, 10177, 10178, 10187, 10188, 10206, 10207, 10208, 10221, 10222, 10223, 10374, 10577, 10574, 10568, 10569, 10559, 10522, 10550, 10555, 10580, 10586, 10587, 10588, 10589, 10590, 10591, 10592, 10593, 10594])
`parse_t_actions = `concat(`parse_t_actions, [238, 242, 246, 250, 254, 534, 58, 539, 263, 267, 271, 543, 547, 5, 550, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190])
`parse_t_entries = `concat(`parse_t_entries, [10595, 10596, 10597, 10598, 10599, 10600, 10601, 10602, 10603, 10604, 10605, 10606, 10607, 10608, 10609, 10610, 10618, 10619, 10620, 10523, 10638, 10639, 10640, 10647, 10648, 10649, 10650, 10653, 10718, 10712, 10713, 10703])
`parse_t_actions = `concat(`parse_t_actions, [194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 554, 558, 58, 549, 563, 263, 267, 567, 571, 575, 579, 271, 130, 134, 138, 142])
`parse_t_entries = `concat(`parse_t_entries, [10666, 10694, 10699, 10724, 10730, 10731, 10732, 10733, 10734, 10735, 10736, 10737, 10738, 10739, 10740, 10741, 10742, 10743, 10744, 10745, 10746, 10747, 10748, 10749, 10750, 10751, 10752, 10753, 10754, 10760, 10761, 10764])
`parse_t_actions = `concat(`parse_t_actions, [146, 26, 150, 582, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 50, 54, 58])
`parse_t_entries = `concat(`parse_t_entries, [10782, 10783, 10784, 10790, 10797, 10838, 10908, 10808, 10939, 10940, 10941, 10952, 11095, 11294, 11288, 11289, 11279, 11242, 11270, 11275, 11300, 11306, 11307, 11308, 11309, 11310, 11311, 11312, 11313, 11314, 11315, 11316])
`parse_t_actions = `concat(`parse_t_actions, [587, 263, 267, 591, 595, 26, 58, 513, 599, 123, 603, 585, 133, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198])
`parse_t_entries = `concat(`parse_t_entries, [11317, 11318, 11319, 11320, 11321, 11322, 11323, 11324, 11325, 11326, 11327, 11328, 11329, 11330, 11340, 11358, 11359, 11360, 11373, 11385, 11388, 11389, 11390, 11391, 11392, 11393, 11394, 11395, 11396, 11397, 11398, 11399])
`parse_t_actions = `concat(`parse_t_actions, [202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 607, 263, 267, 271, 610, 614, 618, 622, 626, 630, 634, 638, 642, 646, 650, 654, 658])
`parse_t_entries = `concat(`parse_t_entries, [11400, 11401, 11402, 11403, 11406, 11408, 11384, 11407, 11568, 11569, 11565, 11566, 11583, 11584, 11585, 11586, 11587, 11570, 11571, 11572, 11573, 11574, 11575, 11576, 11577, 11578, 11579, 11580, 11581, 11527, 11528, 11529])
`parse_t_actions = `concat(`parse_t_actions, [662, 666, 670, 674, 678, 682, 593, 593, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201])
`parse_t_entries = `concat(`parse_t_entries, [11531, 11532, 11533, 11534, 11535, 11536, 11537, 11538, 11539, 11540, 11541, 11542, 11543, 11544, 11545, 11546, 11547, 11550, 11551, 11552, 11564, 11589, 11590, 11591, 11592, 11593, 11707, 11712, 11713, 11709, 11710, 11727])
`parse_t_actions = `concat(`parse_t_actions, [201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 201, 314, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [11728, 11729, 11730, 11731, 11714, 11715, 11716, 11717, 11718, 11719, 11720, 11721, 11722, 11723, 11724, 11725, 11671, 11672, 11673, 11675, 11676, 11677, 11678, 11679, 11680, 11681, 11682, 11683, 11684, 11685, 11686, 11687])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [11688, 11689, 11690, 11691, 11694, 11695, 11696, 11708, 11733, 11734, 11735, 11736, 11737, 11787, 11788, 11789, 11874, 11875, 11858, 11859, 11860, 11861, 11862, 11863, 11864, 11865, 11866, 11867, 11868, 11869, 11856, 11857])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 687, 323, 327, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 285, 285])
`parse_t_entries = `concat(`parse_t_entries, [11853, 11854, 11871, 11872, 11873, 11815, 11819, 11839, 11852, 12000, 12001, 11997, 11998, 12015, 12016, 12017, 12018, 12019, 12002, 12003, 12004, 12005, 12006, 12007, 12008, 12009, 12010, 12011, 12012, 12013, 11959, 11963])
`parse_t_actions = `concat(`parse_t_actions, [285, 285, 285, 285, 285, 285, 285, 285, 285, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313, 313])
`parse_t_entries = `concat(`parse_t_entries, [11983, 11996, 12144, 12145, 12141, 12142, 12159, 12160, 12161, 12162, 12163, 12146, 12147, 12148, 12149, 12150, 12151, 12152, 12153, 12154, 12155, 12156, 12157, 12103, 12107, 12127, 12140, 12288, 12289, 12285, 12286, 12303])
`parse_t_actions = `concat(`parse_t_actions, [313, 313, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 309, 225, 225, 225, 225, 225])
`parse_t_entries = `concat(`parse_t_entries, [12304, 12305, 12306, 12307, 12290, 12291, 12292, 12293, 12294, 12295, 12296, 12297, 12298, 12299, 12300, 12301, 12247, 12251, 12271, 12284, 12432, 12433, 12429, 12430, 12447, 12448, 12449, 12450, 12451, 12434, 12435, 12436])
`parse_t_actions = `concat(`parse_t_actions, [225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 225, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490])
`parse_t_entries = `concat(`parse_t_entries, [12437, 12438, 12439, 12440, 12441, 12442, 12443, 12444, 12445, 12395, 12576, 12577, 12573, 12574, 12591, 12592, 12593, 12594, 12595, 12578, 12579, 12580, 12581, 12582, 12583, 12584, 12585, 12586, 12587, 12588, 12589, 12559])
`parse_t_actions = `concat(`parse_t_actions, [494, 498, 502, 506, 510, 514, 518, 522, 526, 690, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 694])
`parse_t_entries = `concat(`parse_t_entries, [12572, 12660, 12716, 12860, 13029, 13030, 13031, 13032, 13033, 13008, 13009, 13005, 13006, 13023, 13024, 13025, 13026, 13027, 13010, 13011, 13012, 13013, 13014, 13015, 13016, 13017, 13018, 13019, 13020, 13021, 12967, 12971])
`parse_t_actions = `concat(`parse_t_actions, [509, 699, 702, 497, 706, 710, 714, 718, 722, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325, 325])
`parse_t_entries = `concat(`parse_t_entries, [12991, 13004, 13166, 13160, 13161, 13151, 13114, 13142, 13147, 13172, 13178, 13179, 13180, 13181, 13182, 13183, 13184, 13185, 13186, 13187, 13188, 13189, 13190, 13191, 13192, 13193, 13194, 13195, 13196, 13197, 13198, 13199])
`parse_t_actions = `concat(`parse_t_actions, [325, 325, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242])
`parse_t_entries = `concat(`parse_t_entries, [13200, 13201, 13202, 13212, 13230, 13231, 13232, 13245, 13310, 13304, 13305, 13295, 13258, 13286, 13291, 13316, 13322, 13323, 13324, 13325, 13326, 13327, 13328, 13329, 13330, 13331, 13332, 13333, 13334, 13335, 13336, 13337])
`parse_t_actions = `concat(`parse_t_actions, [246, 250, 254, 58, 727, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218])
`parse_t_entries = `concat(`parse_t_entries, [13338, 13339, 13340, 13341, 13342, 13343, 13344, 13345, 13346, 13356, 13374, 13375, 13376, 13389, 13454, 13448, 13449, 13439, 13402, 13430, 13435, 13460, 13466, 13467, 13468, 13469, 13470, 13471, 13472, 13473, 13474, 13475])
`parse_t_actions = `concat(`parse_t_actions, [222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 731, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194])
`parse_t_entries = `concat(`parse_t_entries, [13476, 13477, 13478, 13479, 13480, 13481, 13482, 13483, 13484, 13485, 13486, 13487, 13488, 13489, 13490, 13500, 13518, 13519, 13520, 13533, 13598, 13592, 13593, 13583, 13546, 13574, 13579, 13604, 13610, 13611, 13612, 13613])
`parse_t_actions = `concat(`parse_t_actions, [198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 735, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170])
`parse_t_entries = `concat(`parse_t_entries, [13614, 13615, 13616, 13617, 13618, 13619, 13620, 13621, 13622, 13623, 13624, 13625, 13626, 13627, 13628, 13629, 13630, 13631, 13632, 13633, 13634, 13644, 13662, 13663, 13664, 13677, 13742, 13736, 13737, 13727, 13690, 13718])
`parse_t_actions = `concat(`parse_t_actions, [174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 739, 263, 267, 271, 130, 134, 138, 142, 146, 26])
`parse_t_entries = `concat(`parse_t_entries, [13723, 13748, 13754, 13755, 13756, 13757, 13758, 13759, 13760, 13761, 13762, 13763, 13764, 13765, 13766, 13767, 13768, 13769, 13770, 13771, 13772, 13773, 13774, 13775, 13776, 13777, 13778, 13788, 13806, 13807, 13808, 13821])
`parse_t_actions = `concat(`parse_t_actions, [150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 743, 263, 267, 271])
`parse_t_entries = `concat(`parse_t_entries, [13886, 13880, 13881, 13871, 13834, 13862, 13867, 13892, 13898, 13899, 13900, 13901, 13902, 13903, 13904, 13905, 13906, 13907, 13908, 13909, 13910, 13911, 13912, 13913, 13914, 13915, 13916, 13917, 13918, 13919, 13920, 13921])
`parse_t_actions = `concat(`parse_t_actions, [130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250])
`parse_t_entries = `concat(`parse_t_entries, [13922, 13932, 13950, 13951, 13952, 13965, 14030, 14024, 14025, 14015, 13978, 14006, 14011, 14036, 14042, 14043, 14044, 14045, 14046, 14047, 14048, 14049, 14050, 14051, 14052, 14053, 14054, 14055, 14056, 14057, 14058, 14059])
`parse_t_actions = `concat(`parse_t_actions, [254, 58, 747, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226])
`parse_t_entries = `concat(`parse_t_entries, [14060, 14061, 14062, 14063, 14064, 14065, 14066, 14076, 14094, 14095, 14096, 14109, 14174, 14168, 14169, 14159, 14122, 14150, 14155, 14180, 14186, 14187, 14188, 14189, 14190, 14191, 14192, 14193, 14194, 14195, 14196, 14197])
`parse_t_actions = `concat(`parse_t_actions, [230, 234, 238, 242, 246, 250, 254, 58, 751, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202])
`parse_t_entries = `concat(`parse_t_entries, [14198, 14199, 14200, 14201, 14202, 14203, 14204, 14205, 14206, 14207, 14208, 14209, 14210, 14220, 14238, 14239, 14240, 14253, 14318, 14312, 14313, 14303, 14266, 14294, 14299, 14324, 14330, 14331, 14332, 14333, 14334, 14335])
`parse_t_actions = `concat(`parse_t_actions, [206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 755, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178])
`parse_t_entries = `concat(`parse_t_entries, [14336, 14337, 14338, 14339, 14340, 14341, 14342, 14343, 14344, 14345, 14346, 14347, 14348, 14349, 14350, 14351, 14352, 14353, 14354, 14364, 14382, 14383, 14384, 14397, 14462, 14456, 14457, 14447, 14410, 14438, 14443, 14468])
`parse_t_actions = `concat(`parse_t_actions, [182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 759, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154])
`parse_t_entries = `concat(`parse_t_entries, [14474, 14475, 14476, 14477, 14478, 14479, 14480, 14481, 14482, 14483, 14484, 14485, 14486, 14487, 14488, 14489, 14490, 14491, 14492, 14493, 14494, 14495, 14496, 14497, 14498, 14508, 14526, 14527, 14528, 14541, 14606, 14600])
`parse_t_actions = `concat(`parse_t_actions, [158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 763, 263, 267, 271, 130, 134])
`parse_t_entries = `concat(`parse_t_entries, [14601, 14591, 14554, 14582, 14587, 14612, 14618, 14619, 14620, 14621, 14622, 14623, 14624, 14625, 14626, 14627, 14628, 14629, 14630, 14631, 14632, 14633, 14634, 14635, 14636, 14637, 14638, 14639, 14640, 14641, 14642, 14652])
`parse_t_actions = `concat(`parse_t_actions, [138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58])
`parse_t_entries = `concat(`parse_t_entries, [14670, 14671, 14672, 14685, 14750, 14744, 14745, 14735, 14698, 14726, 14731, 14756, 14762, 14763, 14764, 14765, 14766, 14767, 14768, 14769, 14770, 14771, 14772, 14773, 14774, 14775, 14776, 14777, 14778, 14779, 14780, 14781])
`parse_t_actions = `concat(`parse_t_actions, [767, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234])
`parse_t_entries = `concat(`parse_t_entries, [14782, 14783, 14784, 14785, 14786, 14796, 14814, 14815, 14816, 14829, 14894, 14888, 14889, 14879, 14842, 14870, 14875, 14900, 14906, 14907, 14908, 14909, 14910, 14911, 14912, 14913, 14914, 14915, 14916, 14917, 14918, 14919])
`parse_t_actions = `concat(`parse_t_actions, [238, 242, 246, 250, 254, 58, 771, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210])
`parse_t_entries = `concat(`parse_t_entries, [14920, 14921, 14922, 14923, 14924, 14925, 14926, 14927, 14928, 14929, 14930, 14940, 14958, 14959, 14960, 14973, 15038, 15032, 15033, 15023, 14986, 15014, 15019, 15044, 15050, 15051, 15052, 15053, 15054, 15055, 15056, 15057])
`parse_t_actions = `concat(`parse_t_actions, [214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 775, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186])
`parse_t_entries = `concat(`parse_t_entries, [15058, 15059, 15060, 15061, 15062, 15063, 15064, 15065, 15066, 15067, 15068, 15069, 15070, 15071, 15072, 15073, 15074, 15084, 15102, 15103, 15104, 15117, 15182, 15176, 15177, 15167, 15130, 15158, 15163, 15188, 15194, 15195])
`parse_t_actions = `concat(`parse_t_actions, [190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 779, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162])
`parse_t_entries = `concat(`parse_t_entries, [15196, 15197, 15198, 15199, 15200, 15201, 15202, 15203, 15204, 15205, 15206, 15207, 15208, 15209, 15210, 15211, 15212, 15213, 15214, 15215, 15216, 15217, 15218, 15228, 15246, 15247, 15248, 15261, 15326, 15320, 15321, 15311])
`parse_t_actions = `concat(`parse_t_actions, [166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 783, 263, 267, 271, 130, 134, 138, 142])
`parse_t_entries = `concat(`parse_t_entries, [15274, 15302, 15307, 15332, 15338, 15339, 15340, 15341, 15342, 15343, 15344, 15345, 15346, 15347, 15348, 15349, 15350, 15351, 15352, 15353, 15354, 15355, 15356, 15357, 15358, 15359, 15360, 15361, 15362, 15372, 15390, 15391])
`parse_t_actions = `concat(`parse_t_actions, [146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 787, 263])
`parse_t_entries = `concat(`parse_t_entries, [15392, 15405, 15470, 15464, 15465, 15455, 15418, 15446, 15451, 15476, 15482, 15483, 15484, 15485, 15486, 15487, 15488, 15489, 15490, 15491, 15492, 15493, 15494, 15495, 15496, 15497, 15498, 15499, 15500, 15501, 15502, 15503])
`parse_t_actions = `concat(`parse_t_actions, [267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242])
`parse_t_entries = `concat(`parse_t_entries, [15504, 15505, 15506, 15516, 15534, 15535, 15536, 15549, 15614, 15608, 15609, 15599, 15562, 15590, 15595, 15620, 15626, 15627, 15628, 15629, 15630, 15631, 15632, 15633, 15634, 15635, 15636, 15637, 15638, 15639, 15640, 15641])
`parse_t_actions = `concat(`parse_t_actions, [246, 250, 254, 58, 791, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218])
`parse_t_entries = `concat(`parse_t_entries, [15642, 15643, 15644, 15645, 15646, 15647, 15648, 15649, 15650, 15660, 15678, 15679, 15680, 15693, 15758, 15752, 15753, 15743, 15706, 15734, 15739, 15764, 15770, 15771, 15772, 15773, 15774, 15775, 15776, 15777, 15778, 15779])
`parse_t_actions = `concat(`parse_t_actions, [222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 795, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194])
`parse_t_entries = `concat(`parse_t_entries, [15780, 15781, 15782, 15783, 15784, 15785, 15786, 15787, 15788, 15789, 15790, 15791, 15792, 15793, 15794, 15804, 15822, 15823, 15824, 15837, 15902, 15896, 15897, 15887, 15850, 15878, 15883, 15908, 15914, 15915, 15916, 15917])
`parse_t_actions = `concat(`parse_t_actions, [198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 799, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170])
`parse_t_entries = `concat(`parse_t_entries, [15918, 15919, 15920, 15921, 15922, 15923, 15924, 15925, 15926, 15927, 15928, 15929, 15930, 15931, 15932, 15933, 15934, 15935, 15936, 15937, 15938, 15948, 15966, 15967, 15968, 15981, 16083, 16084, 16085, 16086, 16087, 16117])
`parse_t_actions = `concat(`parse_t_actions, [174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 803, 263, 267, 271, 806, 810, 814, 818, 822, 827])
`parse_t_entries = `concat(`parse_t_entries, [16227, 16228, 16229, 16230, 16231, 16261, 16334, 16328, 16329, 16319, 16282, 16310, 16315, 16340, 16346, 16347, 16348, 16349, 16350, 16351, 16352, 16353, 16354, 16355, 16356, 16357, 16358, 16359, 16360, 16361, 16362, 16363])
`parse_t_actions = `concat(`parse_t_actions, [806, 810, 814, 818, 822, 831, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226])
`parse_t_entries = `concat(`parse_t_entries, [16364, 16365, 16366, 16367, 16368, 16369, 16370, 16380, 16398, 16399, 16400, 16413, 16478, 16472, 16473, 16463, 16426, 16454, 16459, 16484, 16490, 16491, 16492, 16493, 16494, 16495, 16496, 16497, 16498, 16499, 16500, 16501])
`parse_t_actions = `concat(`parse_t_actions, [230, 234, 238, 242, 246, 250, 254, 58, 835, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202])
`parse_t_entries = `concat(`parse_t_entries, [16502, 16503, 16504, 16505, 16506, 16507, 16508, 16509, 16510, 16511, 16512, 16513, 16514, 16524, 16542, 16543, 16544, 16557, 16622, 16616, 16617, 16607, 16570, 16598, 16603, 16628, 16634, 16635, 16636, 16637, 16638, 16639])
`parse_t_actions = `concat(`parse_t_actions, [206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 839, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178])
`parse_t_entries = `concat(`parse_t_entries, [16640, 16641, 16642, 16643, 16644, 16645, 16646, 16647, 16648, 16649, 16650, 16651, 16652, 16653, 16654, 16655, 16656, 16657, 16658, 16668, 16686, 16687, 16688, 16701, 16766, 16760, 16761, 16751, 16714, 16742, 16747, 16772])
`parse_t_actions = `concat(`parse_t_actions, [182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 843, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154])
`parse_t_entries = `concat(`parse_t_entries, [16778, 16779, 16780, 16781, 16782, 16783, 16784, 16785, 16786, 16787, 16788, 16789, 16790, 16791, 16792, 16793, 16794, 16795, 16796, 16797, 16798, 16799, 16800, 16801, 16802, 16812, 16830, 16831, 16832, 16845, 16910, 16904])
`parse_t_actions = `concat(`parse_t_actions, [158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 847, 263, 267, 271, 130, 134])
`parse_t_entries = `concat(`parse_t_entries, [16905, 16895, 16858, 16886, 16891, 16916, 16922, 16923, 16924, 16925, 16926, 16927, 16928, 16929, 16930, 16931, 16932, 16933, 16934, 16935, 16936, 16937, 16938, 16939, 16940, 16941, 16942, 16943, 16944, 16945, 16946, 16956])
`parse_t_actions = `concat(`parse_t_actions, [138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58])
`parse_t_entries = `concat(`parse_t_entries, [16974, 16975, 16976, 16989, 17054, 17048, 17049, 17039, 17002, 17030, 17035, 17060, 17066, 17067, 17068, 17069, 17070, 17071, 17072, 17073, 17074, 17075, 17076, 17077, 17078, 17079, 17080, 17081, 17082, 17083, 17084, 17085])
`parse_t_actions = `concat(`parse_t_actions, [851, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234])
`parse_t_entries = `concat(`parse_t_entries, [17086, 17087, 17088, 17089, 17090, 17100, 17118, 17119, 17120, 17133, 17198, 17192, 17193, 17183, 17146, 17174, 17179, 17204, 17210, 17211, 17212, 17213, 17214, 17215, 17216, 17217, 17218, 17219, 17220, 17221, 17222, 17223])
`parse_t_actions = `concat(`parse_t_actions, [238, 242, 246, 250, 254, 58, 855, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210])
`parse_t_entries = `concat(`parse_t_entries, [17224, 17225, 17226, 17227, 17228, 17229, 17230, 17231, 17232, 17233, 17234, 17244, 17262, 17263, 17264, 17277, 17342, 17336, 17337, 17327, 17290, 17318, 17323, 17348, 17354, 17355, 17356, 17357, 17358, 17359, 17360, 17361])
`parse_t_actions = `concat(`parse_t_actions, [214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 859, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186])
`parse_t_entries = `concat(`parse_t_entries, [17362, 17363, 17364, 17365, 17366, 17367, 17368, 17369, 17370, 17371, 17372, 17373, 17374, 17375, 17376, 17377, 17378, 17388, 17406, 17407, 17408, 17421, 17486, 17480, 17481, 17471, 17434, 17462, 17467, 17492, 17498, 17499])
`parse_t_actions = `concat(`parse_t_actions, [190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 863, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162])
`parse_t_entries = `concat(`parse_t_entries, [17500, 17501, 17502, 17503, 17504, 17505, 17506, 17507, 17508, 17509, 17510, 17511, 17512, 17513, 17514, 17515, 17516, 17517, 17518, 17519, 17520, 17521, 17522, 17532, 17550, 17551, 17552, 17565, 17630, 17624, 17625, 17615])
`parse_t_actions = `concat(`parse_t_actions, [166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 867, 263, 267, 271, 130, 134, 138, 142])
`parse_t_entries = `concat(`parse_t_entries, [17578, 17606, 17611, 17636, 17642, 17643, 17644, 17645, 17646, 17647, 17648, 17649, 17650, 17651, 17652, 17653, 17654, 17655, 17656, 17657, 17658, 17659, 17660, 17661, 17662, 17663, 17664, 17665, 17666, 17676, 17694, 17695])
`parse_t_actions = `concat(`parse_t_actions, [146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 871, 263])
`parse_t_entries = `concat(`parse_t_entries, [17696, 17709, 17774, 17768, 17769, 17759, 17722, 17750, 17755, 17780, 17786, 17787, 17788, 17789, 17790, 17791, 17792, 17793, 17794, 17795, 17796, 17797, 17798, 17799, 17800, 17801, 17802, 17803, 17804, 17805, 17806, 17807])
`parse_t_actions = `concat(`parse_t_actions, [267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242])
`parse_t_entries = `concat(`parse_t_entries, [17808, 17809, 17810, 17820, 17838, 17839, 17840, 17853, 17918, 17912, 17913, 17903, 17866, 17894, 17899, 17924, 17930, 17931, 17932, 17933, 17934, 17935, 17936, 17937, 17938, 17939, 17940, 17941, 17942, 17943, 17944, 17945])
`parse_t_actions = `concat(`parse_t_actions, [246, 250, 254, 58, 875, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218])
`parse_t_entries = `concat(`parse_t_entries, [17946, 17947, 17948, 17949, 17950, 17951, 17952, 17953, 17954, 17964, 17982, 17983, 17984, 17997, 18062, 18056, 18057, 18047, 18010, 18038, 18043, 18068, 18074, 18075, 18076, 18077, 18078, 18079, 18080, 18081, 18082, 18083])
`parse_t_actions = `concat(`parse_t_actions, [222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 879, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194])
`parse_t_entries = `concat(`parse_t_entries, [18084, 18085, 18086, 18087, 18088, 18089, 18090, 18091, 18092, 18093, 18094, 18095, 18096, 18097, 18098, 18108, 18126, 18127, 18128, 18141, 18206, 18200, 18201, 18191, 18154, 18182, 18187, 18212, 18218, 18219, 18220, 18221])
`parse_t_actions = `concat(`parse_t_actions, [198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 883, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170])
`parse_t_entries = `concat(`parse_t_entries, [18222, 18223, 18224, 18225, 18226, 18227, 18228, 18229, 18230, 18231, 18232, 18233, 18234, 18235, 18236, 18237, 18238, 18239, 18240, 18241, 18242, 18252, 18270, 18271, 18272, 18285, 18350, 18344, 18345, 18335, 18298, 18326])
`parse_t_actions = `concat(`parse_t_actions, [174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 887, 263, 267, 271, 130, 134, 138, 142, 146, 26])
`parse_t_entries = `concat(`parse_t_entries, [18331, 18356, 18362, 18363, 18364, 18365, 18366, 18367, 18368, 18369, 18370, 18371, 18372, 18373, 18374, 18375, 18376, 18377, 18378, 18379, 18380, 18381, 18382, 18383, 18384, 18385, 18386, 18396, 18414, 18415, 18416, 18429])
`parse_t_actions = `concat(`parse_t_actions, [150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 891, 263, 267, 271])
`parse_t_entries = `concat(`parse_t_entries, [18494, 18488, 18489, 18479, 18442, 18470, 18475, 18500, 18506, 18507, 18508, 18509, 18510, 18511, 18512, 18513, 18514, 18515, 18516, 18517, 18518, 18519, 18520, 18521, 18522, 18523, 18524, 18525, 18526, 18527, 18528, 18529])
`parse_t_actions = `concat(`parse_t_actions, [130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250])
`parse_t_entries = `concat(`parse_t_entries, [18530, 18540, 18558, 18559, 18560, 18573, 18638, 18632, 18633, 18623, 18586, 18614, 18619, 18644, 18650, 18651, 18652, 18653, 18654, 18655, 18656, 18657, 18658, 18659, 18660, 18661, 18662, 18663, 18664, 18665, 18666, 18667])
`parse_t_actions = `concat(`parse_t_actions, [254, 58, 895, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226])
`parse_t_entries = `concat(`parse_t_entries, [18668, 18669, 18670, 18671, 18672, 18673, 18674, 18684, 18702, 18703, 18704, 18717, 18782, 18776, 18777, 18767, 18730, 18758, 18763, 18788, 18794, 18795, 18796, 18797, 18798, 18799, 18800, 18801, 18802, 18803, 18804, 18805])
`parse_t_actions = `concat(`parse_t_actions, [230, 234, 238, 242, 246, 250, 254, 58, 899, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202])
`parse_t_entries = `concat(`parse_t_entries, [18806, 18807, 18808, 18809, 18810, 18811, 18812, 18813, 18814, 18815, 18816, 18817, 18818, 18828, 18846, 18847, 18848, 18861, 18926, 18920, 18921, 18911, 18874, 18902, 18907, 18932, 18938, 18939, 18940, 18941, 18942, 18943])
`parse_t_actions = `concat(`parse_t_actions, [206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 903, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178])
`parse_t_entries = `concat(`parse_t_entries, [18944, 18945, 18946, 18947, 18948, 18949, 18950, 18951, 18952, 18953, 18954, 18955, 18956, 18957, 18958, 18959, 18960, 18961, 18962, 18972, 18990, 18991, 18992, 19005, 19077, 19078, 19079, 19080, 19081, 19056, 19057, 19053])
`parse_t_actions = `concat(`parse_t_actions, [182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 907, 263, 267, 271, 910, 914, 918, 922, 926, 353, 353, 353])
`parse_t_entries = `concat(`parse_t_entries, [19054, 19071, 19072, 19073, 19074, 19075, 19058, 19059, 19060, 19061, 19062, 19063, 19064, 19065, 19066, 19067, 19068, 19069, 19015, 19019, 19039, 19052, 19163, 19183, 19344, 19345, 19341, 19342, 19359, 19360, 19361, 19362])
`parse_t_actions = `concat(`parse_t_actions, [353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 617, 617, 446, 450, 454, 458, 462, 466, 470, 474])
`parse_t_entries = `concat(`parse_t_entries, [19363, 19346, 19347, 19348, 19349, 19350, 19351, 19352, 19353, 19354, 19355, 19356, 19357, 19307, 19327, 19451, 19615, 19595, 19716, 19766, 19836, 19869, 19883, 19903, 20027, 20047, 20208, 20209, 20205, 20206, 20223, 20224])
`parse_t_actions = `concat(`parse_t_actions, [478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 613, 613, 930, 934, 509, 939, 26, 58, 943, 569, 569, 577, 577, 446, 450, 454, 458, 462, 466])
`parse_t_entries = `concat(`parse_t_entries, [20225, 20226, 20227, 20210, 20211, 20212, 20213, 20214, 20215, 20216, 20217, 20218, 20219, 20220, 20221, 20171, 20191, 20315, 20459, 20623, 20603, 20724, 20747, 20767, 20923, 20928, 20929, 20925, 20926, 20943, 20944, 20945])
`parse_t_actions = `concat(`parse_t_actions, [470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 565, 565, 946, 553, 950, 509, 955, 573, 573, 314, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [20946, 20947, 20930, 20931, 20932, 20933, 20934, 20935, 20936, 20937, 20938, 20939, 20940, 20941, 20887, 20890, 20949, 20950, 20951, 20952, 20953, 21003, 21004, 21005, 21072, 21073, 21069, 21070, 21087, 21088, 21089, 21090])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 537, 197, 197, 197, 197, 197, 363, 323, 327, 446, 450, 454, 458, 462, 466, 470, 474])
`parse_t_entries = `concat(`parse_t_entries, [21091, 21074, 21075, 21076, 21077, 21078, 21079, 21080, 21081, 21082, 21083, 21084, 21085, 21031, 21178, 21355, 21360, 21361, 21357, 21358, 21375, 21376, 21377, 21378, 21379, 21362, 21363, 21364, 21365, 21366, 21367, 21368])
`parse_t_actions = `concat(`parse_t_actions, [478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 53, 958, 314, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [21369, 21370, 21371, 21372, 21373, 21319, 21321, 21324, 21381, 21382, 21383, 21384, 21385, 21435, 21436, 21437, 21464, 21643, 21608, 21631, 21723, 21724, 21725, 21792, 21793, 21789, 21790, 21807, 21808, 21809, 21810, 21811])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 963, 323, 327, 589, 314, 197, 197, 967, 323, 327, 446, 450, 454, 458, 462, 466, 470, 474, 478])
`parse_t_entries = `concat(`parse_t_entries, [21794, 21795, 21796, 21797, 21798, 21799, 21800, 21801, 21802, 21803, 21804, 21805, 21788, 21898, 22042, 22183, 22327, 22471, 22670, 22664, 22665, 22655, 22618, 22646, 22651, 22676, 22682, 22683, 22684, 22685, 22686, 22687])
`parse_t_actions = `concat(`parse_t_actions, [482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 970, 974, 978, 69, 73, 77, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178])
`parse_t_entries = `concat(`parse_t_entries, [22688, 22689, 22690, 22691, 22692, 22693, 22694, 22695, 22696, 22697, 22698, 22699, 22700, 22701, 22702, 22703, 22704, 22705, 22706, 22716, 22734, 22735, 22736, 22749, 22814, 22808, 22809, 22799, 22762, 22790, 22795, 22820])
`parse_t_actions = `concat(`parse_t_actions, [182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 983, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154])
`parse_t_entries = `concat(`parse_t_entries, [22826, 22827, 22828, 22829, 22830, 22831, 22832, 22833, 22834, 22835, 22836, 22837, 22838, 22839, 22840, 22841, 22842, 22843, 22844, 22845, 22846, 22847, 22848, 22849, 22850, 22860, 22878, 22879, 22880, 22893, 22958, 22952])
`parse_t_actions = `concat(`parse_t_actions, [158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 987, 263, 267, 271, 130, 134])
`parse_t_entries = `concat(`parse_t_entries, [22953, 22943, 22906, 22934, 22939, 22964, 22970, 22971, 22972, 22973, 22974, 22975, 22976, 22977, 22978, 22979, 22980, 22981, 22982, 22983, 22984, 22985, 22986, 22987, 22988, 22989, 22990, 22991, 22992, 22993, 22994, 23004])
`parse_t_actions = `concat(`parse_t_actions, [138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58])
`parse_t_entries = `concat(`parse_t_entries, [23022, 23023, 23024, 23037, 23102, 23096, 23097, 23087, 23050, 23078, 23083, 23108, 23114, 23115, 23116, 23117, 23118, 23119, 23120, 23121, 23122, 23123, 23124, 23125, 23126, 23127, 23128, 23129, 23130, 23131, 23132, 23133])
`parse_t_actions = `concat(`parse_t_actions, [991, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234])
`parse_t_entries = `concat(`parse_t_entries, [23134, 23135, 23136, 23137, 23138, 23148, 23166, 23167, 23168, 23181, 23246, 23240, 23241, 23231, 23194, 23222, 23227, 23252, 23258, 23259, 23260, 23261, 23262, 23263, 23264, 23265, 23266, 23267, 23268, 23269, 23270, 23271])
`parse_t_actions = `concat(`parse_t_actions, [238, 242, 246, 250, 254, 58, 995, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210])
`parse_t_entries = `concat(`parse_t_entries, [23272, 23273, 23274, 23275, 23276, 23277, 23278, 23279, 23280, 23281, 23282, 23292, 23310, 23311, 23312, 23325, 23390, 23384, 23385, 23375, 23338, 23366, 23371, 23396, 23402, 23403, 23404, 23405, 23406, 23407, 23408, 23409])
`parse_t_actions = `concat(`parse_t_actions, [214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 999, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186])
`parse_t_entries = `concat(`parse_t_entries, [23410, 23411, 23412, 23413, 23414, 23415, 23416, 23417, 23418, 23419, 23420, 23421, 23422, 23423, 23424, 23425, 23426, 23436, 23454, 23455, 23456, 23469, 23534, 23528, 23529, 23519, 23482, 23510, 23515, 23540, 23546, 23547])
`parse_t_actions = `concat(`parse_t_actions, [190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1003, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162])
`parse_t_entries = `concat(`parse_t_entries, [23548, 23549, 23550, 23551, 23552, 23553, 23554, 23555, 23556, 23557, 23558, 23559, 23560, 23561, 23562, 23563, 23564, 23565, 23566, 23567, 23568, 23569, 23570, 23580, 23598, 23599, 23600, 23613, 23678, 23672, 23673, 23663])
`parse_t_actions = `concat(`parse_t_actions, [166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1007, 263, 267, 271, 130, 134, 138, 142])
`parse_t_entries = `concat(`parse_t_entries, [23626, 23654, 23659, 23684, 23690, 23691, 23692, 23693, 23694, 23695, 23696, 23697, 23698, 23699, 23700, 23701, 23702, 23703, 23704, 23705, 23706, 23707, 23708, 23709, 23710, 23711, 23712, 23713, 23714, 23724, 23742, 23743])
`parse_t_actions = `concat(`parse_t_actions, [146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1011, 263])
`parse_t_entries = `concat(`parse_t_entries, [23744, 23757, 23822, 23816, 23817, 23807, 23770, 23798, 23803, 23828, 23834, 23835, 23836, 23837, 23838, 23839, 23840, 23841, 23842, 23843, 23844, 23845, 23846, 23847, 23848, 23849, 23850, 23851, 23852, 23853, 23854, 23855])
`parse_t_actions = `concat(`parse_t_actions, [267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242])
`parse_t_entries = `concat(`parse_t_entries, [23856, 23857, 23858, 23868, 23886, 23887, 23888, 23901, 23966, 23960, 23961, 23951, 23914, 23942, 23947, 23972, 23978, 23979, 23980, 23981, 23982, 23983, 23984, 23985, 23986, 23987, 23988, 23989, 23990, 23991, 23992, 23993])
`parse_t_actions = `concat(`parse_t_actions, [246, 250, 254, 58, 1015, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218])
`parse_t_entries = `concat(`parse_t_entries, [23994, 23995, 23996, 23997, 23998, 23999, 24000, 24001, 24002, 24012, 24030, 24031, 24032, 24045, 24110, 24104, 24105, 24095, 24058, 24086, 24091, 24116, 24122, 24123, 24124, 24125, 24126, 24127, 24128, 24129, 24130, 24131])
`parse_t_actions = `concat(`parse_t_actions, [222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1019, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194])
`parse_t_entries = `concat(`parse_t_entries, [24132, 24133, 24134, 24135, 24136, 24137, 24138, 24139, 24140, 24141, 24142, 24143, 24144, 24145, 24146, 24156, 24174, 24175, 24176, 24189, 24254, 24248, 24249, 24239, 24202, 24220, 24230, 24235, 24260, 24266, 24267, 24268])
`parse_t_actions = `concat(`parse_t_actions, [198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1023, 263, 267, 271, 130, 134, 138, 142, 146, 1026, 26, 150, 154, 158, 162, 166])
`parse_t_entries = `concat(`parse_t_entries, [24269, 24270, 24271, 24272, 24273, 24274, 24275, 24276, 24277, 24278, 24279, 24280, 24281, 24282, 24283, 24284, 24285, 24286, 24287, 24288, 24289, 24290, 24300, 24318, 24319, 24320, 24333, 24346, 24490, 24672, 24673, 24669])
`parse_t_actions = `concat(`parse_t_actions, [170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1031, 263, 267, 271, 1034, 1038, 205, 205, 205])
`parse_t_entries = `concat(`parse_t_entries, [24670, 24687, 24688, 24689, 24690, 24691, 24674, 24675, 24676, 24677, 24678, 24679, 24680, 24681, 24682, 24683, 24684, 24685, 24631, 24632, 24633, 24635, 24636, 24637, 24638, 24639, 24640, 24641, 24642, 24643, 24644, 24645])
`parse_t_actions = `concat(`parse_t_actions, [205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205])
`parse_t_entries = `concat(`parse_t_entries, [24646, 24647, 24648, 24649, 24650, 24651, 24654, 24655, 24656, 24668, 24693, 24694, 24695, 24696, 24697, 24816, 24817, 24813, 24814, 24831, 24832, 24833, 24834, 24835, 24818, 24819, 24820, 24821, 24822, 24823, 24824, 24825])
`parse_t_actions = `concat(`parse_t_actions, [205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213])
`parse_t_entries = `concat(`parse_t_entries, [24826, 24827, 24828, 24829, 24775, 24779, 24799, 24812, 24974, 24968, 24969, 24959, 24922, 24950, 24955, 24980, 24986, 24987, 24988, 24989, 24990, 24991, 24992, 24993, 24994, 24995, 24996, 24997, 24998, 24999, 25000, 25001])
`parse_t_actions = `concat(`parse_t_actions, [213, 213, 213, 213, 213, 213, 213, 213, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218])
`parse_t_entries = `concat(`parse_t_entries, [25002, 25003, 25004, 25005, 25006, 25007, 25008, 25009, 25010, 25020, 24956, 25038, 25039, 25040, 25043, 25053, 25100, 25243, 25248, 25249, 25245, 25246, 25263, 25264, 25265, 25266, 25267, 25250, 25251, 25252, 25253, 25254])
`parse_t_actions = `concat(`parse_t_actions, [222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 513, 351, 263, 267, 1043, 271, 501, 314, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197])
`parse_t_entries = `concat(`parse_t_entries, [25255, 25256, 25257, 25258, 25259, 25260, 25261, 25207, 25211, 25231, 25244, 25323, 25324, 25325, 25392, 25393, 25389, 25390, 25407, 25408, 25409, 25410, 25411, 25394, 25395, 25396, 25397, 25398, 25399, 25400, 25401, 25402])
`parse_t_actions = `concat(`parse_t_actions, [197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 197, 1047, 323, 327, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329, 329])
`parse_t_entries = `concat(`parse_t_entries, [25403, 25404, 25405, 25351, 25355, 25375, 25388, 25536, 25537, 25533, 25534, 25551, 25552, 25553, 25554, 25555, 25538, 25539, 25540, 25541, 25542, 25543, 25544, 25545, 25546, 25547, 25548, 25549, 25495, 25499, 25519, 25532])
`parse_t_actions = `concat(`parse_t_actions, [329, 329, 329, 329, 329, 329, 329, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333, 333])
`parse_t_entries = `concat(`parse_t_entries, [25680, 25681, 25677, 25678, 25695, 25696, 25697, 25698, 25699, 25682, 25683, 25684, 25685, 25686, 25687, 25688, 25689, 25690, 25691, 25692, 25693, 25639, 25643, 25663, 25676, 25824, 25825, 25821, 25822, 25839, 25840, 25841])
`parse_t_actions = `concat(`parse_t_actions, [337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 341, 341, 341, 341, 341, 341, 341])
`parse_t_entries = `concat(`parse_t_entries, [25842, 25843, 25826, 25827, 25828, 25829, 25830, 25831, 25832, 25833, 25834, 25835, 25836, 25837, 25783, 25787, 25807, 25820, 25930, 26112, 26113, 26109, 26110, 26127, 26128, 26129, 26130, 26131, 26114, 26115, 26116, 26117])
`parse_t_actions = `concat(`parse_t_actions, [341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 341, 1050, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494])
`parse_t_entries = `concat(`parse_t_entries, [26118, 26119, 26120, 26121, 26122, 26123, 26124, 26125, 26075, 26256, 26257, 26253, 26254, 26271, 26272, 26273, 26274, 26275, 26258, 26259, 26260, 26261, 26262, 26263, 26264, 26265, 26266, 26267, 26268, 26269, 26219, 26400])
`parse_t_actions = `concat(`parse_t_actions, [498, 502, 506, 510, 514, 518, 522, 526, 1054, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1058, 446])
`parse_t_entries = `concat(`parse_t_entries, [26401, 26397, 26398, 26415, 26416, 26417, 26418, 26419, 26402, 26403, 26404, 26405, 26406, 26407, 26408, 26409, 26410, 26411, 26412, 26413, 26363, 26544, 26545, 26541, 26542, 26559, 26560, 26561, 26562, 26563, 26546, 26547])
`parse_t_actions = `concat(`parse_t_actions, [450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1062, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486])
`parse_t_entries = `concat(`parse_t_entries, [26548, 26549, 26550, 26551, 26552, 26553, 26554, 26555, 26556, 26557, 26507, 26688, 26689, 26685, 26686, 26703, 26704, 26705, 26706, 26707, 26690, 26691, 26692, 26693, 26694, 26695, 26696, 26697, 26698, 26699, 26700, 26701])
`parse_t_actions = `concat(`parse_t_actions, [490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1066, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526])
`parse_t_entries = `concat(`parse_t_entries, [26671, 26832, 26833, 26829, 26830, 26847, 26848, 26849, 26850, 26851, 26834, 26835, 26836, 26837, 26838, 26839, 26840, 26841, 26842, 26843, 26844, 26845, 26795, 26976, 26977, 26973, 26974, 26991, 26992, 26993, 26994, 26995])
`parse_t_actions = `concat(`parse_t_actions, [1070, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1074, 446, 450, 454, 458, 462, 466, 470, 474, 478])
`parse_t_entries = `concat(`parse_t_entries, [26978, 26979, 26980, 26981, 26982, 26983, 26984, 26985, 26986, 26987, 26988, 26989, 26939, 27120, 27121, 27117, 27118, 27135, 27136, 27137, 27138, 27139, 27122, 27123, 27124, 27125, 27126, 27127, 27128, 27129, 27130, 27131])
`parse_t_actions = `concat(`parse_t_actions, [482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1078, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518])
`parse_t_entries = `concat(`parse_t_entries, [27132, 27133, 27083, 27264, 27265, 27261, 27262, 27279, 27280, 27281, 27282, 27283, 27266, 27267, 27268, 27269, 27270, 27271, 27272, 27273, 27274, 27275, 27276, 27277, 27227, 27408, 27409, 27405, 27406, 27423, 27424, 27425])
`parse_t_actions = `concat(`parse_t_actions, [522, 526, 1082, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1086, 446, 450, 454, 458, 462, 466, 470])
`parse_t_entries = `concat(`parse_t_entries, [27426, 27427, 27410, 27411, 27412, 27413, 27414, 27415, 27416, 27417, 27418, 27419, 27420, 27421, 27371, 27552, 27553, 27549, 27550, 27567, 27568, 27569, 27570, 27571, 27554, 27555, 27556, 27557, 27558, 27559, 27560, 27561])
`parse_t_actions = `concat(`parse_t_actions, [474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1090, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510])
`parse_t_entries = `concat(`parse_t_entries, [27562, 27563, 27564, 27565, 27515, 27696, 27697, 27693, 27694, 27711, 27712, 27713, 27714, 27715, 27698, 27699, 27700, 27701, 27702, 27703, 27704, 27705, 27706, 27707, 27708, 27709, 27659, 27840, 27841, 27837, 27838, 27855])
`parse_t_actions = `concat(`parse_t_actions, [514, 518, 522, 526, 1094, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1098, 446, 450, 454, 458, 462])
`parse_t_entries = `concat(`parse_t_entries, [27856, 27857, 27858, 27859, 27842, 27843, 27844, 27845, 27846, 27847, 27848, 27849, 27850, 27851, 27852, 27853, 27823, 27984, 27985, 27981, 27982, 27999, 28000, 28001, 28002, 28003, 27986, 27987, 27988, 27989, 27990, 27991])
`parse_t_actions = `concat(`parse_t_actions, [466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1102, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502])
`parse_t_entries = `concat(`parse_t_entries, [27992, 27993, 27994, 27995, 27996, 27997, 27967, 28128, 28129, 28125, 28126, 28143, 28144, 28145, 28146, 28147, 28130, 28131, 28132, 28133, 28134, 28135, 28136, 28137, 28138, 28139, 28140, 28141, 28111, 28272, 28273, 28269])
`parse_t_actions = `concat(`parse_t_actions, [506, 510, 514, 518, 522, 526, 1106, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1110, 446, 450, 454])
`parse_t_entries = `concat(`parse_t_entries, [28270, 28287, 28288, 28289, 28290, 28291, 28274, 28275, 28276, 28277, 28278, 28279, 28280, 28281, 28282, 28283, 28284, 28285, 28235, 28416, 28417, 28413, 28414, 28431, 28432, 28433, 28434, 28435, 28418, 28419, 28420, 28421])
`parse_t_actions = `concat(`parse_t_actions, [458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1114, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494])
`parse_t_entries = `concat(`parse_t_entries, [28422, 28423, 28424, 28425, 28426, 28427, 28428, 28429, 28379, 28560, 28561, 28557, 28558, 28575, 28576, 28577, 28578, 28579, 28562, 28563, 28564, 28565, 28566, 28567, 28568, 28569, 28570, 28571, 28572, 28573, 28523, 28704])
`parse_t_actions = `concat(`parse_t_actions, [498, 502, 506, 510, 514, 518, 522, 526, 1118, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1122, 446])
`parse_t_entries = `concat(`parse_t_entries, [28705, 28701, 28702, 28719, 28720, 28721, 28722, 28723, 28706, 28707, 28708, 28709, 28710, 28711, 28712, 28713, 28714, 28715, 28716, 28717, 28667, 28848, 28849, 28845, 28846, 28863, 28864, 28865, 28866, 28867, 28850, 28851])
`parse_t_actions = `concat(`parse_t_actions, [450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1126, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486])
`parse_t_entries = `concat(`parse_t_entries, [28852, 28853, 28854, 28855, 28856, 28857, 28858, 28859, 28860, 28861, 28811, 28992, 28993, 28989, 28990, 29007, 29008, 29009, 29010, 29011, 28994, 28995, 28996, 28997, 28998, 28999, 29000, 29001, 29002, 29003, 29004, 29005])
`parse_t_actions = `concat(`parse_t_actions, [490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1130, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517, 517])
`parse_t_entries = `concat(`parse_t_entries, [28951, 28955, 28975, 28988, 29136, 29137, 29133, 29134, 29151, 29152, 29153, 29154, 29155, 29138, 29139, 29140, 29141, 29142, 29143, 29144, 29145, 29146, 29147, 29148, 29149, 29095, 29099, 29119, 29132, 29280, 29281, 29277])
`parse_t_actions = `concat(`parse_t_actions, [517, 517, 517, 517, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 521, 525, 525, 525])
`parse_t_entries = `concat(`parse_t_entries, [29278, 29295, 29296, 29297, 29298, 29299, 29282, 29283, 29284, 29285, 29286, 29287, 29288, 29289, 29290, 29291, 29292, 29293, 29239, 29243, 29263, 29276, 29424, 29425, 29421, 29422, 29439, 29440, 29441, 29442, 29443, 29426])
`parse_t_actions = `concat(`parse_t_actions, [525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 525, 529, 529, 529, 529, 529, 529, 529, 529, 529, 529])
`parse_t_entries = `concat(`parse_t_entries, [29427, 29428, 29429, 29430, 29431, 29432, 29433, 29434, 29435, 29436, 29437, 29383, 29387, 29407, 29420, 29568, 29569, 29565, 29566, 29583, 29584, 29585, 29586, 29587, 29570, 29571, 29572, 29573, 29574, 29575, 29576, 29577])
`parse_t_actions = `concat(`parse_t_actions, [529, 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, 529, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533])
`parse_t_entries = `concat(`parse_t_entries, [29578, 29579, 29580, 29581, 29527, 29531, 29551, 29564, 29712, 29713, 29709, 29710, 29727, 29728, 29729, 29730, 29731, 29714, 29715, 29716, 29717, 29718, 29719, 29720, 29721, 29722, 29723, 29724, 29725, 29671, 29675, 29695])
`parse_t_actions = `concat(`parse_t_actions, [533, 533, 533, 533, 533, 533, 533, 533, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229, 229])
`parse_t_entries = `concat(`parse_t_entries, [29708, 29856, 29857, 29853, 29854, 29871, 29872, 29873, 29874, 29875, 29858, 29859, 29860, 29861, 29862, 29863, 29864, 29865, 29866, 29867, 29868, 29869, 29815, 29819, 29839, 29852, 29998, 30015, 30016, 30017, 30018, 30019])
`parse_t_actions = `concat(`parse_t_actions, [229, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 233, 458, 462, 466, 470, 474, 478])
`parse_t_entries = `concat(`parse_t_entries, [30002, 30003, 30004, 30005, 30006, 30007, 30008, 30009, 30010, 30011, 30012, 30013, 30000, 30001, 29997, 29959, 29963, 29983, 29996, 30159, 30160, 30161, 30162, 30163, 30146, 30147, 30148, 30149, 30150, 30151, 30152, 30153])
`parse_t_actions = `concat(`parse_t_actions, [482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 217, 217, 217, 217, 217, 217, 217, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510])
`parse_t_entries = `concat(`parse_t_entries, [30154, 30155, 30156, 30157, 30144, 30145, 30141, 30142, 30103, 30107, 30127, 30140, 30304, 30305, 30306, 30307, 30290, 30291, 30292, 30293, 30294, 30295, 30296, 30297, 30298, 30299, 30300, 30301, 30288, 30289, 30285, 30286])
`parse_t_actions = `concat(`parse_t_actions, [514, 518, 522, 526, 221, 221, 221, 221, 221, 221, 221, 221, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 289, 289, 289, 289])
`parse_t_entries = `concat(`parse_t_entries, [30303, 30247, 30251, 30271, 30284, 30449, 30450, 30451, 30434, 30435, 30436, 30437, 30438, 30439, 30440, 30441, 30442, 30443, 30444, 30445, 30432, 30433, 30429, 30430, 30447, 30448, 30391, 30395, 30415, 30428, 30594, 30595])
`parse_t_actions = `concat(`parse_t_actions, [289, 289, 289, 289, 289, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 474, 478])
`parse_t_entries = `concat(`parse_t_entries, [30578, 30579, 30580, 30581, 30582, 30583, 30584, 30585, 30586, 30587, 30588, 30589, 30576, 30577, 30573, 30574, 30591, 30592, 30593, 30535, 30539, 30559, 30572, 30722, 30723, 30724, 30725, 30726, 30727, 30728, 30729, 30730])
`parse_t_actions = `concat(`parse_t_actions, [482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, 297, 482, 486, 490, 494, 498, 502, 506, 510, 514])
`parse_t_entries = `concat(`parse_t_entries, [30731, 30732, 30733, 30720, 30721, 30717, 30718, 30735, 30736, 30737, 30738, 30739, 30679, 30683, 30703, 30716, 30866, 30867, 30868, 30869, 30870, 30871, 30872, 30873, 30874, 30875, 30876, 30877, 30864, 30865, 30861, 30862])
`parse_t_actions = `concat(`parse_t_actions, [518, 522, 526, 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 305, 305, 305, 305])
`parse_t_entries = `concat(`parse_t_entries, [30879, 30880, 30881, 30882, 30883, 30823, 30827, 30847, 30860, 31012, 31013, 31014, 31015, 31016, 31017, 31018, 31019, 31020, 31021, 31008, 31009, 31005, 31006, 31023, 31024, 31025, 31026, 31027, 30967, 30971, 30991, 31004])
`parse_t_actions = `concat(`parse_t_actions, [305, 305, 305, 305, 305, 305, 305, 305, 305, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237])
`parse_t_entries = `concat(`parse_t_entries, [31156, 31157, 31158, 31159, 31160, 31161, 31162, 31163, 31164, 31165, 31152, 31153, 31149, 31150, 31167, 31168, 31169, 31170, 31171, 31111, 31115, 31135, 31148, 31304, 31305, 31306, 31307, 31308, 31309, 31296, 31297, 31293])
`parse_t_actions = `concat(`parse_t_actions, [490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 241, 506, 510, 514, 518, 522, 526, 245, 245, 245])
`parse_t_entries = `concat(`parse_t_entries, [31294, 31311, 31312, 31313, 31314, 31315, 31298, 31299, 31255, 31259, 31279, 31292, 31448, 31449, 31450, 31451, 31452, 31453, 31440, 31441, 31437, 31438, 31455, 31456, 31457, 31458, 31459, 31442, 31443, 31399, 31403, 31423])
`parse_t_actions = `concat(`parse_t_actions, [245, 245, 245, 245, 245, 245, 245, 245, 245, 245, 245, 245, 506, 510, 514, 518, 522, 526, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249])
`parse_t_entries = `concat(`parse_t_entries, [31436, 31592, 31593, 31594, 31595, 31596, 31597, 31584, 31585, 31581, 31582, 31599, 31600, 31601, 31602, 31603, 31586, 31587, 31543, 31547, 31567, 31580, 31736, 31737, 31738, 31739, 31740, 31741, 31728, 31729, 31725, 31726])
`parse_t_actions = `concat(`parse_t_actions, [249, 506, 510, 514, 518, 522, 526, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 506, 510, 514, 518, 522, 526, 257, 257, 257, 257])
`parse_t_entries = `concat(`parse_t_entries, [31743, 31744, 31745, 31746, 31747, 31730, 31731, 31687, 31691, 31711, 31724, 31882, 31883, 31884, 31885, 31872, 31873, 31869, 31870, 31887, 31888, 31889, 31890, 31891, 31874, 31875, 31876, 31877, 31878, 31879, 31880, 31881])
`parse_t_actions = `concat(`parse_t_actions, [257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 514, 518, 522, 526, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261, 261])
`parse_t_entries = `concat(`parse_t_entries, [31831, 31835, 31855, 31868, 32026, 32027, 32028, 32029, 32016, 32017, 32013, 32014, 32031, 32032, 32033, 32034, 32035, 32018, 32019, 32020, 32021, 32022, 32023, 32024, 32025, 31975, 31979, 31999, 32012, 32160, 32161, 32157])
`parse_t_actions = `concat(`parse_t_actions, [261, 261, 261, 261, 514, 518, 522, 526, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 265, 269, 269, 269])
`parse_t_entries = `concat(`parse_t_entries, [32158, 32175, 32176, 32177, 32178, 32179, 32162, 32163, 32164, 32165, 32166, 32167, 32168, 32169, 32170, 32171, 32172, 32173, 32119, 32123, 32143, 32156, 32304, 32305, 32301, 32302, 32319, 32320, 32321, 32322, 32323, 32306])
`parse_t_actions = `concat(`parse_t_actions, [269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, 273, 273, 273, 273, 273, 273, 273, 273, 273, 273])
`parse_t_entries = `concat(`parse_t_entries, [32307, 32308, 32309, 32310, 32311, 32312, 32313, 32314, 32315, 32316, 32317, 32263, 32267, 32287, 32300, 32448, 32449, 32445, 32446, 32463, 32464, 32465, 32466, 32467, 32450, 32451, 32452, 32453, 32454, 32455, 32456, 32457])
`parse_t_actions = `concat(`parse_t_actions, [273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 273, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277])
`parse_t_entries = `concat(`parse_t_entries, [32458, 32459, 32460, 32461, 32407, 32411, 32431, 32444, 32592, 32593, 32589, 32590, 32607, 32608, 32609, 32610, 32611, 32594, 32595, 32596, 32597, 32598, 32599, 32600, 32601, 32602, 32603, 32604, 32605, 32551, 32555, 32575])
`parse_t_actions = `concat(`parse_t_actions, [277, 277, 277, 277, 277, 277, 277, 277, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281])
`parse_t_entries = `concat(`parse_t_entries, [32588, 32736, 32737, 32733, 32734, 32751, 32752, 32753, 32754, 32755, 32738, 32739, 32740, 32741, 32742, 32743, 32744, 32745, 32746, 32747, 32748, 32749, 32695, 32699, 32719, 32732, 32880, 32881, 32877, 32878, 32895, 32896])
`parse_t_actions = `concat(`parse_t_actions, [281, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 357, 361, 361, 361, 361, 361, 361])
`parse_t_entries = `concat(`parse_t_entries, [32897, 32898, 32899, 32882, 32883, 32884, 32885, 32886, 32887, 32888, 32889, 32890, 32891, 32892, 32893, 32839, 32843, 32863, 32876, 33024, 33025, 33021, 33022, 33039, 33040, 33041, 33042, 33043, 33026, 33027, 33028, 33029])
`parse_t_actions = `concat(`parse_t_actions, [361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365])
`parse_t_entries = `concat(`parse_t_entries, [33030, 33031, 33032, 33033, 33034, 33035, 33036, 33037, 32983, 32987, 33007, 33020, 33168, 33169, 33165, 33166, 33183, 33184, 33185, 33186, 33187, 33170, 33171, 33172, 33173, 33174, 33175, 33176, 33177, 33178, 33179, 33180])
`parse_t_actions = `concat(`parse_t_actions, [365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 365, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369, 369])
`parse_t_entries = `concat(`parse_t_entries, [33181, 33127, 33131, 33151, 33164, 33274, 33415, 33614, 33608, 33609, 33599, 33562, 33590, 33595, 33620, 33626, 33627, 33628, 33629, 33630, 33631, 33632, 33633, 33634, 33635, 33636, 33637, 33638, 33639, 33640, 33641, 33642])
`parse_t_actions = `concat(`parse_t_actions, [369, 369, 369, 369, 369, 1134, 193, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222])
`parse_t_entries = `concat(`parse_t_entries, [33643, 33644, 33645, 33646, 33647, 33648, 33649, 33650, 33659, 33660, 33563, 33678, 33679, 33680, 33693, 33694, 33695, 33707, 33883, 33851, 33871, 33963, 33964, 33965, 33991, 34193, 34190, 34184, 34185, 34175, 34138, 34166])
`parse_t_actions = `concat(`parse_t_actions, [226, 230, 234, 238, 242, 246, 250, 254, 534, 58, 513, 539, 263, 267, 271, 1139, 547, 605, 314, 197, 197, 1143, 323, 327, 189, 550, 130, 134, 138, 142, 146, 26])
`parse_t_entries = `concat(`parse_t_entries, [34171, 34196, 34202, 34203, 34204, 34205, 34206, 34207, 34208, 34209, 34210, 34211, 34212, 34213, 34214, 34215, 34216, 34217, 34218, 34219, 34220, 34221, 34222, 34223, 34224, 34225, 34226, 34234, 34235, 34236, 34139, 34254])
`parse_t_actions = `concat(`parse_t_actions, [150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 554, 558, 58, 513, 563])
`parse_t_entries = `concat(`parse_t_entries, [34255, 34256, 34264, 34265, 34266, 34269, 34283, 34481, 34478, 34472, 34473, 34463, 34426, 34454, 34459, 34484, 34490, 34491, 34492, 34493, 34494, 34495, 34496, 34497, 34498, 34499, 34500, 34501, 34502, 34503, 34504, 34505])
`parse_t_actions = `concat(`parse_t_actions, [263, 267, 1147, 575, 579, 271, 557, 550, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218])
`parse_t_entries = `concat(`parse_t_entries, [34506, 34507, 34508, 34509, 34510, 34511, 34512, 34513, 34514, 34522, 34523, 34524, 34427, 34542, 34543, 34544, 34551, 34552, 34553, 34554, 34557, 34569, 34572, 34629, 34630, 34631, 34632, 34633, 34608, 34609, 34605, 34606])
`parse_t_actions = `concat(`parse_t_actions, [222, 226, 230, 234, 238, 242, 246, 250, 254, 554, 558, 58, 549, 563, 263, 267, 1151, 571, 575, 579, 271, 1154, 1158, 910, 914, 918, 922, 926, 353, 353, 353, 353])
`parse_t_entries = `concat(`parse_t_entries, [34623, 34624, 34625, 34626, 34627, 34610, 34611, 34612, 34613, 34614, 34615, 34616, 34617, 34618, 34619, 34620, 34621, 34567, 34712, 34735, 34896, 34897, 34893, 34894, 34911, 34912, 34913, 34914, 34915, 34898, 34899, 34900])
`parse_t_actions = `concat(`parse_t_actions, [353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 593, 593, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209])
`parse_t_entries = `concat(`parse_t_entries, [34901, 34902, 34903, 34904, 34905, 34906, 34907, 34908, 34909, 34855, 34856, 34857, 34859, 34860, 34861, 34862, 34863, 34864, 34865, 34866, 34867, 34868, 34869, 34870, 34871, 34872, 34873, 34874, 34875, 34878, 34879, 34880])
`parse_t_actions = `concat(`parse_t_actions, [209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209])
`parse_t_entries = `concat(`parse_t_entries, [34891, 34892, 34917, 34918, 34919, 34920, 34921, 35054, 35048, 35049, 35039, 35002, 35030, 35035, 35060, 35066, 35067, 35068, 35069, 35070, 35071, 35072, 35073, 35074, 35075, 35076, 35077, 35078, 35079, 35080, 35081, 35082])
`parse_t_actions = `concat(`parse_t_actions, [209, 209, 209, 209, 209, 209, 209, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222])
`parse_t_entries = `concat(`parse_t_entries, [35083, 35084, 35085, 35086, 35087, 35088, 35089, 35090, 35100, 35003, 35118, 35119, 35120, 35121, 35133, 35147, 35328, 35329, 35325, 35326, 35343, 35344, 35345, 35346, 35347, 35330, 35331, 35332, 35333, 35334, 35335, 35336])
`parse_t_actions = `concat(`parse_t_actions, [226, 230, 234, 238, 242, 246, 250, 254, 58, 485, 1163, 263, 267, 1167, 271, 1170, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506])
`parse_t_entries = `concat(`parse_t_entries, [35337, 35338, 35339, 35340, 35341, 35287, 35472, 35473, 35469, 35470, 35487, 35488, 35489, 35490, 35491, 35474, 35475, 35476, 35477, 35478, 35479, 35480, 35481, 35482, 35483, 35484, 35485, 35431, 35616, 35617, 35613, 35614])
`parse_t_actions = `concat(`parse_t_actions, [510, 514, 518, 522, 526, 81, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 85, 446, 450, 454, 458])
`parse_t_entries = `concat(`parse_t_entries, [35631, 35632, 35633, 35634, 35635, 35618, 35619, 35620, 35621, 35622, 35623, 35624, 35625, 35626, 35627, 35628, 35629, 35575, 35760, 35761, 35757, 35758, 35775, 35776, 35777, 35778, 35779, 35762, 35763, 35764, 35765, 35766])
`parse_t_actions = `concat(`parse_t_actions, [462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 89, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498])
`parse_t_entries = `concat(`parse_t_entries, [35767, 35768, 35769, 35770, 35771, 35772, 35773, 35719, 35904, 35905, 35901, 35902, 35919, 35920, 35921, 35922, 35923, 35906, 35907, 35908, 35909, 35910, 35911, 35912, 35913, 35914, 35915, 35916, 35917, 35863, 36048, 36049])
`parse_t_actions = `concat(`parse_t_actions, [502, 506, 510, 514, 518, 522, 526, 93, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 97, 446, 450])
`parse_t_entries = `concat(`parse_t_entries, [36045, 36046, 36063, 36064, 36065, 36066, 36067, 36050, 36051, 36052, 36053, 36054, 36055, 36056, 36057, 36058, 36059, 36060, 36061, 36007, 36192, 36193, 36189, 36190, 36207, 36208, 36209, 36210, 36211, 36194, 36195, 36196])
`parse_t_actions = `concat(`parse_t_actions, [454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 101, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490])
`parse_t_entries = `concat(`parse_t_entries, [36197, 36198, 36199, 36200, 36201, 36202, 36203, 36204, 36205, 36151, 36336, 36337, 36333, 36334, 36351, 36352, 36353, 36354, 36355, 36338, 36339, 36340, 36341, 36342, 36343, 36344, 36345, 36346, 36347, 36348, 36349, 36295])
`parse_t_actions = `concat(`parse_t_actions, [494, 498, 502, 506, 510, 514, 518, 522, 526, 105, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 109])
`parse_t_entries = `concat(`parse_t_entries, [36480, 36481, 36477, 36478, 36495, 36496, 36497, 36498, 36499, 36482, 36483, 36484, 36485, 36486, 36487, 36488, 36489, 36490, 36491, 36492, 36493, 36439, 36624, 36625, 36621, 36622, 36639, 36640, 36641, 36642, 36643, 36626])
`parse_t_actions = `concat(`parse_t_actions, [446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 113, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482])
`parse_t_entries = `concat(`parse_t_entries, [36627, 36628, 36629, 36630, 36631, 36632, 36633, 36634, 36635, 36636, 36637, 36583, 36768, 36769, 36765, 36766, 36783, 36784, 36785, 36786, 36787, 36770, 36771, 36772, 36773, 36774, 36775, 36776, 36777, 36778, 36779, 36780])
`parse_t_actions = `concat(`parse_t_actions, [486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 117, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522])
`parse_t_entries = `concat(`parse_t_entries, [36781, 36727, 36871, 37056, 37057, 37053, 37054, 37071, 37072, 37073, 37074, 37075, 37058, 37059, 37060, 37061, 37062, 37063, 37064, 37065, 37066, 37067, 37068, 37069, 37015, 37214, 37208, 37209, 37199, 37162, 37190, 37195])
`parse_t_actions = `concat(`parse_t_actions, [526, 121, 125, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 129, 130, 134, 138, 142, 146, 26, 150])
`parse_t_entries = `concat(`parse_t_entries, [37220, 37226, 37227, 37228, 37229, 37230, 37231, 37232, 37233, 37234, 37235, 37236, 37237, 37238, 37239, 37240, 37241, 37242, 37243, 37244, 37245, 37246, 37247, 37248, 37249, 37250, 37260, 37278, 37279, 37280, 37293, 37358])
`parse_t_actions = `concat(`parse_t_actions, [154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1175, 263, 267, 271, 130])
`parse_t_entries = `concat(`parse_t_entries, [37352, 37353, 37343, 37306, 37334, 37339, 37364, 37370, 37371, 37372, 37373, 37374, 37375, 37376, 37377, 37378, 37379, 37380, 37381, 37382, 37383, 37384, 37385, 37386, 37387, 37388, 37389, 37390, 37391, 37392, 37393, 37394])
`parse_t_actions = `concat(`parse_t_actions, [134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254])
`parse_t_entries = `concat(`parse_t_entries, [37404, 37422, 37423, 37424, 37437, 37484, 37632, 37633, 37629, 37630, 37647, 37648, 37649, 37650, 37651, 37634, 37635, 37636, 37637, 37638, 37639, 37640, 37641, 37642, 37643, 37644, 37645, 37591, 37595, 37615, 37628, 37790])
`parse_t_actions = `concat(`parse_t_actions, [58, 1179, 263, 267, 271, 505, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 130])
`parse_t_entries = `concat(`parse_t_entries, [37784, 37785, 37775, 37738, 37766, 37771, 37796, 37802, 37803, 37804, 37805, 37806, 37807, 37808, 37809, 37810, 37811, 37812, 37813, 37814, 37815, 37816, 37817, 37818, 37819, 37820, 37821, 37822, 37823, 37824, 37825, 37826])
`parse_t_actions = `concat(`parse_t_actions, [134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254])
`parse_t_entries = `concat(`parse_t_entries, [37836, 37854, 37855, 37856, 37869, 37920, 37921, 37917, 37918, 37935, 37936, 37937, 37938, 37939, 37922, 37923, 37924, 37925, 37926, 37927, 37928, 37929, 37930, 37931, 37932, 37933, 37879, 37883, 37903, 37916, 38064, 38065])
`parse_t_actions = `concat(`parse_t_actions, [58, 1183, 263, 267, 271, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 397, 401, 401])
`parse_t_entries = `concat(`parse_t_entries, [38061, 38062, 38079, 38080, 38081, 38082, 38083, 38066, 38067, 38068, 38069, 38070, 38071, 38072, 38073, 38074, 38075, 38076, 38077, 38023, 38027, 38047, 38060, 38208, 38209, 38205, 38206, 38223, 38224, 38225, 38226, 38227])
`parse_t_actions = `concat(`parse_t_actions, [401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 405, 405, 405, 405, 405, 405, 405, 405, 405])
`parse_t_entries = `concat(`parse_t_entries, [38210, 38211, 38212, 38213, 38214, 38215, 38216, 38217, 38218, 38219, 38220, 38221, 38167, 38171, 38191, 38204, 38352, 38353, 38349, 38350, 38367, 38368, 38369, 38370, 38371, 38354, 38355, 38356, 38357, 38358, 38359, 38360])
`parse_t_actions = `concat(`parse_t_actions, [405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409])
`parse_t_entries = `concat(`parse_t_entries, [38361, 38362, 38363, 38364, 38365, 38311, 38315, 38335, 38348, 38510, 38504, 38505, 38495, 38458, 38486, 38491, 38516, 38522, 38523, 38524, 38525, 38526, 38527, 38528, 38529, 38530, 38531, 38532, 38533, 38534, 38535, 38536])
`parse_t_actions = `concat(`parse_t_actions, [409, 409, 409, 409, 409, 409, 409, 409, 409, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214])
`parse_t_entries = `concat(`parse_t_entries, [38537, 38538, 38539, 38540, 38541, 38542, 38543, 38544, 38545, 38546, 38556, 38574, 38575, 38576, 38589, 38640, 38641, 38637, 38638, 38655, 38656, 38657, 38658, 38659, 38642, 38643, 38644, 38645, 38646, 38647, 38648, 38649])
`parse_t_actions = `concat(`parse_t_actions, [218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1187, 263, 267, 271, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417, 417])
`parse_t_entries = `concat(`parse_t_entries, [38650, 38651, 38652, 38653, 38599, 38603, 38623, 38636, 38784, 38785, 38781, 38782, 38799, 38800, 38801, 38802, 38803, 38786, 38787, 38788, 38789, 38790, 38791, 38792, 38793, 38794, 38795, 38796, 38797, 38743, 38747, 38767])
`parse_t_actions = `concat(`parse_t_actions, [417, 417, 417, 417, 417, 417, 417, 417, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421, 421])
`parse_t_entries = `concat(`parse_t_entries, [38780, 38928, 38929, 38925, 38926, 38943, 38944, 38945, 38946, 38947, 38930, 38931, 38932, 38933, 38934, 38935, 38936, 38937, 38938, 38939, 38940, 38941, 38887, 38891, 38911, 38924, 39072, 39073, 39069, 39070, 39087, 39088])
`parse_t_actions = `concat(`parse_t_actions, [421, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 429, 433, 433, 433, 433, 433, 433])
`parse_t_entries = `concat(`parse_t_entries, [39089, 39090, 39091, 39074, 39075, 39076, 39077, 39078, 39079, 39080, 39081, 39082, 39083, 39084, 39085, 39031, 39035, 39055, 39068, 39216, 39217, 39213, 39214, 39231, 39232, 39233, 39234, 39235, 39218, 39219, 39220, 39221])
`parse_t_actions = `concat(`parse_t_actions, [433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, 437, 437, 437, 437, 437, 437, 437, 437, 437, 437, 437, 437, 437])
`parse_t_entries = `concat(`parse_t_entries, [39222, 39223, 39224, 39225, 39226, 39227, 39228, 39229, 39175, 39179, 39199, 39212, 39360, 39361, 39357, 39358, 39375, 39376, 39377, 39378, 39379, 39362, 39363, 39364, 39365, 39366, 39367, 39368, 39369, 39370, 39371, 39372])
`parse_t_actions = `concat(`parse_t_actions, [437, 437, 437, 437, 437, 437, 437, 437, 437, 437, 437, 437, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, 441])
`parse_t_entries = `concat(`parse_t_entries, [39373, 39319, 39323, 39343, 39356, 39504, 39505, 39501, 39502, 39519, 39520, 39521, 39522, 39523, 39506, 39507, 39508, 39509, 39510, 39511, 39512, 39513, 39514, 39515, 39516, 39517, 39463, 39467, 39487, 39500, 39662, 39656])
`parse_t_actions = `concat(`parse_t_actions, [441, 441, 441, 441, 441, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 445, 130, 134])
`parse_t_entries = `concat(`parse_t_entries, [39657, 39647, 39610, 39638, 39643, 39668, 39674, 39675, 39676, 39677, 39678, 39679, 39680, 39681, 39682, 39683, 39684, 39685, 39686, 39687, 39688, 39689, 39690, 39691, 39692, 39693, 39694, 39695, 39696, 39697, 39698, 39708])
`parse_t_actions = `concat(`parse_t_actions, [138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58])
`parse_t_entries = `concat(`parse_t_entries, [39726, 39727, 39728, 39741, 39806, 39800, 39801, 39791, 39754, 39782, 39787, 39812, 39818, 39819, 39820, 39821, 39822, 39823, 39824, 39825, 39826, 39827, 39828, 39829, 39830, 39831, 39832, 39833, 39834, 39835, 39836, 39837])
`parse_t_actions = `concat(`parse_t_actions, [1191, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234])
`parse_t_entries = `concat(`parse_t_entries, [39838, 39839, 39840, 39841, 39842, 39852, 39870, 39871, 39872, 39885, 39950, 39944, 39945, 39935, 39898, 39926, 39931, 39956, 39962, 39963, 39964, 39965, 39966, 39967, 39968, 39969, 39970, 39971, 39972, 39973, 39974, 39975])
`parse_t_actions = `concat(`parse_t_actions, [238, 242, 246, 250, 254, 58, 1195, 263, 267, 271, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210])
`parse_t_entries = `concat(`parse_t_entries, [39976, 39977, 39978, 39979, 39980, 39981, 39982, 39983, 39984, 39985, 39986, 39996, 40014, 40015, 40016, 40029, 40080, 40081, 40077, 40078, 40095, 40096, 40097, 40098, 40099, 40082, 40083, 40084, 40085, 40086, 40087, 40088])
`parse_t_actions = `concat(`parse_t_actions, [214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1199, 263, 267, 271, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465, 465])
`parse_t_entries = `concat(`parse_t_entries, [40089, 40090, 40091, 40092, 40093, 40039, 40043, 40063, 40076, 40224, 40225, 40221, 40222, 40239, 40240, 40241, 40242, 40243, 40226, 40227, 40228, 40229, 40230, 40231, 40232, 40233, 40234, 40235, 40236, 40237, 40183, 40187])
`parse_t_actions = `concat(`parse_t_actions, [465, 465, 465, 465, 465, 465, 465, 465, 465, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469, 469])
`parse_t_entries = `concat(`parse_t_entries, [40207, 40220, 40368, 40369, 40365, 40366, 40383, 40384, 40385, 40386, 40387, 40370, 40371, 40372, 40373, 40374, 40375, 40376, 40377, 40378, 40379, 40380, 40381, 40327, 40331, 40351, 40364, 40512, 40513, 40509, 40510, 40527])
`parse_t_actions = `concat(`parse_t_actions, [469, 469, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 473, 477, 477, 477, 477, 477])
`parse_t_entries = `concat(`parse_t_entries, [40528, 40529, 40530, 40531, 40514, 40515, 40516, 40517, 40518, 40519, 40520, 40521, 40522, 40523, 40524, 40525, 40471, 40475, 40495, 40508, 40656, 40657, 40653, 40654, 40671, 40672, 40673, 40674, 40675, 40658, 40659, 40660])
`parse_t_actions = `concat(`parse_t_actions, [477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, 481])
`parse_t_entries = `concat(`parse_t_entries, [40661, 40662, 40663, 40664, 40665, 40666, 40667, 40668, 40669, 40615, 40619, 40639, 40652, 40814, 40808, 40809, 40799, 40762, 40790, 40795, 40820, 40826, 40827, 40828, 40829, 40830, 40831, 40832, 40833, 40834, 40835, 40836])
`parse_t_actions = `concat(`parse_t_actions, [481, 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, 481, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198])
`parse_t_entries = `concat(`parse_t_entries, [40837, 40838, 40839, 40840, 40841, 40842, 40843, 40844, 40845, 40846, 40847, 40848, 40849, 40850, 40860, 40878, 40879, 40880, 40893, 40907, 41051, 41071, 41195, 41339, 41482, 41626, 41808, 41809, 41805, 41806, 41823, 41824])
`parse_t_actions = `concat(`parse_t_actions, [202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1203, 263, 267, 271, 609, 581, 581, 561, 1206, 1210, 1214, 446, 450, 454, 458, 462, 466])
`parse_t_entries = `concat(`parse_t_entries, [41825, 41826, 41827, 41810, 41811, 41812, 41813, 41814, 41815, 41816, 41817, 41818, 41819, 41820, 41821, 41771, 41915, 42055, 42240, 42241, 42237, 42238, 42255, 42256, 42257, 42258, 42259, 42242, 42243, 42244, 42245, 42246])
`parse_t_actions = `concat(`parse_t_actions, [470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 489, 1218, 153, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498])
`parse_t_entries = `concat(`parse_t_entries, [42247, 42248, 42249, 42250, 42251, 42252, 42253, 42203, 42223, 42384, 42385, 42381, 42382, 42399, 42400, 42401, 42402, 42403, 42386, 42387, 42388, 42389, 42390, 42391, 42392, 42393, 42394, 42395, 42396, 42397, 42347, 42528])
`parse_t_actions = `concat(`parse_t_actions, [502, 506, 510, 514, 518, 522, 526, 1222, 1226, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1230, 446])
`parse_t_entries = `concat(`parse_t_entries, [42529, 42525, 42526, 42543, 42544, 42545, 42546, 42547, 42530, 42531, 42532, 42533, 42534, 42535, 42536, 42537, 42538, 42539, 42540, 42541, 42491, 42511, 42672, 42673, 42669, 42670, 42687, 42688, 42689, 42690, 42691, 42674])
`parse_t_actions = `concat(`parse_t_actions, [450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1234, 1238, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482])
`parse_t_entries = `concat(`parse_t_entries, [42675, 42676, 42677, 42678, 42679, 42680, 42681, 42682, 42683, 42684, 42685, 42635, 42816, 42817, 42813, 42814, 42831, 42832, 42833, 42834, 42835, 42818, 42819, 42820, 42821, 42822, 42823, 42824, 42825, 42826, 42827, 42828])
`parse_t_actions = `concat(`parse_t_actions, [486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1242, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522])
`parse_t_entries = `concat(`parse_t_entries, [42829, 42779, 42960, 42961, 42957, 42958, 42975, 42976, 42977, 42978, 42979, 42962, 42963, 42964, 42965, 42966, 42967, 42968, 42969, 42970, 42971, 42972, 42973, 42923, 43104, 43105, 43101, 43102, 43119, 43120, 43121, 43122])
`parse_t_actions = `concat(`parse_t_actions, [526, 1246, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1250, 446, 450, 454, 458, 462, 466, 470, 474])
`parse_t_entries = `concat(`parse_t_entries, [43123, 43106, 43107, 43108, 43109, 43110, 43111, 43112, 43113, 43114, 43115, 43116, 43117, 43067, 43248, 43249, 43245, 43246, 43263, 43264, 43265, 43266, 43267, 43250, 43251, 43252, 43253, 43254, 43255, 43256, 43257, 43258])
`parse_t_actions = `concat(`parse_t_actions, [478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1254, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514])
`parse_t_entries = `concat(`parse_t_entries, [43259, 43260, 43261, 43211, 43231, 43351, 43550, 43544, 43545, 43535, 43498, 43526, 43531, 43556, 43562, 43563, 43564, 43565, 43566, 43567, 43568, 43569, 43570, 43571, 43572, 43573, 43574, 43575, 43576, 43577, 43578, 43579])
`parse_t_actions = `concat(`parse_t_actions, [518, 522, 526, 1258, 1262, 65, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226])
`parse_t_entries = `concat(`parse_t_entries, [43580, 43581, 43582, 43583, 43584, 43585, 43586, 43596, 43499, 43614, 43615, 43616, 43617, 43629, 43643, 43783, 43927, 44126, 44120, 44121, 44111, 44074, 44102, 44107, 44132, 44138, 44139, 44140, 44141, 44142, 44143, 44144])
`parse_t_actions = `concat(`parse_t_actions, [230, 234, 238, 242, 246, 250, 254, 58, 485, 1163, 263, 267, 1267, 271, 1270, 149, 137, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182])
`parse_t_entries = `concat(`parse_t_entries, [44145, 44146, 44147, 44148, 44149, 44150, 44151, 44152, 44153, 44154, 44155, 44156, 44157, 44158, 44159, 44160, 44161, 44162, 44172, 44190, 44191, 44192, 44205, 44215, 44400, 44401, 44397, 44398, 44415, 44416, 44417, 44418])
`parse_t_actions = `concat(`parse_t_actions, [186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1275, 263, 267, 271, 145, 345, 345, 345, 345, 345, 345, 345, 345])
`parse_t_entries = `concat(`parse_t_entries, [44419, 44402, 44403, 44404, 44405, 44406, 44407, 44408, 44409, 44410, 44411, 44412, 44413, 44359, 44363, 44383, 44396, 44558, 44552, 44553, 44543, 44506, 44534, 44539, 44564, 44570, 44571, 44572, 44573, 44574, 44575, 44576])
`parse_t_actions = `concat(`parse_t_actions, [345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 345, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170, 174, 178, 182])
`parse_t_entries = `concat(`parse_t_entries, [44577, 44578, 44579, 44580, 44581, 44582, 44583, 44584, 44585, 44586, 44587, 44588, 44589, 44590, 44591, 44592, 44593, 44594, 44604, 44622, 44623, 44624, 44637, 44688, 44689, 44685, 44686, 44703, 44704, 44705, 44706, 44707])
`parse_t_actions = `concat(`parse_t_actions, [186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1279, 263, 267, 271, 413, 413, 413, 413, 413, 413, 413, 413, 413])
`parse_t_entries = `concat(`parse_t_entries, [44690, 44691, 44692, 44693, 44694, 44695, 44696, 44697, 44698, 44699, 44700, 44701, 44647, 44651, 44671, 44684, 44832, 44833, 44829, 44830, 44847, 44848, 44849, 44850, 44851, 44834, 44835, 44836, 44837, 44838, 44839, 44840])
`parse_t_actions = `concat(`parse_t_actions, [413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 413, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449])
`parse_t_entries = `concat(`parse_t_entries, [44841, 44842, 44843, 44844, 44845, 44791, 44795, 44815, 44828, 44976, 44977, 44973, 44974, 44991, 44992, 44993, 44994, 44995, 44978, 44979, 44980, 44981, 44982, 44983, 44984, 44985, 44986, 44987, 44988, 44989, 44935, 44939])
`parse_t_actions = `concat(`parse_t_actions, [449, 449, 449, 449, 449, 449, 449, 449, 449, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453])
`parse_t_entries = `concat(`parse_t_entries, [44959, 44972, 45120, 45121, 45117, 45118, 45135, 45136, 45137, 45138, 45139, 45122, 45123, 45124, 45125, 45126, 45127, 45128, 45129, 45130, 45131, 45132, 45133, 45079, 45083, 45103, 45116, 45264, 45265, 45261, 45262, 45279])
`parse_t_actions = `concat(`parse_t_actions, [453, 453, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 373, 373, 373, 373, 373])
`parse_t_entries = `concat(`parse_t_entries, [45280, 45281, 45282, 45283, 45266, 45267, 45268, 45269, 45270, 45271, 45272, 45273, 45274, 45275, 45276, 45277, 45223, 45227, 45247, 45260, 45422, 45416, 45417, 45407, 45370, 45398, 45403, 45428, 45434, 45435, 45436, 45437])
`parse_t_actions = `concat(`parse_t_actions, [373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 373, 130, 134, 138, 142, 146, 26, 150, 154, 158, 162, 166, 170])
`parse_t_entries = `concat(`parse_t_entries, [45438, 45439, 45440, 45441, 45442, 45443, 45444, 45445, 45446, 45447, 45448, 45449, 45450, 45451, 45452, 45453, 45454, 45455, 45456, 45457, 45458, 45468, 45486, 45487, 45488, 45501, 45515, 45655, 45840, 45841, 45837, 45838])
`parse_t_actions = `concat(`parse_t_actions, [174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 58, 1283, 263, 267, 271, 1286, 61, 446, 450, 454, 458])
`parse_t_entries = `concat(`parse_t_entries, [45855, 45856, 45857, 45858, 45859, 45842, 45843, 45844, 45845, 45846, 45847, 45848, 45849, 45850, 45851, 45852, 45853, 45803, 45984, 45985, 45981, 45982, 45999, 46000, 46001, 46002, 46003, 45986, 45987, 45988, 45989, 45990])
`parse_t_actions = `concat(`parse_t_actions, [462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1290, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498])
`parse_t_entries = `concat(`parse_t_entries, [45991, 45992, 45993, 45994, 45995, 45996, 45997, 45947, 46128, 46129, 46125, 46126, 46143, 46144, 46145, 46146, 46147, 46130, 46131, 46132, 46133, 46134, 46135, 46136, 46137, 46138, 46139, 46140, 46141, 46091, 46231, 46375])
`parse_t_actions = `concat(`parse_t_actions, [502, 506, 510, 514, 518, 522, 526, 1294, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510, 514, 518, 522, 526, 1298, 57, 141])
`parse_t_entries = `concat(`parse_t_entries, [46560, 46561, 46557, 46558, 46575, 46576, 46577, 46578, 46579, 46562, 46563, 46564, 46565, 46566, 46567, 46568, 46569, 46570, 46571, 46572, 46573, 46519, 46523, 46543, 46556, 46704, 46705, 46701, 46702, 46719, 46720, 46721])
`parse_t_actions = `concat(`parse_t_actions, [349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 349, 377, 377, 377, 377, 377, 377, 377])
`parse_t_entries = `concat(`parse_t_entries, [46722, 46723, 46706, 46707, 46708, 46709, 46710, 46711, 46712, 46713, 46714, 46715, 46716, 46717, 46663, 46667, 46687, 46700])
`parse_t_actions = `concat(`parse_t_actions, [377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, 377])

FUNC `tokenIdToString(`token_id):
  IF (`token_id <= 0) OR (`token_id >= `length(`parse_y_t_strings)):
    `warning("Prequel"+" "+"Lexer"+" "+"tokenIdToString"+":"+" "+"unknown"+" "+"id"+":", `token_id)
    `token_id = 0
  ENDIF
  VAR `token_str = `parse_y_t_strings[`token_id]
  return `token_str
ENDFUNC

FUNC `tokenStringToId(`token_str):
  VAR `token_id = `indexof(`parse_y_t_strings, `token_str)
  IF `token_id <= 0:
    `warning("Prequel"+" "+"Lexer"+" "+"tokenStringToId"+":"+" "+"unknown"+" "+"string"+":", `token_str)
    `token_id = 0
  ENDIF
  return `token_id
ENDFUNC

CLASS `Lexer:

  METHOD_INIT():
    THIS.`_reserved_words = []
    `push(THIS.`_reserved_words, "IF")
    `push(THIS.`_reserved_words, "ELIF")
    `push(THIS.`_reserved_words, "ELSE")
    `push(THIS.`_reserved_words, "ENDIF")
    `push(THIS.`_reserved_words, "REPEAT")
    `push(THIS.`_reserved_words, "REPSTOP")
    `push(THIS.`_reserved_words, "REPNEXT")
    `push(THIS.`_reserved_words, "BREAK")
    `push(THIS.`_reserved_words, "CONTINUE")
    `push(THIS.`_reserved_words, "ENDREP")
    `push(THIS.`_reserved_words, "PRINT")
    `push(THIS.`_reserved_words, "OR")
    `push(THIS.`_reserved_words, "AND")
    `push(THIS.`_reserved_words, "NOT")
    `push(THIS.`_reserved_words, "IS")
    `push(THIS.`_reserved_words, "NUMBER")
    `push(THIS.`_reserved_words, "LIST")
    `push(THIS.`_reserved_words, "EMPTY")
    `push(THIS.`_reserved_words, "PROCEDURE")
    `push(THIS.`_reserved_words, "RANDOM")
    `push(THIS.`_reserved_words, "UNDEFINED")

    THIS.`_reserved_vlast_words = []
    `push(THIS.`_reserved_vlast_words, "UNASSIGN")
    `push(THIS.`_reserved_vlast_words, "LENGTH")
    `push(THIS.`_reserved_vlast_words, "PUSH")
    `push(THIS.`_reserved_vlast_words, "QUEUE")
    `push(THIS.`_reserved_vlast_words, "POP")
    `push(THIS.`_reserved_vlast_words, "UNQUEUE")
    `push(THIS.`_reserved_vlast_words, "INDEXOF")

    THIS.`_reserved_qlast_words = []
    `push(THIS.`_reserved_qlast_words, "LENGTH")
    `push(THIS.`_reserved_qlast_words, "INDEXOF")

  METHOD `isModuleNameCharStart(`c):
    return (((`c >= "a") AND (`c <= "z")) OR ((`c >= "A") AND (`c <= "Z")) OR (`c == "_"))

  METHOD `isModuleNameChar(`c):
    return (((`c >= "0") AND (`c <= "9")) OR ((`c >= "a") AND (`c <= "z")) OR ((`c >= "A") AND (`c <= "Z")) OR (`c == "_"))

  METHOD `isValidModuleName(`module_name):
    VAR `j
    IF `not(`is_type_str(`get_type(`module_name))):
      return FALSE
    ENDIF
    IF `length(`module_name) == 0:
      return FALSE
    ENDIF
    IF `not(THIS.`isModuleNameCharStart(`module_name[0])):
      return FALSE
    ENDIF
    FORINCR `j(1 `length(`module_name)):
      IF `not(THIS.`isModuleNameChar(`module_name[`j])):
        return FALSE
      ENDIF
    ENDFOR
    return TRUE

  METHOD `isValidSourceCode(`source_code):
    VAR `j
    VAR `chrcode_j
    IF `not(`is_type_str(`get_type(`source_code))):
      return FALSE
    ENDIF
    FORINCR `j(0 `length(`source_code)):
      `chrcode_j = `char_code_at(`source_code, `j)
      IF `chrcode_j != 9 AND `chrcode_j != 10 AND `chrcode_j != 13 AND (`chrcode_j < 32 OR `chrcode_j > 126):
        return FALSE
      ENDIF
    ENDFOR
    return TRUE

  METHOD `normalize(`source_code):
    VAR `splits
    VAR `j
    `splits = `split(`source_code, `chr_tab)
    `source_code = `splits[0]
    FORINCR `j(1 `length(`splits)):
      `source_code += " "+`splits[`j]
    ENDFOR
    `splits = `split(`source_code, `chr_cr)
    `source_code = `splits[0]
    FORINCR `j(1 `length(`splits)):
      `source_code += `splits[`j]
    ENDFOR
    return `source_code

  METHOD `tokenId(`token):
    return `token[0]

  METHOD `tokenColumn(`token):
    return `token[1]

  METHOD `tokenValue(`token):
    return `token[2]

  METHOD `tokenExtra(`token):
    IF `length(`token) <= 3:
      return NULL
    ENDIF
    return `token[3]

  METHOD `memberOf(`s `i `e `l):
    VAR `len_
    VAR `isEq
    VAR `j
    VAR `j2
    `len_ = `e-`i
    FORINCR `j(0 `length(`l)):
      IF `length(`l[`j]) != `len_:
        continue
      ENDIF
      `isEq = TRUE
      FORINCR `j2(0 `len_):
        IF `s[`i+`j2] != `l[`j][`j2]:
          `isEq = FALSE
          break
        ENDIF
      ENDFOR
      IF `isEq:
        return TRUE
      ENDIF
    ENDFOR
    return FALSE

  METHOD `isValidVarname(`varname):
    IF `not(`is_type_str(`get_type(`varname))):
      return FALSE
    ENDIF
    IF `length(`varname) == 0:
      return FALSE
    ENDIF
    `varname = `uppercase(`varname)
    IF ((`varname[0] < "A") OR (`varname[0] > "Z")) AND (`varname[0] != "_"):
      return FALSE
    ENDIF
    VAR `dotCount
    VAR `lastDotIdx
    VAR `startIdx
    VAR `j
    `dotCount = 0
    FORINCR `j(1 `length(`varname)):
      IF `varname[`j] == ".":
        `startIdx = TERNARY{`dotCount == 0}{0}{`lastDotIdx+1}
        IF `j-`startIdx == 0:
          return FALSE
        ENDIF
        IF `varname[`startIdx] >= "0" AND `varname[`startIdx] <= "9":
          return FALSE
        ENDIF
        `dotCount += 1
        `lastDotIdx = `j
        continue
      ENDIF
      IF ((`varname[`j] >= "0") AND (`varname[`j] <= "9")) OR ((`varname[`j] >= "A") AND (`varname[`j] <= "Z")) OR (`varname[`j] == "_"):
        continue
      ENDIF
      return FALSE
    ENDFOR
    IF `dotCount == 0:
      return FALSE
    ENDIF
    `startIdx = `lastDotIdx+1
    IF `length(`varname)-`startIdx == 0:
      return FALSE
    ENDIF
    IF `varname[`startIdx] >= "0" AND `varname[`startIdx] <= "9":
      return FALSE
    ENDIF
    IF THIS.`memberOf(`varname, `startIdx, `length(`varname), THIS.`_reserved_vlast_words):
      return FALSE
    ENDIF
    return TRUE

  METHOD `isValidIvarname(`ivarname):
    IF `not(`is_type_str(`get_type(`ivarname))):
      return FALSE
    ENDIF
    IF `length(`ivarname) == 0:
      return FALSE
    ENDIF
    `ivarname = `uppercase(`ivarname)
    IF ((`ivarname[0] < "A") OR (`ivarname[0] > "Z")) AND (`ivarname[0] != "_"):
      return FALSE
    ENDIF
    VAR `j
    FORINCR `j(1 `length(`ivarname)):
      IF ((`ivarname[`j] >= "0") AND (`ivarname[`j] <= "9")) OR ((`ivarname[`j] >= "A") AND (`ivarname[`j] <= "Z")) OR (`ivarname[`j] == "_"):
        continue
      ENDIF
      return FALSE
    ENDFOR
    IF THIS.`memberOf(`ivarname, 0, `length(`ivarname), THIS.`_reserved_words):
      return FALSE
    ENDIF
    IF THIS.`memberOf(`ivarname, 0, `length(`ivarname), THIS.`_reserved_vlast_words):
      return FALSE
    ENDIF
    return TRUE

  METHOD `isVarChar(`c):
    return (((`c >= "0") AND (`c <= "9")) OR ((`c >= "a") AND (`c <= "z")) OR ((`c >= "A") AND (`c <= "Z")) OR (`c == "_") OR (`c == "."))

  METHOD `isTokenEndSpace(`l `start `token):
    VAR `j
    FORINCR `j(1 `length(`token)):
      IF `uppercase(`l[`start+`j]) != `token[`j]:
        return FALSE
      ENDIF
    ENDFOR
    return (`l[`start+`length(`token)] == " ")

  METHOD `isTokenEndOther(`l `start `token):
    VAR `j
    FORINCR `j(1 `length(`token)):
      IF `uppercase(`l[`start+`j]) != `token[`j]:
        return FALSE
      ENDIF
    ENDFOR
    return `not(THIS.`isVarChar(`l[`start+`length(`token)]))

  METHOD `lexLine(`line):
    `line += " "+`chr_lf
    VAR `ic
    VAR `tname
    VAR `tlen
    VAR `textra
    VAR `col = 0
    VAR `start
    WHILE `line[`col] == " ":
      `col += 1
    ENDWHILE
    IF `line[`col] == `chr_lf:
      return [[`key_token_INDENT, 0, `substring(`line, 0, `col-1)], [`key_token_NEWLINE, `length(`line)-2, `chr_lf]]
    ENDIF
    VAR `tokens = []
    VAR `nonzero
    VAR `j
    VAR `subtextras
    VAR `error_msg
    VAR `literal
    VAR `var_op
    VAR `indexof_csvar
    VAR `token
    `push(`tokens, [`key_token_INDENT, 0, `substring(`line, 0, `col)])
    WHILE TRUE:
      IF `line[`col] == " ":
        `start = `col
        WHILE `line[`col] == " ":
          `col += 1
        ENDWHILE
        IF `line[`col] == `chr_lf:
          IF `col-`start == 1:
            break
          ENDIF
          `push(`tokens, [`key_token_SPACES, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        `push(`tokens, [`key_token_SPACES, `start, `substring(`line, `start, `col)])
      ENDIF
      `ic = `uppercase(`line[`col])
      IF `ic == "I":
        `tname = "IF"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_IF, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "IS"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_IS, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "ISNOT"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_IS_NOT, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "R":
        `tname = "REPEAT"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_REPEAT, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "REPSTOP"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_REPSTOP, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "REPNEXT"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_REPNEXT, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "RANDOM"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_RANDOM, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "RETURN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_RETURN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "L":
        `tname = "LIST"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_LIST, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "A":
        `tname = "AND"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_AND, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "P":
        `tname = "PROCEDURE"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_PROCEDURE, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "PRINT"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_DEBUGL, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "E":
        `tname = "ENDIF"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_ENDIF, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "ENDREP"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_ENDREP, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "ELSE"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_ELSE, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "ELIF"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_ELSIF, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "EMPTY"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_EMPTY, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "N":
        `tname = "NOT"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_NOT, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
        `tname = "NUMBER"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_NUMBER, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "O":
        `tname = "OR"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_OR, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "U":
        `tname = "UNDEFINED"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_UNDEFINED, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `line[`col] == "+":
        IF `line[`col+1] == "+":
          `push(`tokens, [`key_token_ASSIGN_OP_INCR, `col, "++"])
          `col += 2
          continue
        ENDIF
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_PLUS, `col, "+="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_PLUS, `col, "+"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "-":
        IF `line[`col+1] == "-":
          `push(`tokens, [`key_token_ASSIGN_OP_DECR, `col, "--"])
          `col += 2
          continue
        ENDIF
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_MINUS, `col, "-="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_MINUS, `col, "-"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "*":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_MUL, `col, "*="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_MUL, `col, "*"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "/":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_DIV, `col, "/="])
          `col += 2
          continue
        ELSIF `line[`col+1] == "/":
          IF `line[`col+2] == "=":
            `push(`tokens, [`key_token_ASSIGN_OP_IDV, `col, "//="])
            `col += 3
            continue
          ENDIF
          `push(`tokens, [`key_token_IDV, `col, "//"])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_DIV, `col, "/"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "%":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_MOD, `col, "%="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_MOD, `col, "%"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "&":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_BIT_AND, `col, "&="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_BIT_AND, `col, "&"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "^":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_BIT_XOR, `col, "^="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_BIT_XOR, `col, "^"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "|":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_BIT_OR, `col, "|="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_BIT_OR, `col, "|"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "~":
        IF `line[`col+1] == "~":
          `push(`tokens, [`key_token_ASSIGN_OP_TOGGLE, `col, "~~"])
          `col += 2
          continue
        ENDIF
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_ASSIGN_OP_RANDOM, `col, "~="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_BIT_NOT, `col, "~"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "(":
        `push(`tokens, [`key_token_LPAR, `col, "("])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == ")":
        `push(`tokens, [`key_token_RPAR, `col, ")"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "[":
        `push(`tokens, [`key_token_LSQR, `col, "["])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "]":
        `push(`tokens, [`key_token_RSQR, `col, "]"])
        `col += 1
        IF `line[`col] == ".":
          `start = `col
          `col += 1
          WHILE ((`line[`col] >= "A") AND (`line[`col] <= "Z")) OR ((`line[`col] >= "a") AND (`line[`col] <= "z")):
            `col += 1
          ENDWHILE
          `textra = `uppercase(`substring(`line, `start+1, `col))
          IF `indexof(THIS.`_reserved_vlast_words, `textra) < 0:
            `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "UNEXPECTED"+" "+"SUFFIX"])
            `start = `col
            WHILE `line[`col] != `chr_lf:
              `col += 1
            ENDWHILE
            `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
            break
          ENDIF
          `token = `tokenStringToId(`textra)
          `push(`tokens, [`token, `start, `substring(`line, `start, `col)])
          continue
        ENDIF
        continue
      ENDIF
      IF `line[`col] == ",":
        `push(`tokens, [`key_token_COMMA, `col, ","])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "=":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_EQ, `col, "=="])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_ASSIGN_OP, `col, "="])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "<":
        IF `line[`col+1] == ">":
          `push(`tokens, [`key_token_NE, `col, "<>"])
          `col += 2
          continue
        ENDIF
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_LE, `col, "<="])
          `col += 2
          continue
        ENDIF
        IF `line[`col+1] == "<":
          IF `line[`col+2] == "=":
            `push(`tokens, [`key_token_ASSIGN_OP_BIT_SHL, `col, "<<="])
            `col += 3
            continue
          ENDIF
          `push(`tokens, [`key_token_BIT_SHL, `col, "<<"])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_LT, `col, "<"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == ">":
        IF `line[`col+1] == "=":
          `push(`tokens, [`key_token_GE, `col, ">="])
          `col += 2
          continue
        ENDIF
        IF `line[`col+1] == ">":
          IF `line[`col+2] == "=":
            `push(`tokens, [`key_token_ASSIGN_OP_BIT_SHR, `col, ">>="])
            `col += 3
            continue
          ENDIF
          `push(`tokens, [`key_token_BIT_SHR, `col, ">>"])
          `col += 2
          continue
        ENDIF
        `push(`tokens, [`key_token_GT, `col, ">"])
        `col += 1
        continue
      ENDIF
      IF `line[`col] == "!":
        `start = `col
        `col += 1
        IF ((`line[`col] < "a") OR (`line[`col] > "z")) AND ((`line[`col] < "A") OR (`line[`col] > "Z")) AND (`line[`col] != "_"):
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "EXPECTED"+" "+"VARIABLE"+" "+"NAME"+" "+"AFTER"+" "+"CALLSTACK"+"-"+"VARIABLE"+" "+"OPERATOR"])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        `col += 1
        WHILE ((`line[`col] >= "0") AND (`line[`col] <= "9")) OR ((`line[`col] >= "a") AND (`line[`col] <= "z")) OR ((`line[`col] >= "A") AND (`line[`col] <= "Z")) OR (`line[`col] == "_"):
          `col += 1
        ENDWHILE
        `textra = `substring(`line, `start+1, `col)
        `error_msg = NULL
        `textra = `uppercase(`textra)
        IF `indexof(THIS.`_reserved_words, `textra) >= 0:
          `error_msg = "RESERVED"+" "+"WORD"
        ELSIF `indexof(THIS.`_reserved_vlast_words, `textra) >= 0:
          `error_msg = "RESERVED"+" "+"WORD"
        ENDIF
        IF `not(`isnull(`error_msg)):
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), `error_msg])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        IF `line[`col] == "@":
          `indexof_csvar = `col
          `col += 1
          IF `not(THIS.`isModuleNameCharStart(`line[`col])):
            `textra = `lowercase(`textra)
            `push(`tokens, [`key_token_CSVAR, `start, `substring(`line, `start, `col-1), `textra])
            `start = `col-1
            `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "MISSING"+" "+"MODULE"+" "+"NAME"])
            `start = `col
            WHILE `line[`col] != `chr_lf:
              `col += 1
            ENDWHILE
            `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
            break
          ENDIF
          `col += 1
          WHILE THIS.`isModuleNameChar(`line[`col]):
            `col += 1
          ENDWHILE
          `textra = `lowercase(`substring(`line, `start+1, `indexof_csvar))+"@"+`uppercase(`substring(`line, `indexof_csvar+1, `col))
        ELSE:
          `textra = `lowercase(`substring(`line, `start+1, `col))
        ENDIF
        `push(`tokens, [`key_token_CSVAR, `start, `substring(`line, `start, `col), `textra])
        IF `line[`col] == ".":
          `start = `col
          `col += 1
          WHILE ((`line[`col] >= "A") AND (`line[`col] <= "Z")) OR ((`line[`col] >= "a") AND (`line[`col] <= "z")):
            `col += 1
          ENDWHILE
          `textra = `uppercase(`substring(`line, `start+1, `col))
          IF `indexof(THIS.`_reserved_vlast_words, `textra) < 0:
            `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "UNEXPECTED"+" "+"SUFFIX"])
            `start = `col
            WHILE `line[`col] != `chr_lf:
              `col += 1
            ENDWHILE
            `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
            break
          ENDIF
          `token = `tokenStringToId(`textra)
          `push(`tokens, [`token, `start, `substring(`line, `start, `col)])
          continue
        ENDIF
        continue
      ENDIF
      IF `line[`col] == "@":
        `start = `col
        `col += 1
        IF THIS.`isModuleNameCharStart(`line[`col]):
          `col += 1
          WHILE THIS.`isModuleNameChar(`line[`col]):
            `col += 1
          ENDWHILE
        ENDIF
        IF `start+1 == `col:
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "MISSING"+" "+"MODULE"+" "+"NAME"])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        `textra = `uppercase(`substring(`line, `start+1, `col))
        `push(`tokens, [`key_token_MODULE_NAME, `start, `substring(`line, `start, `col), `textra])
        continue
      ENDIF
      IF `line[`col] == `chr_quote:
        `start = `col
        `col += 1
        `textra = ""
        WHILE TRUE:
          IF `line[`col] == `chr_quote:
            `col += 1
            break
          ENDIF
          IF `line[`col] == `chr_lf:
            `textra = NULL
            `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col-1), "UNEXPECTED"+" "+"END"+" "+"OF"+" "+"STRING"])
            `push(`tokens, [`key_token_POSTERROR, `col-1, ""])
            break
          ENDIF
          IF `line[`col] != "\\":
            `textra += `line[`col]
            `col += 1
            continue
          ENDIF
          `textra += "\\"
          `col += 1
          IF `line[`col] == `chr_lf:
            `textra = NULL
            `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col-1), "UNEXPECTED"+" "+"END"+" "+"OF"+" "+"STRING"])
            `push(`tokens, [`key_token_POSTERROR, `col-1, ""])
            break
          ENDIF
          `textra += `line[`col]
          `col += 1
          continue
        ENDWHILE
        IF `isnull(`textra):
          break
        ENDIF
        `push(`tokens, [`key_token_STRING, `start, `substring(`line, `start, `col), `textra])
        continue
      ENDIF
      IF `line[`col] == "#":
        `start = `col
        `col += 1
        WHILE `line[`col] != `chr_lf:
          `col += 1
        ENDWHILE
        `push(`tokens, [`key_token_COMMENT, `start, `substring(`line, `start, `col-1)])
        break
      ENDIF
      IF (`line[`col] == "0") AND (`lowercase(`line[`col+1]) == "x") AND (((`line[`col+2] >= "0") AND (`line[`col+2] <= "9")) OR ((`line[`col+2] >= "a") AND (`line[`col+2] <= "f")) OR ((`line[`col+2] >= "A") AND (`line[`col+2] <= "F"))):
        `start = `col
        `col += 3
        WHILE ((`line[`col] >= "0") AND (`line[`col] <= "9")) OR ((`line[`col] >= "a") AND (`line[`col] <= "f")) OR ((`line[`col] >= "A") AND (`line[`col] <= "F")):
          `col += 1
        ENDWHILE
        IF `col-`start > 6:
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "HEXADECIMAL"+" "+"NUMBER"+" "+"EXCEEDS"+" "+"SIGNED"+" "+"16"+" "+"BITS"])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        IF (`line[`col] == ".") AND (((`line[`col+1] >= "0") AND (`line[`col+1] <= "9")) OR ((`line[`col+1] >= "a") AND (`line[`col+1] <= "f")) OR ((`line[`col+1] >= "A") AND (`line[`col+1] <= "F"))):
          `col += 2
          WHILE ((`line[`col] >= "0") AND (`line[`col] <= "9")) OR ((`line[`col] >= "a") AND (`line[`col] <= "f")) OR ((`line[`col] >= "A") AND (`line[`col] <= "F")):
            `col += 1
          ENDWHILE
        ENDIF
        `literal = `split(`substring(`line, `start, `col), ".")
        `literal[0] = `parse_int(`substring(`literal[0], 2, `length(`literal[0])), 16)
        IF `length(`literal) > 1:
          `literal[1] = `substring(`literal[1], 0, 4)
          WHILE `length(`literal[1]) < 4:
            `literal[1] += "0"
          ENDWHILE
          `literal[0] += `parse_int(`literal[1], 16)/65536.0
        ENDIF
        `push(`tokens, [`key_token_HEXADECIMAL, `start, `substring(`line, `start, `col), `fp[0].FromFloat(`literal[0])])
        continue
      ENDIF
      IF (`line[`col] == "0") AND (`lowercase(`line[`col+1]) == "b") AND (`line[`col+2] >= "0") AND (`line[`col+2] <= "1"):
        `start = `col
        `col += 3
        WHILE (`line[`col] >= "0") AND (`line[`col] <= "1"):
          `col += 1
        ENDWHILE
        IF `col-`start > 18:
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "BINARY"+" "+"NUMBER"+" "+"EXCEEDS"+" "+"SIGNED"+" "+"16"+" "+"BITS"])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        IF (`line[`col] == ".") AND (`line[`col+1] >= "0") AND (`line[`col+1] <= "1"):
          `col += 2
          WHILE (`line[`col] >= "0") AND (`line[`col] <= "1"):
            `col += 1
          ENDWHILE
        ENDIF
        `literal = `split(`substring(`line, `start, `col), ".")
        `literal[0] = `parse_int(`substring(`literal[0], 2, `length(`literal[0])), 2)
        IF `length(`literal) > 1:
          `literal[1] = `substring(`literal[1], 0, 16)
          WHILE `length(`literal[1]) < 16:
            `literal[1] += "0"
          ENDWHILE
          `literal[0] += `parse_int(`literal[1], 2)/65536.0
        ENDIF
        `push(`tokens, [`key_token_BINARY, `start, `substring(`line, `start, `col), `fp[0].FromFloat(`literal[0])])
        continue
      ENDIF
      IF (`line[`col] >= "0") AND (`line[`col] <= "9"):
        `start = `col
        `col += 1
        WHILE (`line[`col] >= "0") AND (`line[`col] <= "9"):
          `col += 1
        ENDWHILE
        `nonzero = `col
        FORINCR `j(`start `col):
          IF `line[`j] == "0":
            continue
          ENDIF
          `nonzero = `j
          break
        ENDFOR
        IF (`col-`nonzero > 5) OR (`parse_int(`substring(`line, `start, `col), 10) > 0xffff):
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), "NUMBER"+" "+"EXCEEDS"+" "+"SIGNED"+" "+"16"+" "+"BITS"])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        IF (`line[`col] == ".") AND (`line[`col+1] >= "0") AND (`line[`col+1] <= "9"):
          `col += 2
          WHILE (`line[`col] >= "0") AND (`line[`col] <= "9"):
            `col += 1
          ENDWHILE
        ENDIF
        `literal = `parse_float(`substring(`line, `start, `col))
        `push(`tokens, [`key_token_DECIMAL, `start, `substring(`line, `start, `col), `fp[0].FromFloat(`literal)])
        continue
      ENDIF
      IF `ic == "C":
        `tname = "CALL"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_CALL, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "CONTINUE"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_REPNEXT, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "B":
        `tname = "BREAK"
        IF THIS.`isTokenEndSpace(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_REPSTOP, `col, `substring(`line, `col, `col+`tlen)])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF `ic == "M":
        `tname = "MATH"+"."+"ABS"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_ABS, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"ACOS"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_ACOS, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"ASIN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_ASIN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"ATAN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_ATAN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"ATAN2"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_ATAN2, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"CEIL"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_CEIL, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"COS"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_COS, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"E"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_E, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"EXP"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_EXP, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"EXP2"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_EXP2, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"FLOOR"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_FLOOR, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"LOG"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_LOG, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"LOG2"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_LOG2, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"MAX"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_MAX, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"MIN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_MIN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"PI"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_PI, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"POW"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_POW, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"ROUND"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_ROUND, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"SIGN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_SIGN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"SIN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_SIN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"SQRT"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_SQRT, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
        `tname = "MATH"+"."+"TAN"
        IF THIS.`isTokenEndOther(`line, `col, `tname):
          `tlen = `length(`tname)
          `push(`tokens, [`key_token_MATH_TAN, `col, `substring(`line, `col, `col+`tlen), `tname])
          `col += `tlen
          continue
        ENDIF
      ENDIF
      IF ((`ic >= "A") AND (`ic <= "Z")) OR (`line[`col] == "_"):
        `start = `col
        `col += 1
        WHILE ((`line[`col] >= "0") AND (`line[`col] <= "9")) OR ((`line[`col] >= "a") AND (`line[`col] <= "z")) OR ((`line[`col] >= "A") AND (`line[`col] <= "Z")) OR (`line[`col] == "_") OR (`line[`col] == "."):
          `col += 1
        ENDWHILE
        `textra = `substring(`line, `start, `col)
        `subtextras = `split(`textra, ".")
        `error_msg = NULL
        FORINCR `j(0 `length(`subtextras)):
          IF `length(`subtextras[`j]) == 0:
            `error_msg = "INVALID"+" "+"VARIABLE"
            break
          ENDIF
          IF (`subtextras[`j][0] >= "0") AND (`subtextras[`j][0] <= "9"):
            `error_msg = "INVALID"+" "+"VARIABLE"
            break
          ENDIF
          `subtextras[`j] = `uppercase(`subtextras[`j])
        ENDFOR
        IF `isnull(`error_msg):
          IF `indexof(THIS.`_reserved_vlast_words, `subtextras[`length(`subtextras)-1]) >= 0:
            IF (`indexof(THIS.`_reserved_qlast_words, `subtextras[`length(`subtextras)-1]) < 0) AND (`length(`subtextras) > 2):
              `error_msg = "INVALID"+" "+"VARIABLE"
            ELSE:
              `var_op = `subtextras[`length(`subtextras)-1]
              `textra = `substring(`textra, 0, `length(`textra)-`length(`var_op)-1)
              `var_op = `tokenStringToId(`var_op)
              IF `length(`subtextras) == 1:
                `error_msg = "RESERVED"+" "+"WORD"
              ELSIF `length(`subtextras) > 2:
                `textra = `uppercase(`textra)
                IF `indexof(THIS.`_reserved_vlast_words, `subtextras[`length(`subtextras)-2]) >= 0:
                  `error_msg = "RESERVED"+" "+"WORD"
                ELSE:
                  `push(`tokens, [`key_token_EVAR, `start, `substring(`line, `start, `start+`length(`textra)), `textra])
                  `push(`tokens, [`var_op, `start+`length(`textra), `substring(`line, `start+`length(`textra), `col)])
                  continue
                ENDIF
              ELSE:
                `textra = `lowercase(`textra)
                IF `indexof(THIS.`_reserved_words, `subtextras[0]) >= 0:
                  `error_msg = "RESERVED"+" "+"WORD"
                ELSIF `indexof(THIS.`_reserved_vlast_words, `subtextras[0]) >= 0:
                  `error_msg = "RESERVED"+" "+"WORD"
                ELSE:
                  `push(`tokens, [`key_token_IVAR, `start, `substring(`line, `start, `start+`length(`textra)), `textra])
                  `push(`tokens, [`var_op, `start+`length(`textra), `substring(`line, `start+`length(`textra), `col)])
                  continue
                ENDIF
              ENDIF
            ENDIF
          ELSE:
            IF `length(`subtextras) > 1:
              `textra = `uppercase(`textra)
              `push(`tokens, [`key_token_EVAR, `start, `substring(`line, `start, `col), `textra])
              continue
            ELSE:
              IF `indexof(THIS.`_reserved_words, `subtextras[0]) >= 0:
                `error_msg = "RESERVED"+" "+"WORD"
              ELSE:
                `textra = `lowercase(`textra)
                `push(`tokens, [`key_token_IVAR, `start, `substring(`line, `start, `col), `textra])
                continue
              ENDIF
            ENDIF
          ENDIF
        ENDIF
        IF `not(`isnull(`error_msg)):
          `push(`tokens, [`key_token_ERROR, `start, `substring(`line, `start, `col), `error_msg])
          `start = `col
          WHILE `line[`col] != `chr_lf:
            `col += 1
          ENDWHILE
          `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
          break
        ENDIF
        continue
      ENDIF
      `push(`tokens, [`key_token_ERROR, `col, `substring(`line, `col, `col+1), "UNEXPECTED"+" "+"CHAR"])
      `col += 1
      `start = `col
      WHILE `line[`col] != `chr_lf:
        `col += 1
      ENDWHILE
      `push(`tokens, [`key_token_POSTERROR, `start, `substring(`line, `start, `col-1)])
      break
    ENDWHILE
    `push(`tokens, [`key_token_NEWLINE, `length(`line)-2, `chr_lf])
    return `tokens

ENDCLASS

VAR `lexer = NEW `Lexer()

VAR `UNARYOP_ = 0
VAR `UNARYOP_PLUS = 1
VAR `UNARYOP_MINUS = 2
VAR `UNARYOP_BIT_NOT = 3

VAR `OPCODE_ERROR = 0
VAR `OPCODE_SUFFIX = 1
VAR `OPCODE_AND = 2
VAR `OPCODE_ASSIGN_OP = 3
VAR `OPCODE_ASSIGN_OP_CSVAR = 4
VAR `OPCODE_ASSIGN_OP_RANDOM = 5
VAR `OPCODE_ASSIGN_POP = 6
VAR `OPCODE_ASSIGN_UNQUEUE = 7
VAR `OPCODE_BIT_AND = 8
VAR `OPCODE_BIT_NOT = 9
VAR `OPCODE_BIT_OR = 10
VAR `OPCODE_BIT_SHL = 11
VAR `OPCODE_BIT_SHR = 12
VAR `OPCODE_BIT_XOR = 13
VAR `OPCODE_BY_REF = 14
VAR `OPCODE_CSVAR = 15
VAR `OPCODE_DEBUGL = 16
VAR `OPCODE_DIV = 17
VAR `OPCODE_ELSE = 18
VAR `OPCODE_ELSIF = 19
VAR `OPCODE_ENDIF = 20
VAR `OPCODE_ENDREP = 21
VAR `OPCODE_EQ = 22
VAR `OPCODE_EVAR = 23
VAR `OPCODE_GE = 24
VAR `OPCODE_GT = 25
VAR `OPCODE_IDV = 26
VAR `OPCODE_IF = 27
VAR `OPCODE_INDEXOF_VAR = 28
VAR `OPCODE_IS = 29
VAR `OPCODE_IS_NOT = 30
VAR `OPCODE_IVAR = 31
VAR `OPCODE_LE = 32
VAR `OPCODE_LENGTH_VAR = 33
VAR `OPCODE_LIST = 34
VAR `OPCODE_LIST_AT_CSVAR = 35
VAR `OPCODE_LIST_AT_EVAR = 36
VAR `OPCODE_LIST_AT_IVAR = 37
VAR `OPCODE_LIST_AT_LIST = 38
VAR `OPCODE_LSIZE_VAR = 39
VAR `OPCODE_LT = 40
VAR `OPCODE_MATH_ABS = 41
VAR `OPCODE_MATH_ACOS = 42
VAR `OPCODE_MATH_ASIN = 43
VAR `OPCODE_MATH_ATAN = 44
VAR `OPCODE_MATH_ATAN2 = 45
VAR `OPCODE_MATH_CEIL = 46
VAR `OPCODE_MATH_COS = 47
VAR `OPCODE_MATH_EXP = 48
VAR `OPCODE_MATH_EXP2 = 49
VAR `OPCODE_MATH_FLOOR = 50
VAR `OPCODE_MATH_LOG = 51
VAR `OPCODE_MATH_LOG2 = 52
VAR `OPCODE_MATH_MAX = 53
VAR `OPCODE_MATH_MIN = 54
VAR `OPCODE_MATH_POW = 55
VAR `OPCODE_MATH_ROUND = 56
VAR `OPCODE_MATH_SIGN = 57
VAR `OPCODE_MATH_SIN = 58
VAR `OPCODE_MATH_SQRT = 59
VAR `OPCODE_MATH_TAN = 60
VAR `OPCODE_MINUS = 61
VAR `OPCODE_MOD = 62
VAR `OPCODE_MODULE_NAME = 63
VAR `OPCODE_MUL = 64
VAR `OPCODE_NE = 65
VAR `OPCODE_NEG = 66
VAR `OPCODE_NOT = 67
VAR `OPCODE_NSIZE_VAR = 68
VAR `OPCODE_NUMBER = 69
VAR `OPCODE_OR = 70
VAR `OPCODE_PLUS = 71
VAR `OPCODE_PROCEDURE = 72
VAR `OPCODE_PUSH = 73
VAR `OPCODE_QUEUE = 74
VAR `OPCODE_REPEAT = 75
VAR `OPCODE_REPNEXT = 76
VAR `OPCODE_REPSTOP = 77
VAR `OPCODE_SIZE_VAR = 78
VAR `OPCODE_STRING = 79
VAR `OPCODE_UNASSIGN = 80
VAR `OPCODE_UNASSIGN_CSVAR = 81

FUNC `mkMvarOptindexes(`mvar `opt_indexes):
  VAR `mvar_opt_indexes
  IF `length(`opt_indexes) <= 0:
    `mvar_opt_indexes = `mvar
  ELSIF `mvar[0] == `OPCODE_IVAR:
    `mvar_opt_indexes = [`OPCODE_LIST_AT_IVAR, `mvar[1], `opt_indexes]
  ELSE:
    `mvar_opt_indexes = [`OPCODE_LIST_AT_CSVAR, `mvar[1], `opt_indexes, `mvar[2]]
  ENDIF
  return `mvar_opt_indexes
ENDFUNC

FUNC `mkEvarOptindexes(`evar `opt_indexes):
  VAR `evar_opt_indexes
  IF `length(`opt_indexes) <= 0:
    `evar_opt_indexes = [`OPCODE_EVAR, `lexer.`tokenExtra(`evar)]
  ELSE:
    `evar_opt_indexes = [`OPCODE_LIST_AT_EVAR, `lexer.`tokenExtra(`evar), `opt_indexes]
  ENDIF
  return `evar_opt_indexes
ENDFUNC

FUNC `parse_r_semantic_0__ACCEPT(`args):
  COMMENT prequel_line $end
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_1_prequel_line(`args):
  COMMENT instruction "\n"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_2_instruction(`args):
  COMMENT assignment
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_3_instruction(`args):
  COMMENT assignment_random
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_4_instruction(`args):
  COMMENT unassign
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_5_instruction(`args):
  COMMENT push
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_6_instruction(`args):
  COMMENT queue
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_7_instruction(`args):
  COMMENT pop
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_8_instruction(`args):
  COMMENT unqueue
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_9_instruction(`args):
  COMMENT if
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_10_instruction(`args):
  COMMENT repeat
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_11_instruction(`args):
  COMMENT procedure_call
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_12_instruction(`args):
  COMMENT debugl
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_13_assignment(`args):
  COMMENT retvars "=" expr
  IF `length(`args[0]) > 1:
    return [`OPCODE_ERROR, NULL, "TOO"+" "+"MANY"+" "+"LHS"+" "+"EXPRESSIONS", `lexer.`tokenColumn(`args[1]), []]
  ENDIF
  IF `args[0][0][0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `args[0][0][1], [], `args[2]]
  ELSIF `args[0][0][0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `args[0][0][1], `args[0][0][2], [], `args[2]]
  ELSIF `args[0][0][0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `args[0][0][1], `args[0][0][2], `args[2]]
  ELSIF `args[0][0][0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `args[0][0][1], `args[0][0][3], `args[0][0][2], `args[2]]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[1]), []]
ENDFUNC
FUNC `parse_r_semantic_14_assignment(`args):
  COMMENT retvars "=" mvar opt_indexes ".pop" "(" opt_expr ")"
  IF `length(`args[0]) > 1:
    return [`OPCODE_ERROR, NULL, "TOO"+" "+"MANY"+" "+"LHS"+" "+"EXPRESSIONS", `lexer.`tokenColumn(`args[1]), []]
  ENDIF
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[2], `args[3])
  IF `args[0][0][0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_POP, NULL, `args[0][0][1], [], `mvar_opt_indexes, `args[6], NULL]
  ELSIF `args[0][0][0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_POP, NULL, `args[0][0][1], [], `mvar_opt_indexes, `args[6], `args[0][0][2]]
  ELSIF `args[0][0][0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_POP, NULL, `args[0][0][1], `args[0][0][2], `mvar_opt_indexes, `args[6], NULL]
  ELSIF `args[0][0][0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_POP, NULL, `args[0][0][1], `args[0][0][2], `mvar_opt_indexes, `args[6], `args[0][0][3]]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[1]), []]
ENDFUNC
FUNC `parse_r_semantic_15_assignment(`args):
  COMMENT retvars "=" mvar opt_indexes ".unqueue" "(" ")"
  IF `length(`args[0]) > 1:
    return [`OPCODE_ERROR, NULL, "TOO"+" "+"MANY"+" "+"LHS"+" "+"EXPRESSIONS", `lexer.`tokenColumn(`args[1]), []]
  ENDIF
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[2], `args[3])
  IF `args[0][0][0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_UNQUEUE, NULL, `args[0][0][1], [], `mvar_opt_indexes, NULL]
  ELSIF `args[0][0][0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_UNQUEUE, NULL, `args[0][0][1], [], `mvar_opt_indexes, `args[0][0][2]]
  ELSIF `args[0][0][0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_UNQUEUE, NULL, `args[0][0][1], `args[0][0][2], `mvar_opt_indexes, NULL]
  ELSIF `args[0][0][0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_UNQUEUE, NULL, `args[0][0][1], `args[0][0][2], `mvar_opt_indexes, `args[0][0][3]]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[1]), []]
ENDFUNC
FUNC `parse_r_semantic_16_assignment(`args):
  COMMENT retvars "=" procedure_name "(" opt_args ")"
  VAR `opt_args = `args[4]
  VAR `byref_exprs
  VAR `opt_indexes
  VAR `j
  VAR `j2
  FORDECR `j(`length(`args[0])-1 0):
    IF `args[0][`j][0] == `OPCODE_IVAR:
      `byref_exprs = [`args[0][`j][1], NULL]
      `opt_indexes = []
    ELSIF `args[0][`j][0] == `OPCODE_CSVAR:
      `byref_exprs = [`args[0][`j][1], `args[0][`j][2]]
      `opt_indexes = []
    ELSIF `args[0][`j][0] == `OPCODE_LIST_AT_IVAR:
      `byref_exprs = [`args[0][`j][1], NULL]
      `opt_indexes = `args[0][`j][2]
    ELSIF `args[0][`j][0] == `OPCODE_LIST_AT_CSVAR:
      `byref_exprs = [`args[0][`j][1], `args[0][`j][3]]
      `opt_indexes = `args[0][`j][2]
    ENDIF
    FORINCR `j2(0 `length(`opt_indexes)):
      `push(`byref_exprs, `opt_indexes[`j2])
    ENDFOR
    `queue(`opt_args, [`OPCODE_BY_REF, `byref_exprs])
  ENDFOR
  return [`OPCODE_PROCEDURE, NULL, `lexer.`tokenExtra(`args[2]), `opt_args]
ENDFUNC
FUNC `parse_r_semantic_17_assignment(`args):
  COMMENT mvar opt_indexes "++"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_PLUS, `mvar_opt_indexes, [`OPCODE_NUMBER, `fp[0].FromFloat(1)]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_18_assignment(`args):
  COMMENT mvar opt_indexes "--"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_MINUS, `mvar_opt_indexes, [`OPCODE_NUMBER, `fp[0].FromFloat(1)]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_19_assignment(`args):
  COMMENT mvar opt_indexes "~~"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_BIT_NOT, `mvar_opt_indexes]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_20_assignment(`args):
  COMMENT mvar opt_indexes "+=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_PLUS, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_21_assignment(`args):
  COMMENT mvar opt_indexes "-=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_MINUS, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_22_assignment(`args):
  COMMENT mvar opt_indexes "*=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_MUL, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_23_assignment(`args):
  COMMENT mvar opt_indexes "/=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_DIV, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_24_assignment(`args):
  COMMENT mvar opt_indexes "%=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_MOD, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_25_assignment(`args):
  COMMENT mvar opt_indexes "//=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_IDV, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_26_assignment(`args):
  COMMENT mvar opt_indexes "&=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_BIT_AND, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_27_assignment(`args):
  COMMENT mvar opt_indexes "|=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_BIT_OR, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_28_assignment(`args):
  COMMENT mvar opt_indexes "^=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_BIT_XOR, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_29_assignment(`args):
  COMMENT mvar opt_indexes "<<=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_BIT_SHL, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_30_assignment(`args):
  COMMENT mvar opt_indexes ">>=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  VAR `expr = [`OPCODE_BIT_SHR, `mvar_opt_indexes, `args[3]]
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], [], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `expr]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_CSVAR, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[3], `mvar_opt_indexes[2], `expr]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_31_assignment_random(`args):
  COMMENT mvar opt_indexes "~=" "random"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], [], NULL, NULL]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], [], NULL, `mvar_opt_indexes[2]]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], NULL, NULL]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], NULL, `mvar_opt_indexes[3]]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_32_assignment_random(`args):
  COMMENT mvar opt_indexes "~=" expr
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  IF `mvar_opt_indexes[0] == `OPCODE_IVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], [], `args[3], NULL]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_CSVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], [], `args[3], `mvar_opt_indexes[2]]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_IVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `args[3], NULL]
  ELSIF `mvar_opt_indexes[0] == `OPCODE_LIST_AT_CSVAR:
    return [`OPCODE_ASSIGN_OP_RANDOM, NULL, `mvar_opt_indexes[1], `mvar_opt_indexes[2], `args[3], `mvar_opt_indexes[3]]
  ENDIF
  return [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"LHS", `lexer.`tokenColumn(`args[2]), []]
ENDFUNC
FUNC `parse_r_semantic_33_unassign(`args):
  COMMENT mvar ".unassign"
  IF `args[0][0] == `OPCODE_IVAR:
    return [`OPCODE_UNASSIGN, NULL, `args[0][1]]
  ELSE:
    return [`OPCODE_UNASSIGN_CSVAR, NULL, `args[0][1], `args[0][2]]
  ENDIF
ENDFUNC
FUNC `parse_r_semantic_34_push(`args):
  COMMENT mvar opt_indexes ".push" "(" expr ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_PUSH, NULL, `mvar_opt_indexes, `args[4], NULL]
ENDFUNC
FUNC `parse_r_semantic_35_push(`args):
  COMMENT mvar opt_indexes ".push" "(" expr "," expr ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_PUSH, NULL, `mvar_opt_indexes, `args[4], `args[6]]
ENDFUNC
FUNC `parse_r_semantic_36_queue(`args):
  COMMENT mvar opt_indexes ".queue" "(" expr ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_QUEUE, NULL, `mvar_opt_indexes, `args[4]]
ENDFUNC
FUNC `parse_r_semantic_37_pop(`args):
  COMMENT mvar opt_indexes ".pop" "(" opt_expr ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_ASSIGN_POP, NULL, NULL, NULL, `mvar_opt_indexes, `args[4], NULL]
ENDFUNC
FUNC `parse_r_semantic_38_unqueue(`args):
  COMMENT mvar opt_indexes ".unqueue" "(" ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_ASSIGN_UNQUEUE, NULL, NULL, NULL, `mvar_opt_indexes, NULL]
ENDFUNC
FUNC `parse_r_semantic_39_if(`args):
  COMMENT "if" expr
  return [`OPCODE_IF, NULL, NULL, `args[1]]
ENDFUNC
FUNC `parse_r_semantic_40_if(`args):
  COMMENT "elif" expr
  return [`OPCODE_ELSIF, NULL, NULL, `args[1]]
ENDFUNC
FUNC `parse_r_semantic_41_if(`args):
  COMMENT "else"
  return [`OPCODE_ELSE, NULL]
ENDFUNC
FUNC `parse_r_semantic_42_if(`args):
  COMMENT "endif"
  return [`OPCODE_ENDIF, NULL]
ENDFUNC
FUNC `parse_r_semantic_43_repeat(`args):
  COMMENT "repeat" "ivar"
  return [`OPCODE_REPEAT, NULL, NULL, `lexer.`tokenExtra(`args[1])]
ENDFUNC
FUNC `parse_r_semantic_44_repeat(`args):
  COMMENT "continue"
  return [`OPCODE_REPNEXT, NULL]
ENDFUNC
FUNC `parse_r_semantic_45_repeat(`args):
  COMMENT "break"
  return [`OPCODE_REPSTOP, NULL]
ENDFUNC
FUNC `parse_r_semantic_46_repeat(`args):
  COMMENT "endrep"
  return [`OPCODE_ENDREP, NULL, NULL]
ENDFUNC
FUNC `parse_r_semantic_47_procedure_call(`args):
  COMMENT procedure_name "(" opt_args ")"
  return [`OPCODE_PROCEDURE, NULL, `lexer.`tokenExtra(`args[0]), `args[2]]
ENDFUNC
FUNC `parse_r_semantic_48_debugl(`args):
  COMMENT "print" "(" debugl_args ")"
  return [`OPCODE_DEBUGL, NULL, `args[2]]
ENDFUNC
FUNC `parse_r_semantic_49_opt_indexes(`args):
  COMMENT %empty
  return []
ENDFUNC
FUNC `parse_r_semantic_50_opt_indexes(`args):
  COMMENT indexes
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_51_indexes(`args):
  COMMENT index opt_indexes
  VAR `indexes = `args[1]
  `queue(`indexes, `args[0])
  return `indexes
ENDFUNC
FUNC `parse_r_semantic_52_index(`args):
  COMMENT "[" expr "]"
  return `args[1]
ENDFUNC
FUNC `parse_r_semantic_53_expr(`args):
  COMMENT "(" expr ")"
  return `args[1]
ENDFUNC
FUNC `parse_r_semantic_54_expr(`args):
  COMMENT expr "or" expr
  return [`OPCODE_OR, [`args[0], `args[2]]]
ENDFUNC
FUNC `parse_r_semantic_55_expr(`args):
  COMMENT expr "and" expr
  return [`OPCODE_AND, [`args[0], `args[2]]]
ENDFUNC
FUNC `parse_r_semantic_56_expr(`args):
  COMMENT "not" expr
  return [`OPCODE_NOT, `args[1]]
ENDFUNC
FUNC `parse_r_semantic_57_expr(`args):
  COMMENT expr "is" expr_type
  VAR `token_id = `lexer.`tokenId(`args[2])
  return [`OPCODE_IS, `args[0], `token_id]
ENDFUNC
FUNC `parse_r_semantic_58_expr(`args):
  COMMENT expr "is_not" expr_type
  VAR `token_id = `lexer.`tokenId(`args[2])
  return [`OPCODE_IS_NOT, `args[0], `token_id]
ENDFUNC
FUNC `parse_r_semantic_59_expr(`args):
  COMMENT expr "==" expr
  return [`OPCODE_EQ, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_60_expr(`args):
  COMMENT expr "<>" expr
  return [`OPCODE_NE, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_61_expr(`args):
  COMMENT expr "<" expr
  return [`OPCODE_LT, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_62_expr(`args):
  COMMENT expr "<=" expr
  return [`OPCODE_LE, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_63_expr(`args):
  COMMENT expr ">" expr
  return [`OPCODE_GT, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_64_expr(`args):
  COMMENT expr ">=" expr
  return [`OPCODE_GE, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_65_expr(`args):
  COMMENT expr "+" expr
  return [`OPCODE_PLUS, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_66_expr(`args):
  COMMENT expr "-" expr
  return [`OPCODE_MINUS, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_67_expr(`args):
  COMMENT expr "*" expr
  return [`OPCODE_MUL, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_68_expr(`args):
  COMMENT expr "/" expr
  return [`OPCODE_DIV, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_69_expr(`args):
  COMMENT expr "%" expr
  return [`OPCODE_MOD, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_70_expr(`args):
  COMMENT expr "//" expr
  return [`OPCODE_IDV, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_71_expr(`args):
  COMMENT "~" expr
  return [`OPCODE_BIT_NOT, `args[1]]
ENDFUNC
FUNC `parse_r_semantic_72_expr(`args):
  COMMENT expr "|" expr
  return [`OPCODE_BIT_OR, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_73_expr(`args):
  COMMENT expr "^" expr
  return [`OPCODE_BIT_XOR, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_74_expr(`args):
  COMMENT expr "&" expr
  return [`OPCODE_BIT_AND, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_75_expr(`args):
  COMMENT expr "<<" expr
  return [`OPCODE_BIT_SHL, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_76_expr(`args):
  COMMENT expr ">>" expr
  return [`OPCODE_BIT_SHR, `args[0], `args[2]]
ENDFUNC
FUNC `parse_r_semantic_77_expr(`args):
  COMMENT "-" expr %prec UNOP
  return [`OPCODE_NEG, `args[1]]
ENDFUNC
FUNC `parse_r_semantic_78_expr(`args):
  COMMENT "+" expr %prec UNOP
  return `args[1]
ENDFUNC
FUNC `parse_r_semantic_79_expr(`args):
  COMMENT "[" opt_exprs "]" opt_indexes
  IF `length(`args[3]) <= 0:
    return [`OPCODE_LIST, `args[1]]
  ELSE:
    return [`OPCODE_LIST_AT_LIST, `args[1], `args[3]]
  ENDIF
ENDFUNC
FUNC `parse_r_semantic_80_expr(`args):
  COMMENT number
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_81_expr(`args):
  COMMENT "evar" opt_indexes
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return `evar_opt_indexes
ENDFUNC
FUNC `parse_r_semantic_82_expr(`args):
  COMMENT "evar" opt_indexes ".length"
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return [`OPCODE_LENGTH_VAR, `evar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_83_expr(`args):
  COMMENT "evar" opt_indexes ".size"
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return [`OPCODE_SIZE_VAR, `evar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_84_expr(`args):
  COMMENT "evar" opt_indexes ".nsize"
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return [`OPCODE_NSIZE_VAR, `evar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_85_expr(`args):
  COMMENT "evar" opt_indexes ".lsize"
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return [`OPCODE_LSIZE_VAR, `evar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_86_expr(`args):
  COMMENT "evar" opt_indexes ".indexof" "(" expr ")"
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return [`OPCODE_INDEXOF_VAR, `evar_opt_indexes, `args[4], [`OPCODE_NUMBER, 0]]
ENDFUNC
FUNC `parse_r_semantic_87_expr(`args):
  COMMENT "evar" opt_indexes ".indexof" "(" expr "," expr ")"
  VAR `evar_opt_indexes = `mkEvarOptindexes(`args[0], `args[1])
  return [`OPCODE_INDEXOF_VAR, `evar_opt_indexes, `args[4], `args[6]]
ENDFUNC
FUNC `parse_r_semantic_88_expr(`args):
  COMMENT mvar opt_indexes
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return `mvar_opt_indexes
ENDFUNC
FUNC `parse_r_semantic_89_expr(`args):
  COMMENT mvar opt_indexes ".length"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_LENGTH_VAR, `mvar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_90_expr(`args):
  COMMENT mvar opt_indexes ".size"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_SIZE_VAR, `mvar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_91_expr(`args):
  COMMENT mvar opt_indexes ".nsize"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_NSIZE_VAR, `mvar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_92_expr(`args):
  COMMENT mvar opt_indexes ".lsize"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_LSIZE_VAR, `mvar_opt_indexes]
ENDFUNC
FUNC `parse_r_semantic_93_expr(`args):
  COMMENT mvar opt_indexes ".indexof" "(" expr ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_INDEXOF_VAR, `mvar_opt_indexes, `args[4], [`OPCODE_NUMBER, 0]]
ENDFUNC
FUNC `parse_r_semantic_94_expr(`args):
  COMMENT mvar opt_indexes ".indexof" "(" expr "," expr ")"
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return [`OPCODE_INDEXOF_VAR, `mvar_opt_indexes, `args[4], `args[6]]
ENDFUNC
FUNC `parse_r_semantic_95_expr(`args):
  COMMENT math_factor
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_96_number(`args):
  COMMENT "decimal"
  return [`OPCODE_NUMBER, `lexer.`tokenExtra(`args[0])]
ENDFUNC
FUNC `parse_r_semantic_97_number(`args):
  COMMENT "binary"
  return [`OPCODE_NUMBER, `lexer.`tokenExtra(`args[0])]
ENDFUNC
FUNC `parse_r_semantic_98_number(`args):
  COMMENT "hexadecimal"
  return [`OPCODE_NUMBER, `lexer.`tokenExtra(`args[0])]
ENDFUNC
FUNC `parse_r_semantic_99_math_factor(`args):
  COMMENT "math.abs" "(" expr ")"
  return [`OPCODE_MATH_ABS, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_100_math_factor(`args):
  COMMENT "math.acos" "(" expr ")"
  return [`OPCODE_MATH_ACOS, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_101_math_factor(`args):
  COMMENT "math.asin" "(" expr ")"
  return [`OPCODE_MATH_ASIN, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_102_math_factor(`args):
  COMMENT "math.atan" "(" expr ")"
  return [`OPCODE_MATH_ATAN, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_103_math_factor(`args):
  COMMENT "math.atan2" "(" expr "," expr ")"
  return [`OPCODE_MATH_ATAN2, [`args[2], `args[4]]]
ENDFUNC
FUNC `parse_r_semantic_104_math_factor(`args):
  COMMENT "math.ceil" "(" expr ")"
  return [`OPCODE_MATH_CEIL, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_105_math_factor(`args):
  COMMENT "math.cos" "(" expr ")"
  return [`OPCODE_MATH_COS, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_106_math_factor(`args):
  COMMENT "math.e"
  return [`OPCODE_NUMBER, `fp[0].E()]
ENDFUNC
FUNC `parse_r_semantic_107_math_factor(`args):
  COMMENT "math.exp" "(" expr ")"
  return [`OPCODE_MATH_EXP, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_108_math_factor(`args):
  COMMENT "math.exp2" "(" expr ")"
  return [`OPCODE_MATH_EXP2, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_109_math_factor(`args):
  COMMENT "math.floor" "(" expr ")"
  return [`OPCODE_MATH_FLOOR, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_110_math_factor(`args):
  COMMENT "math.log" "(" expr ")"
  return [`OPCODE_MATH_LOG, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_111_math_factor(`args):
  COMMENT "math.log2" "(" expr ")"
  return [`OPCODE_MATH_LOG2, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_112_math_factor(`args):
  COMMENT "math.max" "(" expr "," expr ")"
  return [`OPCODE_MATH_MAX, [`args[2], `args[4]]]
ENDFUNC
FUNC `parse_r_semantic_113_math_factor(`args):
  COMMENT "math.min" "(" expr "," expr ")"
  return [`OPCODE_MATH_MIN, [`args[2], `args[4]]]
ENDFUNC
FUNC `parse_r_semantic_114_math_factor(`args):
  COMMENT "math.pi"
  return [`OPCODE_NUMBER, `fp[0].PI()]
ENDFUNC
FUNC `parse_r_semantic_115_math_factor(`args):
  COMMENT "math.pow" "(" expr "," expr ")"
  return [`OPCODE_MATH_POW, [`args[2], `args[4]]]
ENDFUNC
FUNC `parse_r_semantic_116_math_factor(`args):
  COMMENT "math.round" "(" expr ")"
  return [`OPCODE_MATH_ROUND, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_117_math_factor(`args):
  COMMENT "math.sign" "(" expr ")"
  return [`OPCODE_MATH_SIGN, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_118_math_factor(`args):
  COMMENT "math.sin" "(" expr ")"
  return [`OPCODE_MATH_SIN, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_119_math_factor(`args):
  COMMENT "math.sqrt" "(" expr ")"
  return [`OPCODE_MATH_SQRT, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_120_math_factor(`args):
  COMMENT "math.tan" "(" expr ")"
  return [`OPCODE_MATH_TAN, [`args[2]]]
ENDFUNC
FUNC `parse_r_semantic_121_opt_expr(`args):
  COMMENT %empty
  return NULL
ENDFUNC
FUNC `parse_r_semantic_122_opt_expr(`args):
  COMMENT expr
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_123_opt_exprs(`args):
  COMMENT %empty
  return []
ENDFUNC
FUNC `parse_r_semantic_124_opt_exprs(`args):
  COMMENT exprs
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_125_exprs(`args):
  COMMENT expr opt_comma
  return [`args[0]]
ENDFUNC
FUNC `parse_r_semantic_126_exprs(`args):
  COMMENT expr "," exprs
  VAR `exprs = `args[2]
  `queue(`exprs, `args[0])
  return `exprs
ENDFUNC
FUNC `parse_r_semantic_127_opt_comma(`args):
  COMMENT %empty
  return []
ENDFUNC
FUNC `parse_r_semantic_128_opt_comma(`args):
  COMMENT ","
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_129_expr_type(`args):
  COMMENT "number"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_130_expr_type(`args):
  COMMENT "list"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_131_expr_type(`args):
  COMMENT "empty"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_132_expr_type(`args):
  COMMENT "procedure"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_133_expr_type(`args):
  COMMENT "undefined"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_134_procedure_name(`args):
  COMMENT "evar"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_135_procedure_name(`args):
  COMMENT "call"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_136_procedure_name(`args):
  COMMENT "return"
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_137_opt_args(`args):
  COMMENT %empty
  return []
ENDFUNC
FUNC `parse_r_semantic_138_opt_args(`args):
  COMMENT args
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_139_args(`args):
  COMMENT arg opt_comma
  return [`args[0]]
ENDFUNC
FUNC `parse_r_semantic_140_args(`args):
  COMMENT arg "," args
  VAR `_args = `args[2]
  `queue(`_args, `args[0])
  return `_args
ENDFUNC
FUNC `parse_r_semantic_141_arg(`args):
  COMMENT expr
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_142_arg(`args):
  COMMENT "@module_name"
  return [`OPCODE_MODULE_NAME, `lexer.`tokenExtra(`args[0])]
ENDFUNC
FUNC `parse_r_semantic_143_arg(`args):
  COMMENT mvar_ref
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_144_arg(`args):
  COMMENT "string"
  return [`OPCODE_STRING, `lexer.`tokenExtra(`args[0])]
ENDFUNC
FUNC `parse_r_semantic_145_mvar_ref(`args):
  COMMENT "&" mvar opt_indexes
  VAR `byref_exprs
  IF `args[1][0] == `OPCODE_IVAR:
    `byref_exprs = [`args[1][1], NULL]
  ELSE:
    `byref_exprs = [`args[1][1], `args[1][2]]
  ENDIF
  VAR `j
  FORINCR `j(0 `length(`args[2])):
    `push(`byref_exprs, `args[2][`j])
  ENDFOR
  return [`OPCODE_BY_REF, `byref_exprs]
ENDFUNC
FUNC `parse_r_semantic_146_retvars(`args):
  COMMENT retvar opt_comma
  return [`args[0]]
ENDFUNC
FUNC `parse_r_semantic_147_retvars(`args):
  COMMENT retvar "," retvars
  VAR `retvars = `args[2]
  `queue(`retvars, `args[0])
  return `retvars
ENDFUNC
FUNC `parse_r_semantic_148_retvar(`args):
  COMMENT mvar opt_indexes
  VAR `mvar_opt_indexes = `mkMvarOptindexes(`args[0], `args[1])
  return `mvar_opt_indexes
ENDFUNC
FUNC `parse_r_semantic_149_mvar(`args):
  COMMENT "ivar"
  return [`OPCODE_IVAR, `lexer.`tokenExtra(`args[0])]
ENDFUNC
FUNC `parse_r_semantic_150_mvar(`args):
  COMMENT "csvar"
  VAR `csvar = `lexer.`tokenExtra(`args[0])
  VAR `idx = `indexof(`csvar, "@")
  VAR `vvar
  VAR `vmod
  IF `idx < 0:
    `vvar = `csvar
    `vmod = ""
  ELSE:
    `vvar = `substring(`csvar, 0, `idx)
    `vmod = `substring(`csvar, `idx+1, `length(`csvar))
  ENDIF
  return [`OPCODE_CSVAR, `vvar, `vmod]
ENDFUNC
FUNC `parse_r_semantic_151_debugl_args(`args):
  COMMENT debugl_arg opt_comma
  return [`args[0]]
ENDFUNC
FUNC `parse_r_semantic_152_debugl_args(`args):
  COMMENT debugl_arg "," debugl_args
  VAR `debugl_args = `args[2]
  `queue(`debugl_args, `args[0])
  return `debugl_args
ENDFUNC
FUNC `parse_r_semantic_153_debugl_arg(`args):
  COMMENT expr
  return `args[0]
ENDFUNC
FUNC `parse_r_semantic_154_debugl_arg(`args):
  COMMENT "string"
  return [`OPCODE_STRING, `lexer.`tokenExtra(`args[0])]
ENDFUNC

VAR `parse_r_count = 155
VAR `parse_r_lhs = []
VAR `parse_r_rhs = []
VAR `parse_r_semantic = []
`push(`parse_r_lhs, `key_tokennt__ACCEPT)
`push(`parse_r_rhs, [`key_tokennt_prequel_line, `key_token__END_])
`push(`parse_r_semantic, `parse_r_semantic_0__ACCEPT)
`push(`parse_r_lhs, `key_tokennt_prequel_line)
`push(`parse_r_rhs, [`key_tokennt_instruction, `key_token_NEWLINE])
`push(`parse_r_semantic, `parse_r_semantic_1_prequel_line)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_assignment])
`push(`parse_r_semantic, `parse_r_semantic_2_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_assignment_random])
`push(`parse_r_semantic, `parse_r_semantic_3_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_unassign])
`push(`parse_r_semantic, `parse_r_semantic_4_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_push])
`push(`parse_r_semantic, `parse_r_semantic_5_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_queue])
`push(`parse_r_semantic, `parse_r_semantic_6_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_pop])
`push(`parse_r_semantic, `parse_r_semantic_7_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_unqueue])
`push(`parse_r_semantic, `parse_r_semantic_8_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_if])
`push(`parse_r_semantic, `parse_r_semantic_9_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_repeat])
`push(`parse_r_semantic, `parse_r_semantic_10_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_procedure_call])
`push(`parse_r_semantic, `parse_r_semantic_11_instruction)
`push(`parse_r_lhs, `key_tokennt_instruction)
`push(`parse_r_rhs, [`key_tokennt_debugl])
`push(`parse_r_semantic, `parse_r_semantic_12_instruction)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_retvars, `key_token_ASSIGN_OP, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_13_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_retvars, `key_token_ASSIGN_OP, `key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_POP, `key_token_LPAR, `key_tokennt_opt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_14_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_retvars, `key_token_ASSIGN_OP, `key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_UNQUEUE, `key_token_LPAR, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_15_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_retvars, `key_token_ASSIGN_OP, `key_tokennt_procedure_name, `key_token_LPAR, `key_tokennt_opt_args, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_16_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_INCR])
`push(`parse_r_semantic, `parse_r_semantic_17_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_DECR])
`push(`parse_r_semantic, `parse_r_semantic_18_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_TOGGLE])
`push(`parse_r_semantic, `parse_r_semantic_19_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_PLUS, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_20_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_MINUS, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_21_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_MUL, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_22_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_DIV, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_23_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_MOD, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_24_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_IDV, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_25_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_BIT_AND, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_26_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_BIT_OR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_27_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_BIT_XOR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_28_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_BIT_SHL, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_29_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_BIT_SHR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_30_assignment)
`push(`parse_r_lhs, `key_tokennt_assignment_random)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_RANDOM, `key_token_RANDOM])
`push(`parse_r_semantic, `parse_r_semantic_31_assignment_random)
`push(`parse_r_lhs, `key_tokennt_assignment_random)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_ASSIGN_OP_RANDOM, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_32_assignment_random)
`push(`parse_r_lhs, `key_tokennt_unassign)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_token_UNASSIGN])
`push(`parse_r_semantic, `parse_r_semantic_33_unassign)
`push(`parse_r_lhs, `key_tokennt_push)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_PUSH, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_34_push)
`push(`parse_r_lhs, `key_tokennt_push)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_PUSH, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_35_push)
`push(`parse_r_lhs, `key_tokennt_queue)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_QUEUE, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_36_queue)
`push(`parse_r_lhs, `key_tokennt_pop)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_POP, `key_token_LPAR, `key_tokennt_opt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_37_pop)
`push(`parse_r_lhs, `key_tokennt_unqueue)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_UNQUEUE, `key_token_LPAR, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_38_unqueue)
`push(`parse_r_lhs, `key_tokennt_if)
`push(`parse_r_rhs, [`key_token_IF, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_39_if)
`push(`parse_r_lhs, `key_tokennt_if)
`push(`parse_r_rhs, [`key_token_ELSIF, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_40_if)
`push(`parse_r_lhs, `key_tokennt_if)
`push(`parse_r_rhs, [`key_token_ELSE])
`push(`parse_r_semantic, `parse_r_semantic_41_if)
`push(`parse_r_lhs, `key_tokennt_if)
`push(`parse_r_rhs, [`key_token_ENDIF])
`push(`parse_r_semantic, `parse_r_semantic_42_if)
`push(`parse_r_lhs, `key_tokennt_repeat)
`push(`parse_r_rhs, [`key_token_REPEAT, `key_token_IVAR])
`push(`parse_r_semantic, `parse_r_semantic_43_repeat)
`push(`parse_r_lhs, `key_tokennt_repeat)
`push(`parse_r_rhs, [`key_token_REPNEXT])
`push(`parse_r_semantic, `parse_r_semantic_44_repeat)
`push(`parse_r_lhs, `key_tokennt_repeat)
`push(`parse_r_rhs, [`key_token_REPSTOP])
`push(`parse_r_semantic, `parse_r_semantic_45_repeat)
`push(`parse_r_lhs, `key_tokennt_repeat)
`push(`parse_r_rhs, [`key_token_ENDREP])
`push(`parse_r_semantic, `parse_r_semantic_46_repeat)
`push(`parse_r_lhs, `key_tokennt_procedure_call)
`push(`parse_r_rhs, [`key_tokennt_procedure_name, `key_token_LPAR, `key_tokennt_opt_args, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_47_procedure_call)
`push(`parse_r_lhs, `key_tokennt_debugl)
`push(`parse_r_rhs, [`key_token_DEBUGL, `key_token_LPAR, `key_tokennt_debugl_args, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_48_debugl)
`push(`parse_r_lhs, `key_tokennt_opt_indexes)
`push(`parse_r_rhs, [])
`push(`parse_r_semantic, `parse_r_semantic_49_opt_indexes)
`push(`parse_r_lhs, `key_tokennt_opt_indexes)
`push(`parse_r_rhs, [`key_tokennt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_50_opt_indexes)
`push(`parse_r_lhs, `key_tokennt_indexes)
`push(`parse_r_rhs, [`key_tokennt_index, `key_tokennt_opt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_51_indexes)
`push(`parse_r_lhs, `key_tokennt_index)
`push(`parse_r_rhs, [`key_token_LSQR, `key_tokennt_expr, `key_token_RSQR])
`push(`parse_r_semantic, `parse_r_semantic_52_index)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_53_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_OR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_54_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_AND, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_55_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_NOT, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_56_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_IS, `key_tokennt_expr_type])
`push(`parse_r_semantic, `parse_r_semantic_57_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_IS_NOT, `key_tokennt_expr_type])
`push(`parse_r_semantic, `parse_r_semantic_58_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_EQ, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_59_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_NE, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_60_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_LT, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_61_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_LE, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_62_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_GT, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_63_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_GE, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_64_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_PLUS, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_65_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_MINUS, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_66_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_MUL, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_67_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_DIV, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_68_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_MOD, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_69_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_IDV, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_70_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_BIT_NOT, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_71_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_BIT_OR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_72_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_BIT_XOR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_73_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_BIT_AND, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_74_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_BIT_SHL, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_75_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_BIT_SHR, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_76_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_MINUS, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_77_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_PLUS, `key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_78_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_LSQR, `key_tokennt_opt_exprs, `key_token_RSQR, `key_tokennt_opt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_79_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_number])
`push(`parse_r_semantic, `parse_r_semantic_80_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_81_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes, `key_token_LENGTH])
`push(`parse_r_semantic, `parse_r_semantic_82_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes, `key_token_SIZE])
`push(`parse_r_semantic, `parse_r_semantic_83_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes, `key_token_NSIZE])
`push(`parse_r_semantic, `parse_r_semantic_84_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes, `key_token_LSIZE])
`push(`parse_r_semantic, `parse_r_semantic_85_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes, `key_token_INDEXOF, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_86_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_token_EVAR, `key_tokennt_opt_indexes, `key_token_INDEXOF, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_87_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_88_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_LENGTH])
`push(`parse_r_semantic, `parse_r_semantic_89_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_SIZE])
`push(`parse_r_semantic, `parse_r_semantic_90_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_NSIZE])
`push(`parse_r_semantic, `parse_r_semantic_91_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_LSIZE])
`push(`parse_r_semantic, `parse_r_semantic_92_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_INDEXOF, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_93_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes, `key_token_INDEXOF, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_94_expr)
`push(`parse_r_lhs, `key_tokennt_expr)
`push(`parse_r_rhs, [`key_tokennt_math_factor])
`push(`parse_r_semantic, `parse_r_semantic_95_expr)
`push(`parse_r_lhs, `key_tokennt_number)
`push(`parse_r_rhs, [`key_token_DECIMAL])
`push(`parse_r_semantic, `parse_r_semantic_96_number)
`push(`parse_r_lhs, `key_tokennt_number)
`push(`parse_r_rhs, [`key_token_BINARY])
`push(`parse_r_semantic, `parse_r_semantic_97_number)
`push(`parse_r_lhs, `key_tokennt_number)
`push(`parse_r_rhs, [`key_token_HEXADECIMAL])
`push(`parse_r_semantic, `parse_r_semantic_98_number)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_ABS, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_99_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_ACOS, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_100_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_ASIN, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_101_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_ATAN, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_102_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_ATAN2, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_103_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_CEIL, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_104_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_COS, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_105_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_E])
`push(`parse_r_semantic, `parse_r_semantic_106_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_EXP, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_107_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_EXP2, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_108_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_FLOOR, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_109_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_LOG, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_110_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_LOG2, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_111_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_MAX, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_112_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_MIN, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_113_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_PI])
`push(`parse_r_semantic, `parse_r_semantic_114_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_POW, `key_token_LPAR, `key_tokennt_expr, `key_token_COMMA, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_115_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_ROUND, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_116_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_SIGN, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_117_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_SIN, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_118_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_SQRT, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_119_math_factor)
`push(`parse_r_lhs, `key_tokennt_math_factor)
`push(`parse_r_rhs, [`key_token_MATH_TAN, `key_token_LPAR, `key_tokennt_expr, `key_token_RPAR])
`push(`parse_r_semantic, `parse_r_semantic_120_math_factor)
`push(`parse_r_lhs, `key_tokennt_opt_expr)
`push(`parse_r_rhs, [])
`push(`parse_r_semantic, `parse_r_semantic_121_opt_expr)
`push(`parse_r_lhs, `key_tokennt_opt_expr)
`push(`parse_r_rhs, [`key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_122_opt_expr)
`push(`parse_r_lhs, `key_tokennt_opt_exprs)
`push(`parse_r_rhs, [])
`push(`parse_r_semantic, `parse_r_semantic_123_opt_exprs)
`push(`parse_r_lhs, `key_tokennt_opt_exprs)
`push(`parse_r_rhs, [`key_tokennt_exprs])
`push(`parse_r_semantic, `parse_r_semantic_124_opt_exprs)
`push(`parse_r_lhs, `key_tokennt_exprs)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_tokennt_opt_comma])
`push(`parse_r_semantic, `parse_r_semantic_125_exprs)
`push(`parse_r_lhs, `key_tokennt_exprs)
`push(`parse_r_rhs, [`key_tokennt_expr, `key_token_COMMA, `key_tokennt_exprs])
`push(`parse_r_semantic, `parse_r_semantic_126_exprs)
`push(`parse_r_lhs, `key_tokennt_opt_comma)
`push(`parse_r_rhs, [])
`push(`parse_r_semantic, `parse_r_semantic_127_opt_comma)
`push(`parse_r_lhs, `key_tokennt_opt_comma)
`push(`parse_r_rhs, [`key_token_COMMA])
`push(`parse_r_semantic, `parse_r_semantic_128_opt_comma)
`push(`parse_r_lhs, `key_tokennt_expr_type)
`push(`parse_r_rhs, [`key_token_NUMBER])
`push(`parse_r_semantic, `parse_r_semantic_129_expr_type)
`push(`parse_r_lhs, `key_tokennt_expr_type)
`push(`parse_r_rhs, [`key_token_LIST])
`push(`parse_r_semantic, `parse_r_semantic_130_expr_type)
`push(`parse_r_lhs, `key_tokennt_expr_type)
`push(`parse_r_rhs, [`key_token_EMPTY])
`push(`parse_r_semantic, `parse_r_semantic_131_expr_type)
`push(`parse_r_lhs, `key_tokennt_expr_type)
`push(`parse_r_rhs, [`key_token_PROCEDURE])
`push(`parse_r_semantic, `parse_r_semantic_132_expr_type)
`push(`parse_r_lhs, `key_tokennt_expr_type)
`push(`parse_r_rhs, [`key_token_UNDEFINED])
`push(`parse_r_semantic, `parse_r_semantic_133_expr_type)
`push(`parse_r_lhs, `key_tokennt_procedure_name)
`push(`parse_r_rhs, [`key_token_EVAR])
`push(`parse_r_semantic, `parse_r_semantic_134_procedure_name)
`push(`parse_r_lhs, `key_tokennt_procedure_name)
`push(`parse_r_rhs, [`key_token_CALL])
`push(`parse_r_semantic, `parse_r_semantic_135_procedure_name)
`push(`parse_r_lhs, `key_tokennt_procedure_name)
`push(`parse_r_rhs, [`key_token_RETURN])
`push(`parse_r_semantic, `parse_r_semantic_136_procedure_name)
`push(`parse_r_lhs, `key_tokennt_opt_args)
`push(`parse_r_rhs, [])
`push(`parse_r_semantic, `parse_r_semantic_137_opt_args)
`push(`parse_r_lhs, `key_tokennt_opt_args)
`push(`parse_r_rhs, [`key_tokennt_args])
`push(`parse_r_semantic, `parse_r_semantic_138_opt_args)
`push(`parse_r_lhs, `key_tokennt_args)
`push(`parse_r_rhs, [`key_tokennt_arg, `key_tokennt_opt_comma])
`push(`parse_r_semantic, `parse_r_semantic_139_args)
`push(`parse_r_lhs, `key_tokennt_args)
`push(`parse_r_rhs, [`key_tokennt_arg, `key_token_COMMA, `key_tokennt_args])
`push(`parse_r_semantic, `parse_r_semantic_140_args)
`push(`parse_r_lhs, `key_tokennt_arg)
`push(`parse_r_rhs, [`key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_141_arg)
`push(`parse_r_lhs, `key_tokennt_arg)
`push(`parse_r_rhs, [`key_token_MODULE_NAME])
`push(`parse_r_semantic, `parse_r_semantic_142_arg)
`push(`parse_r_lhs, `key_tokennt_arg)
`push(`parse_r_rhs, [`key_tokennt_mvar_ref])
`push(`parse_r_semantic, `parse_r_semantic_143_arg)
`push(`parse_r_lhs, `key_tokennt_arg)
`push(`parse_r_rhs, [`key_token_STRING])
`push(`parse_r_semantic, `parse_r_semantic_144_arg)
`push(`parse_r_lhs, `key_tokennt_mvar_ref)
`push(`parse_r_rhs, [`key_token_BIT_AND, `key_tokennt_mvar, `key_tokennt_opt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_145_mvar_ref)
`push(`parse_r_lhs, `key_tokennt_retvars)
`push(`parse_r_rhs, [`key_tokennt_retvar, `key_tokennt_opt_comma])
`push(`parse_r_semantic, `parse_r_semantic_146_retvars)
`push(`parse_r_lhs, `key_tokennt_retvars)
`push(`parse_r_rhs, [`key_tokennt_retvar, `key_token_COMMA, `key_tokennt_retvars])
`push(`parse_r_semantic, `parse_r_semantic_147_retvars)
`push(`parse_r_lhs, `key_tokennt_retvar)
`push(`parse_r_rhs, [`key_tokennt_mvar, `key_tokennt_opt_indexes])
`push(`parse_r_semantic, `parse_r_semantic_148_retvar)
`push(`parse_r_lhs, `key_tokennt_mvar)
`push(`parse_r_rhs, [`key_token_IVAR])
`push(`parse_r_semantic, `parse_r_semantic_149_mvar)
`push(`parse_r_lhs, `key_tokennt_mvar)
`push(`parse_r_rhs, [`key_token_CSVAR])
`push(`parse_r_semantic, `parse_r_semantic_150_mvar)
`push(`parse_r_lhs, `key_tokennt_debugl_args)
`push(`parse_r_rhs, [`key_tokennt_debugl_arg, `key_tokennt_opt_comma])
`push(`parse_r_semantic, `parse_r_semantic_151_debugl_args)
`push(`parse_r_lhs, `key_tokennt_debugl_args)
`push(`parse_r_rhs, [`key_tokennt_debugl_arg, `key_token_COMMA, `key_tokennt_debugl_args])
`push(`parse_r_semantic, `parse_r_semantic_152_debugl_args)
`push(`parse_r_lhs, `key_tokennt_debugl_arg)
`push(`parse_r_rhs, [`key_tokennt_expr])
`push(`parse_r_semantic, `parse_r_semantic_153_debugl_arg)
`push(`parse_r_lhs, `key_tokennt_debugl_arg)
`push(`parse_r_rhs, [`key_token_STRING])
`push(`parse_r_semantic, `parse_r_semantic_154_debugl_arg)

CLASS `Parser:

  METHOD_INIT():
    THIS.`_ignored_lexemes = []
    `push(THIS.`_ignored_lexemes, `key_token_INDENT)
    `push(THIS.`_ignored_lexemes, `key_token_SPACES)
    `push(THIS.`_ignored_lexemes, `key_token_COMMENT)

  METHOD `parseLine(`tokens):
    IF `lexer.`tokenId(`tokens[`length(`tokens)-2]) == `key_token_POSTERROR:
      return [`OPCODE_ERROR, NULL, `lexer.`tokenExtra(`tokens[`length(`tokens)-3]), `lexer.`tokenColumn(`tokens[`length(`tokens)-3]), []]
    ENDIF
    VAR `lidxs = []
    VAR `j
    FORINCR `j(0 `length(`tokens)):
      IF `indexof(THIS.`_ignored_lexemes, `lexer.`tokenId(`tokens[`j])) < 0:
        `push(`lidxs, `j)
      ENDIF
    ENDFOR
    IF `length(`lidxs) == 1:
      return NULL
    ENDIF
    VAR `ast = [`OPCODE_ERROR, NULL, "INVALID"+" "+"INSTRUCTION", `lexer.`tokenColumn(`tokens[`lidxs[0]]), []]
    VAR `stack_states = [0]
    VAR `stack_symbols = []
    VAR `stack_semantic = []
    VAR `lidx = 0
    VAR `state
    VAR `token_id
    VAR `semantic
    VAR `entry
    VAR `entry_idx
    VAR `action_data
    VAR `action_type
    VAR `action_number
    VAR `lhs
    VAR `rhs
    VAR `semantic_args
    IF `lidx >= `length(`lidxs):
      `token_id = `key_token__END_
      `semantic = []
    ELSE:
      `token_id = `lexer.`tokenId(`tokens[`lidxs[`lidx]])
      `semantic = `tokens[`lidxs[`lidx]]
    ENDIF
    WHILE TRUE:
      `state = `stack_states[0]
      `entry = `state*`parse_y_count+`token_id
      `entry_idx = `indexof(`parse_t_entries, `entry)
      IF `entry_idx < 0:
        IF `token_id == `key_token__END_:
          `ast = [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"END"+"-"+"OF"+"-"+"LINE", `lexer.`tokenColumn(`tokens[`lidxs[`length(`lidxs)-1]]), []]
        ELSE:
          `ast = [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"TOKEN"+" "+`tokenIdToString(`token_id), `lexer.`tokenColumn(`tokens[`lidxs[`lidx]]), []]
        ENDIF
        break
      ENDIF
      `action_data = `parse_t_actions[`entry_idx]
      `action_type = `action_data % `parse_a_count
      `action_number = `trunc((`action_data-`action_type) / `parse_a_count)
      IF `action_type == `key_parse_a_accept:
        IF `length(`stack_semantic) == 1:
          COMMENT `warning("Prequel"+" "+"parseLine"+" "+"OK"+":", `stack_semantic[0])
          `ast = `stack_semantic[0]
        ELSE:
          COMMENT `warning("Prequel"+" "+"parseLine"+" "+"KO"+":", `stack_semantic)
          `ast = [`OPCODE_ERROR, NULL, "UNEXPECTED"+" "+"ACCEPT"+" "+`str(`length(`stack_semantic)), 0, []]
        ENDIF
        break
      ENDIF
      IF `action_type == `key_parse_a_shift:
        `queue(`stack_states, `action_number)
        `queue(`stack_symbols, `token_id)
        `queue(`stack_semantic, `semantic)
        `lidx += 1
        IF `lidx >= `length(`lidxs):
          `token_id = `key_token__END_
          `semantic = []
        ELSE:
          `token_id = `lexer.`tokenId(`tokens[`lidxs[`lidx]])
          `semantic = `tokens[`lidxs[`lidx]]
        ENDIF
        continue
      ENDIF
      IF `action_type == `key_parse_a_reduce:
        `lhs = `parse_r_lhs[`action_number]
        `rhs = `parse_r_rhs[`action_number]
        `semantic_args = []
        FORINCR `j(0 `length(`rhs)):
          `unqueue(`stack_states)
          `unqueue(`stack_symbols)
          `queue(`semantic_args, `unqueue(`stack_semantic))
        ENDFOR
        `token_id = `lhs
        `semantic = `parse_r_semantic[`action_number](`semantic_args)
        IF `not(`isnull(`semantic)) AND (`length(`semantic) > 0) AND (`semantic[0] == `OPCODE_ERROR):
          `ast = `semantic
          break
        ENDIF
        continue
      ENDIF
      IF `action_type == `key_parse_a_goto:
        `queue(`stack_states, `action_number)
        `queue(`stack_symbols, `token_id)
        `queue(`stack_semantic, `semantic)
        IF `lidx >= `length(`lidxs):
          `token_id = `key_token__END_
          `semantic = []
        ELSE:
          `token_id = `lexer.`tokenId(`tokens[`lidxs[`lidx]])
          `semantic = `tokens[`lidxs[`lidx]]
        ENDIF
        continue
      ENDIF
      break
    ENDWHILE
    COMMENT `warning("Prequel"+" "+"parseLine"+" "+"ast"+":", [`lidx, `lidxs, `tokens, `ast, `stack_states, `stack_symbols, `stack_semantic, `semantic])
    return `ast

ENDCLASS

VAR `parser = NEW `Parser()

VAR `UtilsEditorM_control_tokens = [`key_token_IF, `key_token_ELSIF, `key_token_ELSE, `key_token_ENDIF, `key_token_REPEAT, `key_token_ENDREP, `key_token_REPNEXT, `key_token_REPSTOP]
VAR `UtilsEditorM_indent_ignored = [`key_token_COMMENT, `key_token_NEWLINE, `key_token_ERROR]

CLASS `UtilsEditorM:

  METHOD_INIT():
    THIS.`_control_tokens_if = [`key_token_IF, `key_token_ELSIF, `key_token_ELSE, `key_token_ENDIF]
    THIS.`_control_tokens_repeat = [`key_token_REPEAT, `key_token_ENDREP]
    THIS.`_control_tokens_repstop = [`key_token_REPNEXT, `key_token_REPSTOP]
    VAR `indent_spaces = 1
    THIS.`_indent_stmts = {}
    THIS.`_indent_stmts[`key_token_IF] = [0, `indent_spaces]
    THIS.`_indent_stmts[`key_token_ELSIF] = [-`indent_spaces, `indent_spaces]
    THIS.`_indent_stmts[`key_token_ELSE] = [-`indent_spaces, `indent_spaces]
    THIS.`_indent_stmts[`key_token_ENDIF] = [-`indent_spaces, 0]
    THIS.`_indent_stmts[`key_token_REPEAT] = [0, `indent_spaces]
    THIS.`_indent_stmts[`key_token_ENDREP] = [-`indent_spaces, 0]

  METHOD `lineastLine(`line_ast):
    return `line_ast[0]

  METHOD `lineastTokens(`line_ast):
    return `line_ast[1]

  METHOD `lineastAst(`line_ast):
    return `line_ast[2]

  METHOD `lineastControl(`line_ast):
    IF `length(`line_ast) <= 3:
      return NULL
    ENDIF
    return `line_ast[3]

  METHOD `indentStmts(`token):
    IF `not(`token in THIS.`_indent_stmts):
      return [0, 0]
    ENDIF
    VAR `indent_stmt = THIS.`_indent_stmts[`token]
    return [`indent_stmt[0], `indent_stmt[1]]

  METHOD `mkControlSets(`lines_control `sets_control `error_control `lines_id `lines_ast):
    VAR `processed_indexes = []
    VAR `j1
    VAR `set_control_indexes
    VAR `sets_control_index
    VAR `set_control
    VAR `j2
    VAR `lnid_j
    VAR `token_indent_j
    VAR `line_ast_j
    VAR `control_node_j
    VAR `error_data
    VAR `error_lnid
    VAR `error_message
    VAR `error_line_ast
    VAR `error_control_node
    FORINCR `j1(0 `length(`lines_control)):
      IF `indexof(`processed_indexes, `j1) >= 0:
        continue
      ENDIF
      `set_control_indexes = THIS.`_extractControlSetIndexes(`j1, `lines_control)
      `sets_control_index = `length(`sets_control)
      `set_control = []
      FORINCR `j2(0 `length(`set_control_indexes)):
        `lnid_j = `lines_control[`set_control_indexes[`j2]][0]
        `token_indent_j = `lines_control[`set_control_indexes[`j2]][1]
        `push(`set_control, [`lnid_j, `token_indent_j])
        `line_ast_j = `lines_ast[`lnid_j]
        `control_node_j = [`set_control_indexes[`j2], `sets_control_index]
        `push(`line_ast_j, `control_node_j)
      ENDFOR
      `push(`sets_control, `set_control)
      `error_data = THIS.`_mkControlError(`set_control)
      `error_lnid = `error_data[0]
      `error_message = `error_data[1]
      IF `not(`isnull(`error_lnid)):
        THIS.`setInsertLineId(`error_lnid, `error_control, `lines_id)
        `error_line_ast = `lines_ast[`error_lnid]
        `error_control_node = THIS.`lineastControl(`error_line_ast)
        `push(`error_control_node, `error_message)
      ENDIF
      `processed_indexes = `concat(`processed_indexes, `set_control_indexes)
      IF `length(`processed_indexes) >= `length(`lines_control):
        IF `length(`processed_indexes) > `length(`lines_control):
          `warning("Prequel"+" "+"UtilsEditorM"+" "+"mkControlSets"+":"+" "+"unhandled"+" "+"value"+":", [`processed_indexes, `lines_control])
        ENDIF
        break
      ENDIF
    ENDFOR

  METHOD `_extractControlSetIndexes(`index `lines_control):
    VAR `line_control = `lines_control[`index]
    VAR `lnid = `line_control[0]
    VAR `token_indent = `line_control[1]
    VAR `indent = `line_control[2]
    VAR `set_control = [`index]
    VAR `last_token_indent
    VAR `j
    VAR `lnid_j
    VAR `token_indent_j
    VAR `indent_j
    VAR `min_indent_repstop
    `index += 1
    IF `index >= `length(`lines_control):
      return `set_control
    ENDIF
    IF `token_indent == `key_token_IF:
      `last_token_indent = `key_token_IF
      `j = `index
      WHILE `j < `length(`lines_control):
        `lnid_j = `lines_control[`j][0]
        `token_indent_j = `lines_control[`j][1]
        `indent_j = `lines_control[`j][2]
        IF `indent_j < `indent:
          break
        ENDIF
        IF `indent_j > `indent:
          `j += 1
          continue
        ENDIF
        IF `indexof(THIS.`_control_tokens_if, `token_indent_j) < 0:
          break
        ENDIF
        IF `token_indent_j == `key_token_IF:
          break
        ENDIF
        IF `token_indent_j == `key_token_ENDIF:
          `push(`set_control, `j)
          break
        ENDIF
        IF `last_token_indent == `key_token_ELSE:
          break
        ENDIF
        `push(`set_control, `j)
        `last_token_indent = `token_indent_j
        `j += 1
      ENDWHILE
    ELSIF `token_indent == `key_token_REPEAT:
      `min_indent_repstop = -1
      `j = `index
      WHILE `j < `length(`lines_control):
        `lnid_j = `lines_control[`j][0]
        `token_indent_j = `lines_control[`j][1]
        `indent_j = `lines_control[`j][2]
        IF `indent_j < `indent:
          break
        ENDIF
        IF `indent_j == `indent:
          IF `token_indent_j == `key_token_ENDREP:
            `push(`set_control, `j)
          ENDIF
          break
        ENDIF
        IF `token_indent_j == `key_token_REPEAT:
          IF (`min_indent_repstop < 0) OR (`min_indent_repstop > `indent_j):
            `min_indent_repstop = `indent_j
          ENDIF
          `j += 1
          continue
        ENDIF
        IF `indexof(THIS.`_control_tokens_repstop, `token_indent_j) < 0:
          IF `indent_j <= `min_indent_repstop:
            `min_indent_repstop = -1
          ENDIF
          `j += 1
          continue
        ENDIF
        IF (`min_indent_repstop >= 0) AND (`min_indent_repstop < `indent_j):
          `j += 1
          continue
        ENDIF
        `push(`set_control, `j)
        `j += 1
      ENDWHILE
    ENDIF
    return `set_control

  METHOD `_mkControlError(`set_control):
    VAR `error_lnid
    VAR `error_message
    IF `set_control[0][1] == `key_token_IF:
      IF `set_control[`length(`set_control)-1][1] == `key_token_ENDIF:
        return [NULL, NULL]
      ENDIF
      `error_lnid = `set_control[`length(`set_control)-1][0]
      IF `set_control[`length(`set_control)-1][1] == `key_token_IF:
        `error_message = "IF"+" "+"MISMATCHES"+" "+"ENDIF"
      ELSIF `set_control[`length(`set_control)-1][1] == `key_token_ELSIF:
        `error_message = "ELIF"+" "+"MISMATCHES"+" "+"ENDIF"
      ELSE:
        `error_message = "ELSE"+" "+"MISMATCHES"+" "+"ENDIF"
      ENDIF
      return [`error_lnid, `error_message]
    ENDIF
    IF `set_control[0][1] == `key_token_REPEAT:
      IF `set_control[`length(`set_control)-1][1] == `key_token_ENDREP:
        return [NULL, NULL]
      ENDIF
      return [`set_control[0][0], "REPEAT"+" "+"MISMATCHES"+" "+"ENDREP"]
    ENDIF
    `error_lnid = `set_control[0][0]
    IF `set_control[0][1] == `key_token_ELSIF:
      `error_message = "ELIF"+" "+"WITHOUT"+" "+"IF"
    ELSIF `set_control[0][1] == `key_token_ELSE:
      `error_message = "ELSE"+" "+"WITHOUT"+" "+"IF"
    ELSIF `set_control[0][1] == `key_token_ENDIF:
      `error_message = "ENDIF"+" "+"WITHOUT"+" "+"IF"
    ELSIF `set_control[0][1] == `key_token_REPNEXT:
      `error_message = "REPNEXT"+" "+"WITHOUT"+" "+"REPEAT"
    ELSIF `set_control[0][1] == `key_token_REPSTOP:
      `error_message = "REPSTOP"+" "+"WITHOUT"+" "+"REPEAT"
    ELSE:
      `error_message = "ENDREP"+" "+"WITHOUT"+" "+"REPEAT"
    ENDIF
    return [`error_lnid, `error_message]

  METHOD `setInsertLineId(`lnid `set_ `lines_id):
    VAR `index = `indexof(`set_, `lnid)
    IF `index >= 0:
      return
    ENDIF
    VAR `lnno = `indexof(`lines_id, `lnid)
    `index = 0
    VAR `j
    FORDECR `j(`length(`set_)-1 0):
      IF `lnno <= `indexof(`lines_id, `set_[`j]):
        continue
      ENDIF
      `index = `j+1
      break
    ENDFOR
    `poke(`set_, `index, `lnid)

  METHOD `setDeleteLineId(`lnid `set_):
    VAR `index = `indexof(`set_, `lnid)
    WHILE `index >= 0:
      `pick(`set_, `index)
      `index = `indexof(`set_, `lnid)
    ENDWHILE

ENDCLASS

VAR `utils_editor_m = NEW `UtilsEditorM()

CLASS `EditorM:

  METHOD_INIT(`source_code):
    THIS.`_lnids = NEW `ResourceIds()
    THIS.`_lines_id = []
    THIS.`setSourceCode(`source_code)

  METHOD `setSourceCode(`source_code):
    VAR `ast_node
    VAR `bptn_lnid
    VAR `indent
    VAR `indent_stmt
    VAR `is_breakpoint
    VAR `j
    VAR `j1
    VAR `line_indent
    VAR `lines
    VAR `lnid
    VAR `lnno
    VAR `token_indent
    VAR `tokens
    FORINCR `j(0 `length(THIS.`_lines_id)):
      `lnid = THIS.`_lines_id[`j]
      THIS.`_lnids.`free(`lnid)
    ENDFOR
    IF (`length(`source_code) > 0) AND (`source_code[`length(`source_code)-1] != `chr_lf):
      `source_code += `chr_lf
    ENDIF
    `source_code = `lexer.`normalize(`source_code)
    `lines = `split(`source_code, `chr_lf)
    `push(`lines, "")
    THIS.`_lines_id = []
    THIS.`_lines_ast = {}
    THIS.`_error_lines = []
    THIS.`_lines_indent = [[0, 0]]
    THIS.`_error_indents = []
    THIS.`_lines_control = []
    THIS.`_sets_control = []
    THIS.`_error_control = []
    THIS.`_cut_lines = []
    THIS.`_cut_lnno = -1
    THIS.`_breakpoints = []
    `is_breakpoint = FALSE
    FORINCR `j1(0 `length(`lines)-1):
      IF `lines[`j1] == "#pragma"+" "+"breakpoint":
        `is_breakpoint = TRUE
        continue
      ENDIF
      `lnid = THIS.`_lnids.`alloc()
      `lnno = `length(THIS.`_lines_id)
      `tokens = `lexer.`lexLine(`lines[`j1])
      `ast_node = `parser.`parseLine(`tokens)
      IF `not(`isnull(`ast_node)) AND (`ast_node[0] == `OPCODE_ERROR):
        `push(THIS.`_error_lines, `lnid)
      ENDIF
      `line_indent = THIS.`_lines_indent[`lnno]
      `indent = `length(`lexer.`tokenValue(`tokens[0]))
      `token_indent = `lexer.`tokenId(`tokens[1])
      IF `indexof(`UtilsEditorM_indent_ignored, `token_indent) >= 0:
        `push(THIS.`_lines_indent, [`line_indent[0], `line_indent[1]])
      ELSE:
        `indent_stmt = `utils_editor_m.`indentStmts(`token_indent)
        `push(THIS.`_lines_indent, [`indent, `indent_stmt[1]])
        IF `indent != `line_indent[0]+`line_indent[1]+`indent_stmt[0]:
          `push(THIS.`_error_indents, `lnid)
        ENDIF
      ENDIF
      `push(THIS.`_lines_id, `lnid)
      THIS.`_lines_ast[`lnid] = [`lines[`j1], `tokens, `ast_node]
      IF `indexof(`UtilsEditorM_control_tokens, `token_indent) >= 0:
        `push(THIS.`_lines_control, [`lnid, `token_indent, `indent])
      ENDIF
      IF `is_breakpoint:
        `push(THIS.`_breakpoints, `lnid)
        `is_breakpoint = FALSE
      ENDIF
    ENDFOR
    `unqueue(THIS.`_lines_indent)
    `utils_editor_m.`mkControlSets(THIS.`_lines_control, THIS.`_sets_control, THIS.`_error_control, THIS.`_lines_id, THIS.`_lines_ast)
    THIS.`_inactive_breakpoints = []
    FORINCR `j(0 `length(THIS.`_breakpoints)):
      `bptn_lnid = THIS.`_breakpoints[`j]
      IF `not(`isnull(`utils_editor_m.`lineastAst(THIS.`_lines_ast[`bptn_lnid]))) AND (`indexof(THIS.`_error_lines, `bptn_lnid) < 0) AND (`indexof(THIS.`_error_indents, `bptn_lnid) < 0) AND (`indexof(THIS.`_error_control, `bptn_lnid) < 0):
        continue
      ENDIF
      `push(THIS.`_inactive_breakpoints, `bptn_lnid)
    ENDFOR
    THIS.`_parser_error = THIS.`_mkTopError()
    THIS.`_entry_lnid = NULL
    THIS.`_is_compiled = FALSE

  METHOD `getSourceCode():
    VAR `source_code = ""
    VAR `j
    VAR `lnid
    VAR `line
    FORINCR `j(0 `length(THIS.`_lines_id)-1):
      `lnid = THIS.`_lines_id[`j]
      `line = `utils_editor_m.`lineastLine(THIS.`_lines_ast[`lnid])
      `source_code += `line+`chr_lf
    ENDFOR
    return `source_code

  METHOD `getLnnoCount():
    return (`length(THIS.`_lines_id)-1)

  METHOD `getTokens(`lnno):
    VAR `lnid = THIS.`_lines_id[`lnno]
    return `utils_editor_m.`lineastTokens(THIS.`_lines_ast[`lnid])

  METHOD `getParserError():
    return THIS.`_parser_error

  METHOD `getEntryLnno():
    IF `isnull(THIS.`_entry_lnid):
      return -1
    ENDIF
    return `indexof(THIS.`_lines_id, THIS.`_entry_lnid)

  METHOD `_mkTopError():
    VAR `error_lnid
    VAR `error_lnno
    VAR `terr_lnid
    VAR `terr_lnno
    VAR `terr_startcol
    VAR `terr_endcol
    VAR `terr_message
    VAR `tokens
    IF `length(THIS.`_error_lines) > 0:
      `terr_lnid = THIS.`_error_lines[0]
      `terr_lnno = `indexof(THIS.`_lines_id, `terr_lnid)
      `terr_startcol = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`terr_lnid])[3]
      `terr_endcol = `terr_startcol
      `terr_message = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`terr_lnid])[2]
      `tokens = `utils_editor_m.`lineastTokens(THIS.`_lines_ast[`terr_lnid])
      IF (`length(`tokens) >= 4) AND (`lexer.`tokenId(`tokens[`length(`tokens)-3]) == `key_token_ERROR):
        `terr_endcol = `terr_startcol+`length(`lexer.`tokenValue(`tokens[`length(`tokens)-3]))
      ENDIF
    ELSE:
      `terr_lnno = `length(THIS.`_lines_id)
    ENDIF
    IF `length(THIS.`_error_control) > 0:
      `error_lnid = THIS.`_error_control[0]
      `error_lnno = `indexof(THIS.`_lines_id, `error_lnid)
      IF `terr_lnno > `error_lnno:
        `terr_lnid = `error_lnid
        `terr_lnno = `error_lnno
        `tokens = `utils_editor_m.`lineastTokens(THIS.`_lines_ast[`terr_lnid])
        `terr_startcol = `length(`lexer.`tokenValue(`tokens[0]))
        `terr_endcol = `terr_startcol
        `terr_message = `utils_editor_m.`lineastControl(THIS.`_lines_ast[`terr_lnid])[2]
      ENDIF
    ENDIF
    IF `length(THIS.`_error_indents) > 0:
      `error_lnid = THIS.`_error_indents[0]
      `error_lnno = `indexof(THIS.`_lines_id, `error_lnid)
      IF `terr_lnno > `error_lnno:
        `terr_lnid = `error_lnid
        `terr_lnno = `error_lnno
        `tokens = `utils_editor_m.`lineastTokens(THIS.`_lines_ast[`terr_lnid])
        `terr_startcol = `length(`lexer.`tokenValue(`tokens[0]))
        `terr_endcol = `terr_startcol
        `terr_message = "INVALID"+" "+"INDENTATION"
      ENDIF
    ENDIF
    IF `terr_lnno >= `length(THIS.`_lines_id):
      return NULL
    ENDIF
    return [`terr_lnid, `terr_lnno, `terr_startcol, `terr_endcol, `terr_message]

  METHOD `getBreakpointsInfo():
    return [THIS.`_breakpoints, THIS.`_inactive_breakpoints]

  METHOD `hasBreakpoint(`lnno):
    VAR `lnid = THIS.`_lines_id[`lnno]
    return ((`indexof(THIS.`_breakpoints, `lnid) >= 0) AND (`indexof(THIS.`_inactive_breakpoints, `lnid) < 0))

  METHOD `setBreakpoint(`lnno):
    VAR `lnid = THIS.`_lines_id[`lnno]
    IF `indexof(THIS.`_breakpoints, `lnid) >= 0:
      return
    ENDIF
    `utils_editor_m.`setInsertLineId(`lnid, THIS.`_breakpoints, THIS.`_lines_id)
    IF `not(`isnull(`utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid]))) AND (`indexof(THIS.`_error_lines, `lnid) < 0) AND (`indexof(THIS.`_error_indents, `lnid) < 0) AND (`indexof(THIS.`_error_control, `lnid) < 0):
      return
    ENDIF
    `utils_editor_m.`setInsertLineId(`lnid, THIS.`_inactive_breakpoints, THIS.`_lines_id)

  METHOD `clearBreakpoint(`lnno):
    VAR `lnid = THIS.`_lines_id[`lnno]
    VAR `index = `indexof(THIS.`_breakpoints, `lnid)
    IF `index < 0:
      return
    ENDIF
    `pick(THIS.`_breakpoints, `index)
    `index = `indexof(THIS.`_inactive_breakpoints, `lnid)
    IF `index < 0:
      return
    ENDIF
    `pick(THIS.`_inactive_breakpoints, `index)

  METHOD `getLinesId():
    return THIS.`_lines_id

  METHOD `getLinesAst():
    return THIS.`_lines_ast

  METHOD `getEntryLnid():
    return THIS.`_entry_lnid

  METHOD `isCompiled():
    return THIS.`_is_compiled

  METHOD `compile():
    IF THIS.`_is_compiled:
      return
    ENDIF
    VAR `ast_node_endrep
    VAR `ast_node_if
    VAR `ast_node_j
    VAR `ast_node_prev_elsif_else
    VAR `ast_node_prev_if
    VAR `ast_node_repeat
    VAR `ast_node_repstop
    VAR `control_type_j_0
    VAR `j
    VAR `j1
    VAR `j2
    VAR `lnid_elsif_else
    VAR `lnid_endif
    VAR `lnid_endrep
    VAR `lnid_if
    VAR `lnid_j
    VAR `lnid_prev_elsif_else
    VAR `lnid_prev_if
    VAR `lnid_repeat
    VAR `lnid_repstop
    VAR `lnno_elsif_else
    VAR `lnno_prev_elsif_else
    VAR `prev_ast_node
    VAR `prev_lnid
    VAR `set_control_j
    VAR `type_if
    THIS.`_is_compiled = TRUE
    THIS.`_entry_lnid = NULL
    FORINCR `j(0 `length(THIS.`_lines_id)):
      `lnid_j = THIS.`_lines_id[`j]
      IF `isnull(`utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_j])):
        continue
      ENDIF
      THIS.`_entry_lnid = `lnid_j
      break
    ENDFOR
    IF `isnull(THIS.`_entry_lnid):
      return
    ENDIF
    `prev_lnid = THIS.`_entry_lnid
    `prev_ast_node = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`prev_lnid])
    VAR `start_j = `indexof(THIS.`_lines_id, THIS.`_entry_lnid)+1
    FORINCR `j(`start_j `length(THIS.`_lines_id)):
      `lnid_j = THIS.`_lines_id[`j]
      `ast_node_j = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_j])
      IF `isnull(`ast_node_j):
        continue
      ENDIF
      `prev_ast_node[1] = `lnid_j
      `prev_lnid = `lnid_j
      `prev_ast_node = `ast_node_j
    ENDFOR
    `prev_ast_node[1] = NULL
    FORINCR `j1(0 `length(THIS.`_sets_control)):
      `set_control_j = THIS.`_sets_control[`j1]
      `control_type_j_0 = `set_control_j[0][1]
      IF `control_type_j_0 == `key_token_IF:
        `lnid_prev_if = `set_control_j[0][0]
        `ast_node_prev_if = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_prev_if])
        FORINCR `j2(1 `length(`set_control_j)):
          `lnid_if  = `set_control_j[`j2][0]
          `ast_node_if = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_if])
          `ast_node_prev_if[2] = `lnid_if
          `type_if = `set_control_j[`j2][1]
          IF (`type_if != `key_token_IF) AND (`type_if != `key_token_ELSIF):
            break
          ENDIF
          `lnid_prev_if = `lnid_if
          `ast_node_prev_if = `ast_node_if
        ENDFOR
        `lnid_endif = `set_control_j[`length(`set_control_j)-1][0]
        FORINCR `j2(1 `length(`set_control_j)-1):
          `lnid_elsif_else = `set_control_j[`j2][0]
          `lnno_elsif_else = `indexof(THIS.`_lines_id, `lnid_elsif_else)
          `lnno_prev_elsif_else = `lnno_elsif_else-1
          WHILE TRUE:
            `lnid_prev_elsif_else = THIS.`_lines_id[`lnno_prev_elsif_else]
            `ast_node_prev_elsif_else = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_prev_elsif_else])
            IF `isnull(`ast_node_prev_elsif_else):
              `lnno_prev_elsif_else -= 1
              continue
            ENDIF
            IF `ast_node_prev_elsif_else[0] == `OPCODE_REPNEXT:
              break
            ELSIF `ast_node_prev_elsif_else[0] == `OPCODE_REPSTOP:
              break
            ENDIF
            `ast_node_prev_elsif_else[1] = `lnid_endif
            break
          ENDWHILE
        ENDFOR
      ELSE:
        `lnid_repeat = `set_control_j[0][0]
        `ast_node_repeat = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_repeat])
        `lnid_endrep = `set_control_j[`length(`set_control_j)-1][0]
        `ast_node_endrep = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_endrep])
        `ast_node_repeat[2] = `lnid_endrep
        `ast_node_endrep[2] = `lnid_repeat
        FORINCR `j2(1 `length(`set_control_j)-1):
          `lnid_repstop = `set_control_j[`j2][0]
          `ast_node_repstop = `utils_editor_m.`lineastAst(THIS.`_lines_ast[`lnid_repstop])
          `ast_node_repstop[1] = `lnid_endrep
        ENDFOR
      ENDIF
    ENDFOR

  METHOD `destroy():
    VAR `x = NULL

ENDCLASS

CLASS `Environment:

  METHOD_INIT():
    THIS.`reset()

  METHOD `reset():
    THIS.`_env = []

  METHOD `vars():
    VAR `vs = []
    VAR `j
    FORINCR `j(0 `length(THIS.`_env)):
      `push(`vs, THIS.`_env[`j][0])
    ENDFOR
    return `vs

  METHOD `set(`evar `evalue):
    VAR `j
    FORINCR `j(0 `length(THIS.`_env)):
      IF THIS.`_env[`j][0] == `evar:
        THIS.`_env[`j][1] = `evalue
        return
      ENDIF
    ENDFOR
    `push(THIS.`_env, [`evar, `evalue, 0])

  METHOD `overwrite(`evar `varvalue):
    VAR `j
    FORINCR `j(0 `length(THIS.`_env)):
      IF THIS.`_env[`j][0] == `evar:
        IF `not(`utils.`encodeOverwriteData(THIS.`_env[`j][1], `varvalue)):
          `pick(THIS.`_env, `j)
          return FALSE
        ENDIF
        return TRUE
      ENDIF
    ENDFOR
    return FALSE

  METHOD `get(`evar):
    VAR `count = 0
    VAR `evalue = NULL
    VAR `e
    VAR `j
    VAR `j2
    FORINCR `j(0 `length(THIS.`_env)):
      `count += 1
      IF THIS.`_env[`j][0] == `evar:
        THIS.`_env[`j][2] += `count
        `evalue = THIS.`_env[`j][1]
        `j2 = `j
        WHILE (`j2-1 >= 0) AND (THIS.`_env[`j2-1][2] < THIS.`_env[`j][2]):
          `j2 -= 1
        ENDWHILE
        IF `j2 == `j:
          break
        ENDIF
        `e = `pick(THIS.`_env, `j)
        `poke(THIS.`_env, `j2, `e)
        break
      ENDIF
    ENDFOR
    IF `not(`isnull(`evalue)) AND (THIS.`_env[0][2] >= 120000):
      FORINCR `j(0 `length(THIS.`_env)):
        IF THIS.`_env[`j][2] > 80000:
          THIS.`_env[`j][2] -= 80000
        ELSE:
          THIS.`_env[`j][2] = 0
        ENDIF
      ENDFOR
    ENDIF
    return `evalue

  METHOD `del(`evar):
    VAR `j
    FORINCR `j(0 `length(THIS.`_env)):
      IF THIS.`_env[`j][0] == `evar:
        `pick(THIS.`_env, `j)
        break
      ENDIF
    ENDFOR

  METHOD `destroy():
    WHILE `length(THIS.`_env) > 0:
      `pop(THIS.`_env)
    ENDWHILE
    THIS.`_env = NULL

ENDCLASS

VAR `INTERP_STATE_READY = 0
VAR `INTERP_STATE_LIMIT = 1
VAR `INTERP_STATE_PAUSE = 2
VAR `INTERP_STATE_YIELD = 3
VAR `INTERP_STATE_ERROR = 4
VAR `INTERP_STATE_ENDED = 5

FUNC `func_iexpr_rel_op_eq(`v1 `v2):
  return (`v1 == `v2)
ENDFUNC

FUNC `func_iexpr_rel_op_ne(`v1 `v2):
  return (`v1 != `v2)
ENDFUNC

FUNC `func_iexpr_rel_op_lt(`v1 `v2):
  return (`v1 < `v2)
ENDFUNC

FUNC `func_iexpr_rel_op_le(`v1 `v2):
  return (`v1 <= `v2)
ENDFUNC

FUNC `func_iexpr_rel_op_gt(`v1 `v2):
  return (`v1 > `v2)
ENDFUNC

FUNC `func_iexpr_rel_op_ge(`v1 `v2):
  return (`v1 >= `v2)
ENDFUNC

FUNC `func_iexpr_unary_op_neg(`v):
  return `fp[0].Neg(`v)
ENDFUNC

FUNC `func_iexpr_unary_op_bit_not(`v):
  return (~`v)
ENDFUNC

FUNC `func_iexpr_add_op_plus(`v1 `v2):
  return `fp[0].Add(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_add_op_minus(`v1 `v2):
  return `fp[0].Sub(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_add_op_bit_or(`v1 `v2):
  return (`v1 | `v2)
ENDFUNC

FUNC `func_iexpr_add_op_bit_xor(`v1 `v2):
  return (`v1 ^ `v2)
ENDFUNC

FUNC `func_iexpr_mul_op_mul(`v1 `v2):
  return `fp[0].Mul(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_mul_op_div(`v1 `v2):
  return `fp[0].Div(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_mul_op_idv(`v1 `v2):
  return `fp[0].Floor(`fp[0].Div(`v1, `v2))
ENDFUNC

FUNC `func_iexpr_mul_op_mod(`v1 `v2):
  return `fp[0].Mod(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_mul_op_bit_and(`v1 `v2):
  return (`v1 & `v2)
ENDFUNC

FUNC `func_iexpr_mul_op_bit_shl(`v1 `v2):
  `v2 = `fp[0].FloorToInt(`v2)
  IF `v2 >= 32:
    return 0
  ELSIF `v2 >= 0:
    return `int32(`v1 << `v2)
  ELSIF `v2 <= -31:
    return TERNARY{(`v1 & 0x80000000) == 0}{0}{-1}
  ENDIF
  return `int32(`v1 >> (-`v2))
ENDFUNC

FUNC `func_iexpr_mul_op_bit_shr(`v1 `v2):
  `v2 = `fp[0].FloorToInt(`v2)
  IF `v2 >= 31:
    return TERNARY{(`v1 & 0x80000000) == 0}{0}{-1}
  ELSIF `v2 >= 0:
    return `int32(`v1 >> `v2)
  ELSIF `v2 <= -32:
    return 0
  ENDIF
  return `int32(`v1 << (-`v2))
ENDFUNC

FUNC `func_iexpr_size_var_size(`lsize `nsize):
  return (`lsize+`nsize)
ENDFUNC

FUNC `func_iexpr_size_var_nsize(`lsize `nsize):
  return `nsize
ENDFUNC

FUNC `func_iexpr_size_var_lsize(`lsize `nsize):
  return `lsize
ENDFUNC

FUNC `func_iexpr_math_op_abs(`v):
  return `fp[0].Abs(`v)
ENDFUNC

FUNC `func_iexpr_math_op_acos(`v):
  return `fp[0].Acos(`v)
ENDFUNC

FUNC `func_iexpr_math_op_asin(`v):
  return `fp[0].Asin(`v)
ENDFUNC

FUNC `func_iexpr_math_op_atan(`v):
  return `fp[0].Atan(`v)
ENDFUNC

FUNC `func_iexpr_math_op_atan2(`v1 `v2):
  return `fp[0].Atan2(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_math_op_ceil(`v):
  return `fp[0].Ceil(`v)
ENDFUNC

FUNC `func_iexpr_math_op_cos(`v):
  return `fp[0].Cos(`v)
ENDFUNC

FUNC `func_iexpr_math_op_exp(`v):
  return `fp[0].Exp(`v)
ENDFUNC

FUNC `func_iexpr_math_op_exp2(`v):
  return `fp[0].Exp2(`v)
ENDFUNC

FUNC `func_iexpr_math_op_floor(`v):
  return `fp[0].Floor(`v)
ENDFUNC

FUNC `func_iexpr_math_op_log(`v):
  return `fp[0].Log(`v)
ENDFUNC

FUNC `func_iexpr_math_op_log2(`v):
  return `fp[0].Log2(`v)
ENDFUNC

FUNC `func_iexpr_math_op_max(`v1 `v2):
  return `fp[0].Max(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_math_op_min(`v1 `v2):
  return `fp[0].Min(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_math_op_pow(`v1 `v2):
  return `fp[0].Pow(`v1, `v2)
ENDFUNC

FUNC `func_iexpr_math_op_round(`v):
  return `fp[0].Round(`v)
ENDFUNC

FUNC `func_iexpr_math_op_sign(`v):
  return `fp[0].Sign(`v)
ENDFUNC

FUNC `func_iexpr_math_op_sin(`v):
  return `fp[0].Sin(`v)
ENDFUNC

FUNC `func_iexpr_math_op_sqrt(`v):
  return `fp[0].Sqrt(`v)
ENDFUNC

FUNC `func_iexpr_math_op_tan(`v):
  return `fp[0].Tan(`v)
ENDFUNC

CLASS `InterpM:

  METHOD_INIT(`editor_m `getEvar `onProcedure `onYieldResume `rnd32b `instance `existsInstanceCsvar `getInstanceCsvar `__addInstanceCsvar `__removeInstanceCsvar `__updateInstanceCsvarDeltaCost `inInstanceRepeatCsvars `isCsinstanceStatusCodeNull `getCsinstance):
    THIS.`_lines_id = `editor_m.`getLinesId()
    THIS.`_lines_ast = `editor_m.`getLinesAst()
    VAR `breakpoints_info = `editor_m.`getBreakpointsInfo()
    THIS.`_breakpoints = `breakpoints_info[0]
    THIS.`_entry_pcounter = `editor_m.`getEntryLnid()
    THIS.`_getEvar = `getEvar
    THIS.`_onProcedure = `onProcedure
    THIS.`_onYieldResume = `onYieldResume
    THIS.`_rnd32b = `rnd32b
    THIS.`_instance = `instance
    THIS.`_existsInstanceCsvar = `existsInstanceCsvar
    THIS.`_getInstanceCsvar = `getInstanceCsvar
    THIS.`_addInstanceCsvar = `__addInstanceCsvar
    THIS.`_removeInstanceCsvar = `__removeInstanceCsvar
    THIS.`_updateInstanceCsvarDeltaCost = `__updateInstanceCsvarDeltaCost
    THIS.`_inInstanceRepeatCsvars = `inInstanceRepeatCsvars
    THIS.`_isCsinstanceStatusCodeNull = `isCsinstanceStatusCodeNull
    THIS.`_getCsinstance = `getCsinstance
    THIS.`_max_debugl_lines = NULL
    THIS.`_max_debugl_chars_per_line = NULL
    THIS.`_environment = NEW `Environment()
    THIS.`_varnames = []
    THIS.`_prev_pcounter = NULL
    THIS.`_pcounter = THIS.`_entry_pcounter
    THIS.`_repeat_vars = []
    THIS.`_has_repstop = FALSE
    THIS.`_debugl_lines = []
    THIS.`_changed_vars = []
    THIS.`_error = NULL
    THIS.`_status_code = NULL
    THIS.`_memory_delta_n = 0
    THIS.`_memory_delta_l = 0
    THIS.`_yield = FALSE
    THIS.`_procedure = NULL
    THIS.`_limits = `utils.`getNormalizedLimits(NULL)
    THIS.`_count = {}
    THIS.`_count[`key_limits_instructions] = NULL
    THIS.`_count[`key_limits_max_memory] = NULL
    THIS.`_count[`key_limits_memory] = NULL
    THIS.`_count[`key_limits_memory_n] = NULL
    THIS.`_count[`key_limits_memory_l] = NULL
    THIS.`_tmpNumber = [`key_interp_number, 0, 0, 1]
    THIS.`_tmpBoolean = [`key_interp_boolean, TRUE]
    THIS.`_tmpByRef = [`key_interp_by_ref, NULL]
    THIS.`_tmpModuleName = [`key_interp_module_name, NULL]
    THIS.`_tmpString = [`key_interp_string, NULL]
    VAR `that = THIS
    CLOSURE `closure_istmt_assign_op(`instruction):
      `that.`_istmtAssignOp(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_assign_op_csvar(`instruction):
      `that.`_istmtAssignOpCsvar(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_assign_op_random(`instruction):
      `that.`_istmtAssignOpRandom(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_assign_pop(`instruction):
      `that.`_istmtAssignPop(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_assign_unqueue(`instruction):
      `that.`_istmtAssignUnqueue(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_if(`instruction):
      `that.`_istmtIf(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_elsif(`instruction):
      `that.`_istmtElsif(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_else(`instruction):
      `that.`_istmtElse(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_endif(`instruction):
      `that.`_istmtEndif(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_repeat(`instruction):
      `that.`_istmtRepeat(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_repnext(`instruction):
      `that.`_istmtRepnext(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_repstop(`instruction):
      `that.`_istmtRepstop(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_endrep(`instruction):
      `that.`_istmtEndrep(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_procedure(`instruction):
      `that.`_istmtProcedure(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_push(`instruction):
      `that.`_istmtPush(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_queue(`instruction):
      `that.`_istmtQueue(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_unassign(`instruction):
      `that.`_istmtUnassign(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_unassign_csvar(`instruction):
      `that.`_istmtUnassignCsvar(`instruction)
    ENDCLOSURE
    CLOSURE `closure_istmt_debugl(`instruction):
      `that.`_istmtDebugl(`instruction)
    ENDCLOSURE
    THIS.`_dispatch_stmt = {}
    THIS.`_dispatch_stmt[`OPCODE_ASSIGN_OP] = `closure_istmt_assign_op
    THIS.`_dispatch_stmt[`OPCODE_ASSIGN_OP_CSVAR] = `closure_istmt_assign_op_csvar
    THIS.`_dispatch_stmt[`OPCODE_ASSIGN_OP_RANDOM] = `closure_istmt_assign_op_random
    THIS.`_dispatch_stmt[`OPCODE_ASSIGN_POP] = `closure_istmt_assign_pop
    THIS.`_dispatch_stmt[`OPCODE_ASSIGN_UNQUEUE] = `closure_istmt_assign_unqueue
    THIS.`_dispatch_stmt[`OPCODE_IF] = `closure_istmt_if
    THIS.`_dispatch_stmt[`OPCODE_ELSIF] = `closure_istmt_elsif
    THIS.`_dispatch_stmt[`OPCODE_ELSE] = `closure_istmt_else
    THIS.`_dispatch_stmt[`OPCODE_ENDIF] = `closure_istmt_endif
    THIS.`_dispatch_stmt[`OPCODE_REPEAT] = `closure_istmt_repeat
    THIS.`_dispatch_stmt[`OPCODE_REPNEXT] = `closure_istmt_repnext
    THIS.`_dispatch_stmt[`OPCODE_REPSTOP] = `closure_istmt_repstop
    THIS.`_dispatch_stmt[`OPCODE_ENDREP] = `closure_istmt_endrep
    THIS.`_dispatch_stmt[`OPCODE_PROCEDURE] = `closure_istmt_procedure
    THIS.`_dispatch_stmt[`OPCODE_PUSH] = `closure_istmt_push
    THIS.`_dispatch_stmt[`OPCODE_QUEUE] = `closure_istmt_queue
    THIS.`_dispatch_stmt[`OPCODE_UNASSIGN] = `closure_istmt_unassign
    THIS.`_dispatch_stmt[`OPCODE_UNASSIGN_CSVAR] = `closure_istmt_unassign_csvar
    THIS.`_dispatch_stmt[`OPCODE_DEBUGL] = `closure_istmt_debugl
    CLOSURE `closure_iexpr_number(`expression):
      return `that.`_iexprNumber(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_list(`expression):
      return `that.`_iexprList(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_by_ref(`expression):
      return `that.`_iexprByRef(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_module_name(`expression):
      return `that.`_iexprModuleName(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_string(`expression):
      return `that.`_iexprString(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_or(`expression):
      return `that.`_iexprOr(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_and(`expression):
      return `that.`_iexprAnd(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_not(`expression):
      return `that.`_iexprNot(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_rel_op_eq(`expression):
      return `that.`_iexprRelOp(`expression, `func_iexpr_rel_op_eq)
    ENDCLOSURE
    CLOSURE `closure_iexpr_rel_op_ne(`expression):
      return `that.`_iexprRelOp(`expression, `func_iexpr_rel_op_ne)
    ENDCLOSURE
    CLOSURE `closure_iexpr_rel_op_lt(`expression):
      return `that.`_iexprRelOp(`expression, `func_iexpr_rel_op_lt)
    ENDCLOSURE
    CLOSURE `closure_iexpr_rel_op_le(`expression):
      return `that.`_iexprRelOp(`expression, `func_iexpr_rel_op_le)
    ENDCLOSURE
    CLOSURE `closure_iexpr_rel_op_gt(`expression):
      return `that.`_iexprRelOp(`expression, `func_iexpr_rel_op_gt)
    ENDCLOSURE
    CLOSURE `closure_iexpr_rel_op_ge(`expression):
      return `that.`_iexprRelOp(`expression, `func_iexpr_rel_op_ge)
    ENDCLOSURE
    CLOSURE `closure_iexpr_unary_op_neg(`expression):
      return `that.`_iexprUnaryOp(`expression, `func_iexpr_unary_op_neg)
    ENDCLOSURE
    CLOSURE `closure_iexpr_unary_op_bit_not(`expression):
      return `that.`_iexprUnaryOp(`expression, `func_iexpr_unary_op_bit_not)
    ENDCLOSURE
    CLOSURE `closure_iexpr_add_op_plus(`expression):
      return `that.`_iexprAddOp(`expression, `func_iexpr_add_op_plus)
    ENDCLOSURE
    CLOSURE `closure_iexpr_add_op_minus(`expression):
      return `that.`_iexprAddOp(`expression, `func_iexpr_add_op_minus)
    ENDCLOSURE
    CLOSURE `closure_iexpr_add_op_bit_or(`expression):
      return `that.`_iexprAddOp(`expression, `func_iexpr_add_op_bit_or)
    ENDCLOSURE
    CLOSURE `closure_iexpr_add_op_bit_xor(`expression):
      return `that.`_iexprAddOp(`expression, `func_iexpr_add_op_bit_xor)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_mul(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_mul)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_div(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_div)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_idv(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_idv)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_mod(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_mod)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_bit_and(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_bit_and)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_bit_shl(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_bit_shl)
    ENDCLOSURE
    CLOSURE `closure_iexpr_mul_op_bit_shr(`expression):
      return `that.`_iexprMulOp(`expression, `func_iexpr_mul_op_bit_shr)
    ENDCLOSURE
    CLOSURE `closure_iexpr_ivar(`expression):
      return `that.`_iexprIvar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_evar(`expression):
      return `that.`_iexprEvar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_csvar(`expression):
      return `that.`_iexprCsvar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_is(`expression):
      return `that.`_iexprIs(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_is_not(`expression):
      return `that.`_iexprIsNot(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_length_var(`expression):
      return `that.`_iexprLengthVar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_size_var_size(`expression):
      return `that.`_iexprSizeVar(`expression, `func_iexpr_size_var_size)
    ENDCLOSURE
    CLOSURE `closure_iexpr_size_var_nsize(`expression):
      return `that.`_iexprSizeVar(`expression, `func_iexpr_size_var_nsize)
    ENDCLOSURE
    CLOSURE `closure_iexpr_size_var_lsize(`expression):
      return `that.`_iexprSizeVar(`expression, `func_iexpr_size_var_lsize)
    ENDCLOSURE
    CLOSURE `closure_iexpr_indexof_var(`expression):
      return `that.`_iexprIndexofVar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_list_at_list(`expression):
      return `that.`_iexprListAtList(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_list_at_ivar(`expression):
      return `that.`_iexprListAtIvar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_list_at_evar(`expression):
      return `that.`_iexprListAtEvar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_list_at_csvar(`expression):
      return `that.`_iexprListAtCsvar(`expression)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_abs(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_abs)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_acos(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_acos)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_asin(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_asin)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_atan(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_atan)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_atan2(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_atan2)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_ceil(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_ceil)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_cos(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_cos)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_exp(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_exp)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_exp2(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_exp2)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_floor(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_floor)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_log(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_log)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_log2(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_log2)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_max(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_max)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_min(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_min)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_pow(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_pow)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_round(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_round)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_sign(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_sign)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_sin(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_sin)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_sqrt(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_sqrt)
    ENDCLOSURE
    CLOSURE `closure_iexpr_math_op_tan(`expression):
      return `that.`_iexprMathOp(`expression, `func_iexpr_math_op_tan)
    ENDCLOSURE
    THIS.`_dispatch_expr = {}
    THIS.`_dispatch_expr[`OPCODE_NUMBER] = `closure_iexpr_number
    THIS.`_dispatch_expr[`OPCODE_LIST] = `closure_iexpr_list
    THIS.`_dispatch_expr[`OPCODE_BY_REF] = `closure_iexpr_by_ref
    THIS.`_dispatch_expr[`OPCODE_MODULE_NAME] = `closure_iexpr_module_name
    THIS.`_dispatch_expr[`OPCODE_STRING] = `closure_iexpr_string
    THIS.`_dispatch_expr[`OPCODE_OR] = `closure_iexpr_or
    THIS.`_dispatch_expr[`OPCODE_AND] = `closure_iexpr_and
    THIS.`_dispatch_expr[`OPCODE_NOT] = `closure_iexpr_not
    THIS.`_dispatch_expr[`OPCODE_EQ] = `closure_iexpr_rel_op_eq
    THIS.`_dispatch_expr[`OPCODE_NE] = `closure_iexpr_rel_op_ne
    THIS.`_dispatch_expr[`OPCODE_LT] = `closure_iexpr_rel_op_lt
    THIS.`_dispatch_expr[`OPCODE_LE] = `closure_iexpr_rel_op_le
    THIS.`_dispatch_expr[`OPCODE_GT] = `closure_iexpr_rel_op_gt
    THIS.`_dispatch_expr[`OPCODE_GE] = `closure_iexpr_rel_op_ge
    THIS.`_dispatch_expr[`OPCODE_NEG] = `closure_iexpr_unary_op_neg
    THIS.`_dispatch_expr[`OPCODE_BIT_NOT] = `closure_iexpr_unary_op_bit_not
    THIS.`_dispatch_expr[`OPCODE_PLUS] = `closure_iexpr_add_op_plus
    THIS.`_dispatch_expr[`OPCODE_MINUS] = `closure_iexpr_add_op_minus
    THIS.`_dispatch_expr[`OPCODE_BIT_OR] = `closure_iexpr_add_op_bit_or
    THIS.`_dispatch_expr[`OPCODE_BIT_XOR] = `closure_iexpr_add_op_bit_xor
    THIS.`_dispatch_expr[`OPCODE_MUL] = `closure_iexpr_mul_op_mul
    THIS.`_dispatch_expr[`OPCODE_DIV] = `closure_iexpr_mul_op_div
    THIS.`_dispatch_expr[`OPCODE_IDV] = `closure_iexpr_mul_op_idv
    THIS.`_dispatch_expr[`OPCODE_MOD] = `closure_iexpr_mul_op_mod
    THIS.`_dispatch_expr[`OPCODE_BIT_AND] = `closure_iexpr_mul_op_bit_and
    THIS.`_dispatch_expr[`OPCODE_BIT_SHL] = `closure_iexpr_mul_op_bit_shl
    THIS.`_dispatch_expr[`OPCODE_BIT_SHR] = `closure_iexpr_mul_op_bit_shr
    THIS.`_dispatch_expr[`OPCODE_IVAR] = `closure_iexpr_ivar
    THIS.`_dispatch_expr[`OPCODE_EVAR] = `closure_iexpr_evar
    THIS.`_dispatch_expr[`OPCODE_CSVAR] = `closure_iexpr_csvar
    THIS.`_dispatch_expr[`OPCODE_IS] = `closure_iexpr_is
    THIS.`_dispatch_expr[`OPCODE_IS_NOT] = `closure_iexpr_is_not
    THIS.`_dispatch_expr[`OPCODE_LENGTH_VAR] = `closure_iexpr_length_var
    THIS.`_dispatch_expr[`OPCODE_SIZE_VAR] = `closure_iexpr_size_var_size
    THIS.`_dispatch_expr[`OPCODE_NSIZE_VAR] = `closure_iexpr_size_var_nsize
    THIS.`_dispatch_expr[`OPCODE_LSIZE_VAR] = `closure_iexpr_size_var_lsize
    THIS.`_dispatch_expr[`OPCODE_INDEXOF_VAR] = `closure_iexpr_indexof_var
    THIS.`_dispatch_expr[`OPCODE_LIST_AT_LIST] = `closure_iexpr_list_at_list
    THIS.`_dispatch_expr[`OPCODE_LIST_AT_IVAR] = `closure_iexpr_list_at_ivar
    THIS.`_dispatch_expr[`OPCODE_LIST_AT_EVAR] = `closure_iexpr_list_at_evar
    THIS.`_dispatch_expr[`OPCODE_LIST_AT_CSVAR] = `closure_iexpr_list_at_csvar
    THIS.`_dispatch_expr[`OPCODE_MATH_ABS] = `closure_iexpr_math_op_abs
    THIS.`_dispatch_expr[`OPCODE_MATH_ACOS] = `closure_iexpr_math_op_acos
    THIS.`_dispatch_expr[`OPCODE_MATH_ASIN] = `closure_iexpr_math_op_asin
    THIS.`_dispatch_expr[`OPCODE_MATH_ATAN] = `closure_iexpr_math_op_atan
    THIS.`_dispatch_expr[`OPCODE_MATH_ATAN2] = `closure_iexpr_math_op_atan2
    THIS.`_dispatch_expr[`OPCODE_MATH_CEIL] = `closure_iexpr_math_op_ceil
    THIS.`_dispatch_expr[`OPCODE_MATH_COS] = `closure_iexpr_math_op_cos
    THIS.`_dispatch_expr[`OPCODE_MATH_EXP] = `closure_iexpr_math_op_exp
    THIS.`_dispatch_expr[`OPCODE_MATH_EXP2] = `closure_iexpr_math_op_exp2
    THIS.`_dispatch_expr[`OPCODE_MATH_FLOOR] = `closure_iexpr_math_op_floor
    THIS.`_dispatch_expr[`OPCODE_MATH_LOG] = `closure_iexpr_math_op_log
    THIS.`_dispatch_expr[`OPCODE_MATH_LOG2] = `closure_iexpr_math_op_log2
    THIS.`_dispatch_expr[`OPCODE_MATH_MAX] = `closure_iexpr_math_op_max
    THIS.`_dispatch_expr[`OPCODE_MATH_MIN] = `closure_iexpr_math_op_min
    THIS.`_dispatch_expr[`OPCODE_MATH_POW] = `closure_iexpr_math_op_pow
    THIS.`_dispatch_expr[`OPCODE_MATH_ROUND] = `closure_iexpr_math_op_round
    THIS.`_dispatch_expr[`OPCODE_MATH_SIGN] = `closure_iexpr_math_op_sign
    THIS.`_dispatch_expr[`OPCODE_MATH_SIN] = `closure_iexpr_math_op_sin
    THIS.`_dispatch_expr[`OPCODE_MATH_SQRT] = `closure_iexpr_math_op_sqrt
    THIS.`_dispatch_expr[`OPCODE_MATH_TAN] = `closure_iexpr_math_op_tan
    THIS.`_data_v = NULL

  METHOD `readDebugl():
    VAR `debugl_lines = THIS.`_debugl_lines
    THIS.`_debugl_lines = []
    return `debugl_lines

  METHOD `readChangedVars():
    VAR `changed_vars = THIS.`_changed_vars
    THIS.`_changed_vars = []
    return `changed_vars

  METHOD `_addChangedVar(`varname):
    IF `indexof(THIS.`_changed_vars, `varname) >= 0:
      return
    ENDIF
    `push(THIS.`_changed_vars, `varname)

  METHOD `_getLnno(`lnid):
    IF `isnull(`lnid):
      return -1
    ENDIF
    return `indexof(THIS.`_lines_id, `lnid)

  METHOD `_setRuntimeError(`error_message):
    THIS.`_error = `error_message

  METHOD `getVarNames():
    return THIS.`_varnames

  METHOD `addVar(`varname `evalue):
    VAR `delta_cost_n = `utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = `utils.`lsizeEvalue(`evalue)
    THIS.`_memory_delta_n += `delta_cost_n
    THIS.`_memory_delta_l += `delta_cost_l
    THIS.`_addChangedVar(`varname)
    THIS.`_addVar(`varname, `evalue)

  METHOD `getVar(`varname):
    return THIS.`_environment.`get(`varname)

  METHOD `removeVar(`varname):
    VAR `evalue = THIS.`getVar(`varname)
    VAR `delta_cost_n = -`utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = -`utils.`lsizeEvalue(`evalue)
    THIS.`_memory_delta_n += `delta_cost_n
    THIS.`_memory_delta_l += `delta_cost_l
    THIS.`_addChangedVar(`varname)
    THIS.`_removeVar(`varname)

  METHOD `addCsvar(`varname `evalue):
    THIS.`_addVar(`varname, `evalue)

  METHOD `addCsvarCost(`varname `evalue):
    VAR `delta_cost_n = `utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = `utils.`lsizeEvalue(`evalue)
    THIS.`updateCsvarDeltaCost(`varname, `delta_cost_n, `delta_cost_l)

  METHOD `removeCsvar(`varname):
    VAR `evalue = THIS.`getVar(`varname)
    THIS.`_removeVar(`varname)
    return `evalue

  METHOD `removeCsvarCost(`varname `evalue):
    VAR `delta_cost_n = -`utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = -`utils.`lsizeEvalue(`evalue)
    THIS.`updateCsvarDeltaCost(`varname, `delta_cost_n, `delta_cost_l)

  METHOD `updateCsvarDeltaCost(`varname `delta_cost_n `delta_cost_l):
    THIS.`_memory_delta_n += `delta_cost_n
    THIS.`_memory_delta_l += `delta_cost_l
    THIS.`_addChangedVar(`varname)

  METHOD `_addVar(`varname `evalue):
    IF `indexof(THIS.`_varnames, `varname) < 0:
      `push(THIS.`_varnames, `varname)
    ENDIF
    THIS.`_environment.`set(`varname, `evalue)

  METHOD `_removeVar(`varname):
    VAR `idx = `indexof(THIS.`_varnames, `varname)
    IF `idx >= 0:
      `pick(THIS.`_varnames, `idx)
    ENDIF
    THIS.`_environment.`del(`varname)

  METHOD `inRepeatVars(`varname):
    return (`indexof(THIS.`_repeat_vars, `varname) >= 0)

  METHOD `run(`instance `stepping `limits):
    return THIS.`_run(`instance, FALSE, `stepping, `limits)

  METHOD `resume(`instance `resume_yield `stepping `limits_):
    VAR `limits
    IF `not(`isnull(`limits_)):
      `limits = `limits_
    ELSE:
      `limits = THIS.`_limits
      IF `not(`isnull(`limits[`key_limits_instructions])):
        `limits[`key_limits_instructions] -= THIS.`_count[`key_limits_instructions]
      ENDIF
      IF `not(`isnull(`limits[`key_limits_memory])):
        `limits[`key_limits_memory] -= THIS.`_count[`key_limits_memory]
      ENDIF
      IF `not(`isnull(`limits[`key_limits_memory_n])):
        `limits[`key_limits_memory_n] -= THIS.`_count[`key_limits_memory_n]
      ENDIF
      IF `not(`isnull(`limits[`key_limits_memory_l])):
        `limits[`key_limits_memory_l] -= THIS.`_count[`key_limits_memory_l]
      ENDIF
    ENDIF
    return THIS.`_run(`instance, `resume_yield, `stepping, `limits)

  METHOD `reap():
    THIS.`_prev_pcounter = NULL
    THIS.`_pcounter = THIS.`_entry_pcounter
    THIS.`_repeat_vars = []
    THIS.`_has_repstop = FALSE
    THIS.`_debugl_lines = []
    THIS.`_changed_vars = []
    THIS.`_error = NULL
    THIS.`_status_code = NULL
    THIS.`_memory_delta_n = 0
    THIS.`_memory_delta_l = 0
    THIS.`_yield = FALSE
    THIS.`_procedure = NULL

  METHOD `reset():
    THIS.`_environment.`reset()
    THIS.`_varnames = []

  METHOD `getStatusCode():
    return THIS.`_status_code

  METHOD `returnWithStatus(`status_code):
    THIS.`_status_code = `status_code

  METHOD `prequelYield():
    THIS.`_yield = TRUE

  METHOD `runtimeError(`error_message):
    THIS.`_setRuntimeError(`error_message)

  METHOD `_run(`instance `resume_yield `stepping `limits):
    THIS.`_limits = `limits
    THIS.`_count[`key_limits_instructions] = 0
    THIS.`_count[`key_limits_max_memory] = 0
    THIS.`_count[`key_limits_memory] = 0
    THIS.`_count[`key_limits_memory_n] = 0
    THIS.`_count[`key_limits_memory_l] = 0
    THIS.`_yield = FALSE
    VAR `force
    VAR `instruction
    VAR `next_pcounter
    VAR `status_code
    VAR `was_procedure
    IF `resume_yield:
      THIS.`_error = NULL
      THIS.`_status_code = NULL
      THIS.`_memory_delta_n = 0
      THIS.`_memory_delta_l = 0
      THIS.`_onYieldResume(`instance)
      IF `not(`isnull(THIS.`_error)):
        return [`INTERP_STATE_ERROR, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), THIS.`_error]
      ENDIF
      THIS.`_count[`key_limits_memory] += (THIS.`_memory_delta_l+THIS.`_memory_delta_n)
      THIS.`_count[`key_limits_memory_n] += THIS.`_memory_delta_n
      THIS.`_count[`key_limits_memory_l] += THIS.`_memory_delta_l
      IF THIS.`_count[`key_limits_max_memory] < THIS.`_count[`key_limits_memory]:
        THIS.`_count[`key_limits_max_memory] = THIS.`_count[`key_limits_memory]
      ENDIF
      IF THIS.`_yield:
        return [`INTERP_STATE_YIELD, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter)]
      ENDIF
      `instruction = `utils_editor_m.`lineastAst(THIS.`_lines_ast[THIS.`_pcounter])
      `next_pcounter = `instruction[1]
      THIS.`_pcounter = `next_pcounter
      THIS.`_count[`key_limits_instructions] += 1
      IF `not(`isnull(THIS.`_status_code)):
        THIS.`_pcounter = NULL
        return [`INTERP_STATE_ENDED, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), THIS.`_status_code]
      ENDIF
      IF `isnull(THIS.`_pcounter):
        `status_code = 0
        return [`INTERP_STATE_ENDED, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), `status_code]
      ENDIF
      IF (`not(`isnull(THIS.`_limits[`key_limits_instructions])) AND (THIS.`_limits[`key_limits_instructions] <= THIS.`_count[`key_limits_instructions])) OR (`not(`isnull(THIS.`_limits[`key_limits_memory])) AND (THIS.`_limits[`key_limits_memory] <= THIS.`_count[`key_limits_memory])) OR (`not(`isnull(THIS.`_limits[`key_limits_memory_n])) AND (THIS.`_limits[`key_limits_memory_n] <= THIS.`_count[`key_limits_memory_n])) OR (`not(`isnull(THIS.`_limits[`key_limits_memory_l])) AND (THIS.`_limits[`key_limits_memory_l] <= THIS.`_count[`key_limits_memory_l])):
        return [`INTERP_STATE_LIMIT, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter)]
      ENDIF
    ENDIF
    IF `isnull(THIS.`_pcounter):
      `status_code = 0
      return [`INTERP_STATE_ENDED, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), `status_code]
    ENDIF
    `force = (THIS.`_pcounter == THIS.`_prev_pcounter)
    `was_procedure = FALSE
    WHILE TRUE:
      `instruction = `utils_editor_m.`lineastAst(THIS.`_lines_ast[THIS.`_pcounter])
      IF (`stepping OR (`indexof(THIS.`_breakpoints, THIS.`_pcounter) >= 0)) AND `not(`force):
        THIS.`_prev_pcounter = THIS.`_pcounter
        return [`INTERP_STATE_PAUSE, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter)]
      ENDIF
      THIS.`_interpStmt(`instruction)
      THIS.`_prev_pcounter = NULL
      `force = FALSE
      IF `not(`isnull(THIS.`_error)):
        return [`INTERP_STATE_ERROR, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), THIS.`_error]
      ENDIF
      IF `not(`isnull(THIS.`_procedure)):
        THIS.`_onProcedure(`instance, THIS.`_procedure[0], THIS.`_procedure[1])
        THIS.`_procedure = NULL
        IF `not(`isnull(THIS.`_error)):
          return [`INTERP_STATE_ERROR, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), THIS.`_error]
        ENDIF
        `was_procedure = TRUE
      ENDIF
      THIS.`_count[`key_limits_memory] += (THIS.`_memory_delta_l+THIS.`_memory_delta_n)
      THIS.`_count[`key_limits_memory_n] += THIS.`_memory_delta_n
      THIS.`_count[`key_limits_memory_l] += THIS.`_memory_delta_l
      IF THIS.`_count[`key_limits_max_memory] < THIS.`_count[`key_limits_memory]:
        THIS.`_count[`key_limits_max_memory] = THIS.`_count[`key_limits_memory]
      ENDIF
      IF THIS.`_yield:
        return [`INTERP_STATE_YIELD, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter)]
      ENDIF
      THIS.`_count[`key_limits_instructions] += 1
      IF `was_procedure:
        `was_procedure = FALSE
        `next_pcounter = `instruction[1]
        THIS.`_pcounter = `next_pcounter
      ENDIF
      IF `not(`isnull(THIS.`_status_code)):
        THIS.`_pcounter = NULL
        return [`INTERP_STATE_ENDED, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), THIS.`_status_code]
      ENDIF
      IF `isnull(THIS.`_pcounter):
        `status_code = 0
        return [`INTERP_STATE_ENDED, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter), `status_code]
      ENDIF
      IF (`not(`isnull(THIS.`_limits[`key_limits_instructions])) AND (THIS.`_limits[`key_limits_instructions] <= THIS.`_count[`key_limits_instructions])) OR (`not(`isnull(THIS.`_limits[`key_limits_memory])) AND (THIS.`_limits[`key_limits_memory] <= THIS.`_count[`key_limits_memory])) OR (`not(`isnull(THIS.`_limits[`key_limits_memory_n])) AND (THIS.`_limits[`key_limits_memory_n] <= THIS.`_count[`key_limits_memory_n])) OR (`not(`isnull(THIS.`_limits[`key_limits_memory_l])) AND (THIS.`_limits[`key_limits_memory_l] <= THIS.`_count[`key_limits_memory_l])):
        return [`INTERP_STATE_LIMIT, THIS.`_count, THIS.`_getLnno(THIS.`_pcounter)]
      ENDIF
    ENDWHILE

  METHOD `_interpStmt(`instruction):
    THIS.`_error = NULL
    THIS.`_status_code = NULL
    THIS.`_memory_delta_n = 0
    THIS.`_memory_delta_l = 0
    THIS.`_procedure = NULL
    VAR `opcode = `instruction[0]
    THIS.`_dispatch_stmt[`opcode](`instruction)

  METHOD `_istmtAssignOp(`instruction):
    VAR `that = THIS
    VAR `next_pcounter = `instruction[1]
    VAR `vvar = `instruction[2]
    VAR `exprs = `instruction[3]
    VAR `expr = `instruction[4]
    CLOSURE `getExpr():
      return `utils.`deepCopy(`that.`_interpExpr(`expr))
    ENDCLOSURE
    IF `length(`exprs) == 0:
      THIS.`_istmtAssignToVar(`vvar, `getExpr, `next_pcounter)
    ELSE:
      THIS.`_istmtAssignToListAt(`vvar, `exprs, `getExpr, `next_pcounter)
    ENDIF

  METHOD `_istmtAssignOpCsvar(`instruction):
    VAR `that = THIS
    VAR `next_pcounter = `instruction[1]
    VAR `vvar = `instruction[2]
    VAR `vmod = `instruction[3]
    VAR `exprs = `instruction[4]
    VAR `expr = `instruction[5]
    CLOSURE `getExpr():
      return `utils.`deepCopy(`that.`_interpExpr(`expr))
    ENDCLOSURE
    IF `length(`exprs) == 0:
      THIS.`_istmtAssignToCsvar(`vvar, `vmod, `getExpr, `next_pcounter)
    ELSE:
      THIS.`_istmtAssignToListAtCsvar(`vvar, `vmod, `exprs, `getExpr, `next_pcounter)
    ENDIF

  METHOD `_istmtAssignOpRandom(`instruction):
    VAR `that = THIS
    VAR `next_pcounter = `instruction[1]
    VAR `vvar = `instruction[2]
    VAR `exprs = `instruction[3]
    VAR `expr = `instruction[4]
    VAR `vmod = `instruction[5]
    CLOSURE `getExpr():
      VAR `evalue
      VAR `evaluen
      VAR `r
      IF `isnull(`expr):
        `r = `int32(`that.`_rnd32b[0]())
        return `utils.`encodeData(`r)
      ENDIF
      `evalue = `that.`_interpExpr(`expr)
      IF `isnull(`evalue):
        return NULL
      ENDIF
      IF `evalue[0] != `key_interp_number:
        `that.`_setRuntimeError("EXPECTED"+" "+"NUMBER"+" "+"IN"+" "+"RHS")
        return NULL
      ENDIF
      IF `fp[0].Fract(`evalue[1]) == 0:
        `evaluen = `trunc(`fp[0].ToFloat(`evalue[1]))
        IF `evaluen < 2:
          `r = 0
          return `utils.`encodeData(`r)
        ENDIF
        `r = `that.`_rnd32b[0]() | 0
        `r = (`r & 0x7fff0000) % `evalue[1]
      ELSE:
        IF `evalue[1] < 2:
          `r = 0
          return `utils.`encodeData(`r)
        ENDIF
        `r = `that.`_rnd32b[0]() | 0
        `r = (`r & 0x7fffffff) % `evalue[1]
      ENDIF
      return `utils.`encodeData(`r)
    ENDCLOSURE
    IF `isnull(`vmod):
      IF `length(`exprs) == 0:
        THIS.`_istmtAssignToVar(`vvar, `getExpr, `next_pcounter)
      ELSE:
        THIS.`_istmtAssignToListAt(`vvar, `exprs, `getExpr, `next_pcounter)
      ENDIF
    ELSE:
      IF `length(`exprs) == 0:
        THIS.`_istmtAssignToCsvar(`vvar, `vmod, `getExpr, `next_pcounter)
      ELSE:
        THIS.`_istmtAssignToListAtCsvar(`vvar, `vmod, `exprs, `getExpr, `next_pcounter)
      ENDIF
    ENDIF

  METHOD `_istmtAssignPop(`instruction):
    VAR `that = THIS
    VAR `next_pcounter = `instruction[1]
    VAR `vvar = `instruction[2]
    VAR `exprs = `instruction[3]
    VAR `popvarexprs = `instruction[4]
    VAR `index = `instruction[5]
    VAR `vmod = `instruction[6]
    CLOSURE `getExpr():
      VAR `evalue = `that.`_interpExpr(`popvarexprs)
      IF `isnull(`evalue):
        return NULL
      ENDIF
      IF `evalue[0] != `key_interp_list:
        `that.`_setRuntimeError("EXPECTED"+" "+"LIST")
        return NULL
      ENDIF
      IF `length(`evalue[1]) == 0:
        `that.`_setRuntimeError("POP"+" "+"EMPTY"+" "+"LIST")
        return NULL
      ENDIF
      VAR `popvar = `popvarexprs[1]
      VAR `popvalue
      VAR `lindex
      VAR `lindexn
      IF `isnull(`index):
        `popvalue = `pop(`evalue[1])
      ELSE:
        `lindex = `that.`_interpExpr(`index)
        IF `isnull(`lindex):
          return NULL
        ENDIF
        IF `lindex[0] != `key_interp_number:
          `that.`_setRuntimeError("INVALID"+" "+"INDEX")
          return NULL
        ENDIF
        `lindexn = `fp[0].FloorToInt(`lindex[1])
        IF (`lindexn < 0) OR (`lindexn >= `length(`evalue[1])):
          `that.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE")
          return NULL
        ENDIF
        `popvalue = `pick(`evalue[1], `lindexn)
      ENDIF
      VAR `delta_cost_n = -`utils.`nsizeEvalue(`popvalue)
      VAR `delta_cost_l = -`utils.`lsizeEvalue(`popvalue)
      VAR `popexprs
      VAR `popevalue
      VAR `poplindex
      VAR `poplindexn
      VAR `j
      VAR `csinstance
      VAR `popmod
      IF `popvarexprs[0] == `OPCODE_IVAR:
        `evalue[2] += `delta_cost_l
        `evalue[3] += `delta_cost_n
        `csinstance = `that.`_instance
      ELSIF `popvarexprs[0] == `OPCODE_LIST_AT_IVAR:
        `popexprs = `popvarexprs[2]
        `popevalue = `that.`getVar(`popvar)
        `popevalue[2] += `delta_cost_l
        `popevalue[3] += `delta_cost_n
        FORINCR `j(0 `length(`popexprs)):
          `poplindex = `that.`_interpExpr(`popexprs[`j])
          `poplindexn = `fp[0].FloorToInt(`poplindex[1])
          `popevalue = `popevalue[1][`poplindexn]
          `popevalue[2] += `delta_cost_l
          `popevalue[3] += `delta_cost_n
        ENDFOR
        `csinstance = `that.`_instance
      ELSIF `popvarexprs[0] == `OPCODE_CSVAR:
        `evalue[2] += `delta_cost_l
        `evalue[3] += `delta_cost_n
        `popmod = `popvarexprs[2]
        `csinstance = `that.`_getCsinstance(`popvar, `popmod, `that.`_instance)
      ELSIF `popvarexprs[0] == `OPCODE_LIST_AT_CSVAR:
        `popexprs = `popvarexprs[2]
        `popmod = `popvarexprs[3]
        `csinstance = `that.`_getCsinstance(`popvar, `popmod, `that.`_instance)
        `popevalue = `that.`_getInstanceCsvar(`csinstance, `popvar)
        `popevalue[2] += `delta_cost_l
        `popevalue[3] += `delta_cost_n
        FORINCR `j(0 `length(`popexprs)):
          `poplindex = `that.`_interpExpr(`popexprs[`j])
          `poplindexn = `fp[0].FloorToInt(`poplindex[1])
          `popevalue = `popevalue[1][`poplindexn]
          `popevalue[2] += `delta_cost_l
          `popevalue[3] += `delta_cost_n
        ENDFOR
      ELSE:
        `that.`_setRuntimeError("UNEXPECTED"+" "+"OPCODE")
        return NULL
      ENDIF
      `that.`_updateInstanceCsvarDeltaCost(`that.`_instance, `popvar, `csinstance, `delta_cost_n, `delta_cost_l)
      return `popvalue
    ENDCLOSURE
    IF `isnull(`vvar):
      THIS.`_istmtAssignToDummy(`getExpr, `next_pcounter)
    ELSIF `isnull(`vmod):
      IF `length(`exprs) == 0:
        THIS.`_istmtAssignToVar(`vvar, `getExpr, `next_pcounter)
      ELSE:
        THIS.`_istmtAssignToListAt(`vvar, `exprs, `getExpr, `next_pcounter)
      ENDIF
    ELSE:
      IF `length(`exprs) == 0:
        THIS.`_istmtAssignToCsvar(`vvar, `vmod, `getExpr, `next_pcounter)
      ELSE:
        THIS.`_istmtAssignToListAtCsvar(`vvar, `vmod, `exprs, `getExpr, `next_pcounter)
      ENDIF
    ENDIF

  METHOD `_istmtAssignUnqueue(`instruction):
    VAR `that = THIS
    VAR `next_pcounter = `instruction[1]
    VAR `vvar = `instruction[2]
    VAR `exprs = `instruction[3]
    VAR `unqvarexprs = `instruction[4]
    VAR `vmod = `instruction[5]
    CLOSURE `getExpr():
      VAR `evalue = `that.`_interpExpr(`unqvarexprs)
      IF `isnull(`evalue):
        return NULL
      ENDIF
      IF `evalue[0] != `key_interp_list:
        `that.`_setRuntimeError("EXPECTED"+" "+"LIST")
        return NULL
      ENDIF
      IF `length(`evalue[1]) == 0:
        `that.`_setRuntimeError("UNQUEUE"+" "+"EMPTY"+" "+"LIST")
        return NULL
      ENDIF
      VAR `unqvar = `unqvarexprs[1]
      VAR `unqvalue = `unqueue(`evalue[1])
      VAR `delta_cost_n = -`utils.`nsizeEvalue(`unqvalue)
      VAR `delta_cost_l = -`utils.`lsizeEvalue(`unqvalue)
      VAR `unqexprs
      VAR `unqevalue
      VAR `unqlindex
      VAR `unqlindexn
      VAR `j
      VAR `csinstance
      VAR `unqmod
      IF `unqvarexprs[0] == `OPCODE_IVAR:
        `evalue[2] += `delta_cost_l
        `evalue[3] += `delta_cost_n
        `csinstance = `that.`_instance
      ELSIF `unqvarexprs[0] == `OPCODE_LIST_AT_IVAR:
        `unqexprs = `unqvarexprs[2]
        `unqevalue = `that.`getVar(`unqvar)
        `unqevalue[2] += `delta_cost_l
        `unqevalue[3] += `delta_cost_n
        FORINCR `j(0 `length(`unqexprs)):
          `unqlindex = `that.`_interpExpr(`unqexprs[`j])
          `unqlindexn = `fp[0].FloorToInt(`unqlindex[1])
          `unqevalue = `unqevalue[1][`unqlindexn]
          `unqevalue[2] += `delta_cost_l
          `unqevalue[3] += `delta_cost_n
        ENDFOR
        `csinstance = `that.`_instance
      ELSIF `unqvarexprs[0] == `OPCODE_CSVAR:
        `evalue[2] += `delta_cost_l
        `evalue[3] += `delta_cost_n
        `unqmod = `unqvarexprs[2]
        `csinstance = `that.`_getCsinstance(`unqvar, `unqmod, `that.`_instance)
      ELSIF `unqvarexprs[0] == `OPCODE_LIST_AT_CSVAR:
        `unqexprs = `unqvarexprs[2]
        `unqmod = `unqvarexprs[3]
        `csinstance = `that.`_getCsinstance(`unqvar, `unqmod, `that.`_instance)
        `unqevalue = `that.`_getInstanceCsvar(`csinstance, `unqvar)
        `unqevalue[2] += `delta_cost_l
        `unqevalue[3] += `delta_cost_n
        FORINCR `j(0 `length(`unqexprs)):
          `unqlindex = `that.`_interpExpr(`unqexprs[`j])
          `unqlindexn = `fp[0].FloorToInt(`unqlindex[1])
          `unqevalue = `unqevalue[1][`unqlindexn]
          `unqevalue[2] += `delta_cost_l
          `unqevalue[3] += `delta_cost_n
        ENDFOR
      ELSE:
        `that.`_setRuntimeError("UNEXPECTED"+" "+"OPCODE")
        return NULL
      ENDIF
      `that.`_updateInstanceCsvarDeltaCost(`that.`_instance, `unqvar, `csinstance, `delta_cost_n, `delta_cost_l)
      return `unqvalue
    ENDCLOSURE
    IF `isnull(`vvar):
      THIS.`_istmtAssignToDummy(`getExpr, `next_pcounter)
    ELSIF `isnull(`vmod):
      IF `length(`exprs) == 0:
        THIS.`_istmtAssignToVar(`vvar, `getExpr, `next_pcounter)
      ELSE:
        THIS.`_istmtAssignToListAt(`vvar, `exprs, `getExpr, `next_pcounter)
      ENDIF
    ELSE:
      IF `length(`exprs) == 0:
        THIS.`_istmtAssignToCsvar(`vvar, `vmod, `getExpr, `next_pcounter)
      ELSE:
        THIS.`_istmtAssignToListAtCsvar(`vvar, `vmod, `exprs, `getExpr, `next_pcounter)
      ENDIF
    ENDIF

  METHOD `_istmtAssignToDummy(`getExpr `next_pcounter):
    VAR `evalue = `getExpr()
    IF `isnull(`evalue):
      return
    ENDIF
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtAssignToVar(`vvar `getExpr `next_pcounter):
    IF THIS.`inRepeatVars(`vvar):
      THIS.`_setRuntimeError("REPEAT"+" "+"VARIABLE"+" "+"IN"+" "+"ASSIGNMENT")
      return
    ENDIF
    VAR `evalue = `getExpr()
    IF `isnull(`evalue):
      return
    ENDIF
    VAR `delta_cost_n = `utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = `utils.`lsizeEvalue(`evalue)
    VAR `old_evalue = THIS.`getVar(`vvar)
    IF `not(`isnull(`old_evalue)):
      `delta_cost_n += -`utils.`nsizeEvalue(`old_evalue)
      `delta_cost_l += -`utils.`lsizeEvalue(`old_evalue)
    ENDIF
    THIS.`_addVar(`vvar, `evalue)
    THIS.`_memory_delta_n += `delta_cost_n
    THIS.`_memory_delta_l += `delta_cost_l
    THIS.`_addChangedVar(`vvar)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtAssignToListAt(`vvar `exprs `getExpr `next_pcounter):
    VAR `vvalue = THIS.`getVar(`vvar)
    IF `isnull(`vvalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    IF `vvalue[0] != `key_interp_list:
      THIS.`_setRuntimeError("EXPECTED"+" "+"LIST"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    VAR `vvalues = []
    VAR `lindex = THIS.`_interpExpr(`exprs[0])
    IF `isnull(`lindex):
      return
    ENDIF
    IF `lindex[0] != `key_interp_number:
      THIS.`_setRuntimeError("INVALID"+" "+"INDEX"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    VAR `lindexn = `fp[0].FloorToInt(`lindex[1])
    IF (`lindexn < 0) OR (`lindexn >= `length(`vvalue[1])):
      THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    VAR `j
    FORINCR `j(1 `length(`exprs)):
      `push(`vvalues, `vvalue)
      `vvalue = `vvalue[1][`lindexn]
      IF `vvalue[0] != `key_interp_list:
        THIS.`_setRuntimeError("EXPECTED"+" "+"LIST"+" "+"IN"+" "+"LHS")
        return
      ENDIF
      `lindex = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`lindex):
        return
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX"+" "+"IN"+" "+"LHS")
        return
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn >= `length(`vvalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE"+" "+"IN"+" "+"LHS")
        return
      ENDIF
    ENDFOR
    VAR `evalue = `getExpr()
    IF `isnull(`evalue):
      return
    ENDIF
    VAR `delta_cost_n = -`utils.`nsizeEvalue(`vvalue[1][`lindexn])+`utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = -`utils.`lsizeEvalue(`vvalue[1][`lindexn])+`utils.`lsizeEvalue(`evalue)
    `vvalue[1][`lindexn] = `evalue
    IF (`delta_cost_n != 0) OR (`delta_cost_l != 0):
      `push(`vvalues, `vvalue)
      FORINCR `j(0 `length(`vvalues)):
        `vvalues[`j][2] += `delta_cost_l
        `vvalues[`j][3] += `delta_cost_n
      ENDFOR
      THIS.`_memory_delta_n += `delta_cost_n
      THIS.`_memory_delta_l += `delta_cost_l
    ENDIF
    THIS.`_addChangedVar(`vvar)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtAssignToCsvar(`vvar `vmod `getExpr `next_pcounter):
    VAR `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
    IF `isnull(`csinstance):
      THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
      return
    ENDIF
    IF `csinstance == THIS.`_instance:
      THIS.`_istmtAssignToVar(`vvar, `getExpr, `next_pcounter)
      return
    ENDIF
    IF THIS.`_inInstanceRepeatCsvars(`csinstance, `vvar) AND THIS.`_isCsinstanceStatusCodeNull(`csinstance):
      THIS.`_setRuntimeError("REPEAT"+" "+"VARIABLE"+" "+"IN"+" "+"ASSIGNMENT")
      return
    ENDIF
    VAR `evalue = `getExpr()
    IF `isnull(`evalue):
      return
    ENDIF
    IF THIS.`_existsInstanceCsvar(`csinstance, `vvar):
      THIS.`_removeInstanceCsvar(THIS.`_instance, `vvar, `csinstance)
    ENDIF
    THIS.`_addInstanceCsvar(THIS.`_instance, `vvar, `evalue, `csinstance)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtAssignToListAtCsvar(`vvar `vmod `exprs `getExpr `next_pcounter):
    VAR `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
    IF `isnull(`csinstance):
      THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
      return
    ENDIF
    IF `csinstance == THIS.`_instance:
      THIS.`_istmtAssignToListAt(`vvar, `exprs, `getExpr, `next_pcounter)
      return
    ENDIF
    VAR `vvalue = THIS.`_getInstanceCsvar(`csinstance, `vvar)
    IF `isnull(`vvalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    IF `vvalue[0] != `key_interp_list:
      THIS.`_setRuntimeError("EXPECTED"+" "+"LIST"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    VAR `vvalues = []
    VAR `lindex = THIS.`_interpExpr(`exprs[0])
    IF `isnull(`lindex):
      return
    ENDIF
    IF `lindex[0] != `key_interp_number:
      THIS.`_setRuntimeError("INVALID"+" "+"INDEX"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    VAR `lindexn = `fp[0].FloorToInt(`lindex[1])
    IF (`lindexn < 0) OR (`lindexn >= `length(`vvalue[1])):
      THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE"+" "+"IN"+" "+"LHS")
      return
    ENDIF
    VAR `j
    FORINCR `j(1 `length(`exprs)):
      `push(`vvalues, `vvalue)
      `vvalue = `vvalue[1][`lindexn]
      IF `vvalue[0] != `key_interp_list:
        THIS.`_setRuntimeError("EXPECTED"+" "+"LIST"+" "+"IN"+" "+"LHS")
        return
      ENDIF
      `lindex = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`lindex):
        return
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX"+" "+"IN"+" "+"LHS")
        return
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn >= `length(`vvalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE"+" "+"IN"+" "+"LHS")
        return
      ENDIF
    ENDFOR
    VAR `evalue = `getExpr()
    IF `isnull(`evalue):
      return
    ENDIF
    VAR `delta_cost_n = -`utils.`nsizeEvalue(`vvalue[1][`lindexn])+`utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = -`utils.`lsizeEvalue(`vvalue[1][`lindexn])+`utils.`lsizeEvalue(`evalue)
    `vvalue[1][`lindexn] = `evalue
    IF (`delta_cost_n != 0) OR (`delta_cost_l != 0):
      `push(`vvalues, `vvalue)
      FORINCR `j(0 `length(`vvalues)):
        `vvalues[`j][2] += `delta_cost_l
        `vvalues[`j][3] += `delta_cost_n
      ENDFOR
    ENDIF
    THIS.`_updateInstanceCsvarDeltaCost(THIS.`_instance, `vvar, `csinstance, `delta_cost_n, `delta_cost_l)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtIf(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `alt_pcounter = `instruction[2]
    VAR `expr = `instruction[3]
    VAR `evalue = THIS.`_interpExpr(`expr)
    IF `isnull(`evalue):
      return
    ENDIF
    IF `evalue[1]:
      THIS.`_pcounter = `next_pcounter
    ELSE:
      THIS.`_pcounter = `alt_pcounter
    ENDIF

  METHOD `_istmtElsif(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `alt_pcounter = `instruction[2]
    VAR `expr = `instruction[3]
    VAR `evalue = THIS.`_interpExpr(`expr)
    IF `isnull(`evalue):
      return
    ENDIF
    IF `evalue[1]:
      THIS.`_pcounter = `next_pcounter
    ELSE:
      THIS.`_pcounter = `alt_pcounter
    ENDIF

  METHOD `_istmtElse(`instruction):
    VAR `next_pcounter = `instruction[1]
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtEndif(`instruction):
    VAR `next_pcounter = `instruction[1]
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtRepeat(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `alt_pcounter = `instruction[2]
    VAR `vvar = `instruction[3]
    IF THIS.`inRepeatVars(`vvar):
      THIS.`_setRuntimeError("REPEAT"+" "+"VARIABLE"+" "+"INSIDE"+" "+"REPEAT")
      return
    ENDIF
    VAR `evalue = THIS.`getVar(`vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE")
      return
    ENDIF
    IF `evalue[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return
    ENDIF
    `push(THIS.`_repeat_vars, `vvar)
    VAR `evaluen = `fp[0].FloorToInt(`evalue[1])
    IF `evaluen > 0:
      `evaluen -= 1
      `evalue[1] = `fp[0].FromFloat(`evaluen)
      THIS.`_addChangedVar(`vvar)
      THIS.`_has_repstop = FALSE
      THIS.`_pcounter = `next_pcounter
    ELSE:
      `evalue[1] = `fp[0].FromFloat(`evaluen)
      THIS.`_pcounter = `alt_pcounter
    ENDIF

  METHOD `_istmtRepnext(`instruction):
    VAR `next_pcounter = `instruction[1]
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtRepstop(`instruction):
    VAR `next_pcounter = `instruction[1]
    THIS.`_has_repstop = TRUE
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtEndrep(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `alt_pcounter = `instruction[2]
    VAR `vvar = `pop(THIS.`_repeat_vars)
    VAR `evalue = THIS.`getVar(`vvar)
    IF (`evalue[1] <= 0) OR THIS.`_has_repstop:
      THIS.`_has_repstop = FALSE
      THIS.`_pcounter = `next_pcounter
    ELSE:
      THIS.`_pcounter = `alt_pcounter
    ENDIF

  METHOD `_istmtProcedure(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `procname = `instruction[2]
    VAR `exprs = `instruction[3]
    VAR `procvalue = THIS.`_getEvar(`procname)
    IF `isnull(`procvalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"PROCEDURE")
      return
    ENDIF
    IF `procvalue[0] != `key_interp_procedure:
      THIS.`_setRuntimeError("EXPECTED"+" "+"PROCEDURE")
      return
    ENDIF
    VAR `args = []
    VAR `j
    VAR `evalue
    FORINCR `j(0 `length(`exprs)):
      `evalue = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`evalue):
        return
      ENDIF
      `push(`args, `utils.`decodeData(`evalue))
    ENDFOR
    THIS.`_procedure = [`procname, `args]

  METHOD `_istmtPush(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `pvarexprs = `instruction[2]
    VAR `expr = `instruction[3]
    VAR `index = `instruction[4]
    VAR `pvar = `pvarexprs[1]
    VAR `pvalue = THIS.`_interpExpr(`pvarexprs)
    IF `isnull(`pvalue):
      return
    ENDIF
    IF `pvalue[0] != `key_interp_list:
      THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
      return
    ENDIF
    VAR `evalue = `utils.`deepCopy(THIS.`_interpExpr(`expr))
    IF `isnull(`evalue):
      return
    ENDIF
    VAR `delta_cost_n = `utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = `utils.`lsizeEvalue(`evalue)
    VAR `lindex
    VAR `lindexn
    IF `isnull(`index):
      `push(`pvalue[1], `evalue)
    ELSE:
      `lindex = THIS.`_interpExpr(`index)
      IF `isnull(`lindex):
        return
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX")
        return
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn > `length(`pvalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE")
        return
      ENDIF
      IF `lindexn < `length(`pvalue[1]):
        `poke(`pvalue[1], `lindexn, `evalue)
      ELSE:
        `push(`pvalue[1], `evalue)
      ENDIF
    ENDIF
    VAR `pexprs
    VAR `pevalue
    VAR `plindex
    VAR `plindexn
    VAR `j
    VAR `csinstance
    VAR `pmod
    IF `pvarexprs[0] == `OPCODE_IVAR:
      `pvalue[2] += `delta_cost_l
      `pvalue[3] += `delta_cost_n
      `csinstance = THIS.`_instance
    ELSIF `pvarexprs[0] == `OPCODE_LIST_AT_IVAR:
      `pexprs = `pvarexprs[2]
      `pevalue = THIS.`getVar(`pvar)
      `pevalue[2] += `delta_cost_l
      `pevalue[3] += `delta_cost_n
      FORINCR `j(0 `length(`pexprs)):
        `plindex = THIS.`_interpExpr(`pexprs[`j])
        `plindexn = `fp[0].FloorToInt(`plindex[1])
        `pevalue = `pevalue[1][`plindexn]
        `pevalue[2] += `delta_cost_l
        `pevalue[3] += `delta_cost_n
      ENDFOR
      `csinstance = THIS.`_instance
    ELSIF `pvarexprs[0] == `OPCODE_CSVAR:
      `pvalue[2] += `delta_cost_l
      `pvalue[3] += `delta_cost_n
      `pmod = `pvarexprs[2]
      `csinstance = THIS.`_getCsinstance(`pvar, `pmod, THIS.`_instance)
    ELSIF `pvarexprs[0] == `OPCODE_LIST_AT_CSVAR:
      `pexprs = `pvarexprs[2]
      `pmod = `pvarexprs[3]
      `csinstance = THIS.`_getCsinstance(`pvar, `pmod, THIS.`_instance)
      `pevalue = THIS.`_getInstanceCsvar(`csinstance, `pvar)
      `pevalue[2] += `delta_cost_l
      `pevalue[3] += `delta_cost_n
      FORINCR `j(0 `length(`pexprs)):
        `plindex = THIS.`_interpExpr(`pexprs[`j])
        `plindexn = `fp[0].FloorToInt(`plindex[1])
        `pevalue = `pevalue[1][`plindexn]
        `pevalue[2] += `delta_cost_l
        `pevalue[3] += `delta_cost_n
      ENDFOR
    ELSE:
      THIS.`_setRuntimeError("UNEXPECTED"+" "+"OPCODE")
      return
    ENDIF
    THIS.`_updateInstanceCsvarDeltaCost(THIS.`_instance, `pvar, `csinstance, `delta_cost_n, `delta_cost_l)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtQueue(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `qvarexprs = `instruction[2]
    VAR `expr = `instruction[3]
    VAR `qvar = `qvarexprs[1]
    VAR `qvalue = THIS.`_interpExpr(`qvarexprs)
    IF `isnull(`qvalue):
      return
    ENDIF
    IF `qvalue[0] != `key_interp_list:
      THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
      return
    ENDIF
    VAR `evalue = `utils.`deepCopy(THIS.`_interpExpr(`expr))
    IF `isnull(`evalue):
      return
    ENDIF
    VAR `delta_cost_n = `utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = `utils.`lsizeEvalue(`evalue)
    `queue(`qvalue[1], `evalue)
    VAR `qexprs
    VAR `qevalue
    VAR `qlindex
    VAR `qlindexn
    VAR `j
    VAR `csinstance
    VAR `qmod
    IF `qvarexprs[0] == `OPCODE_IVAR:
      `qvalue[2] += `delta_cost_l
      `qvalue[3] += `delta_cost_n
      `csinstance = THIS.`_instance
    ELSIF `qvarexprs[0] == `OPCODE_LIST_AT_IVAR:
      `qexprs = `qvarexprs[2]
      `qevalue = THIS.`getVar(`qvar)
      `qevalue[2] += `delta_cost_l
      `qevalue[3] += `delta_cost_n
      FORINCR `j(0 `length(`qexprs)):
        `qlindex = THIS.`_interpExpr(`qexprs[`j])
        `qlindexn = `fp[0].FloorToInt(`qlindex[1])
        `qevalue = `qevalue[1][`qlindexn]
        `qevalue[2] += `delta_cost_l
        `qevalue[3] += `delta_cost_n
      ENDFOR
      `csinstance = THIS.`_instance
    ELSIF `qvarexprs[0] == `OPCODE_CSVAR:
      `qvalue[2] += `delta_cost_l
      `qvalue[3] += `delta_cost_n
      `qmod = `qvarexprs[2]
      `csinstance = THIS.`_getCsinstance(`qvar, `qmod, THIS.`_instance)
    ELSIF `qvarexprs[0] == `OPCODE_LIST_AT_CSVAR:
      `qexprs = `qvarexprs[2]
      `qmod = `qvarexprs[3]
      `csinstance = THIS.`_getCsinstance(`qvar, `qmod, THIS.`_instance)
      `qevalue = THIS.`_getInstanceCsvar(`csinstance, `qvar)
      `qevalue[2] += `delta_cost_l
      `qevalue[3] += `delta_cost_n
      FORINCR `j(0 `length(`qexprs)):
        `qlindex = THIS.`_interpExpr(`qexprs[`j])
        `qlindexn = `fp[0].FloorToInt(`qlindex[1])
        `qevalue = `qevalue[1][`qlindexn]
        `qevalue[2] += `delta_cost_l
        `qevalue[3] += `delta_cost_n
      ENDFOR
    ELSE:
      THIS.`_setRuntimeError("UNEXPECTED"+" "+"OPCODE")
      return
    ENDIF
    THIS.`_updateInstanceCsvarDeltaCost(THIS.`_instance, `qvar, `csinstance, `delta_cost_n, `delta_cost_l)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtUnassign(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `vvar = `instruction[2]
    IF THIS.`inRepeatVars(`vvar):
      THIS.`_setRuntimeError("REPEAT"+" "+"VARIABLE"+" "+"IN"+" "+"UNASSIGN")
      return
    ENDIF
    VAR `evalue = THIS.`getVar(`vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE")
      return
    ENDIF
    VAR `delta_cost_n = -`utils.`nsizeEvalue(`evalue)
    VAR `delta_cost_l = -`utils.`lsizeEvalue(`evalue)
    THIS.`_removeVar(`vvar)
    THIS.`_memory_delta_n += `delta_cost_n
    THIS.`_memory_delta_l += `delta_cost_l
    THIS.`_addChangedVar(`vvar)
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtUnassignCsvar(`instruction):
    VAR `vvar = `instruction[2]
    VAR `vmod = `instruction[3]
    VAR `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
    IF `isnull(`csinstance):
      THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
      return
    ENDIF
    IF `csinstance == THIS.`_instance:
      THIS.`_istmtUnassign(`instruction)
      return
    ENDIF
    IF `not(THIS.`_existsInstanceCsvar(`csinstance, `vvar)):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"CALLSTACK"+" "+"VARIABLE")
      return
    ENDIF
    IF THIS.`_inInstanceRepeatCsvars(`csinstance, `vvar) AND THIS.`_isCsinstanceStatusCodeNull(`csinstance):
      THIS.`_setRuntimeError("REPEAT"+" "+"VARIABLE"+" "+"IN"+" "+"UNASSIGN")
      return
    ENDIF
    THIS.`_removeInstanceCsvar(THIS.`_instance, `vvar, `csinstance)
    VAR `next_pcounter = `instruction[1]
    THIS.`_pcounter = `next_pcounter

  METHOD `_istmtDebugl(`instruction):
    VAR `next_pcounter = `instruction[1]
    VAR `debuglexprs = `instruction[2]
    VAR `debugl_message = ""
    VAR `j
    VAR `debuglexpr_j
    VAR `evalue_j
    FORINCR `j(0 `length(`debuglexprs)):
      `debuglexpr_j = `debuglexprs[`j]
      IF `debuglexpr_j[0] == `OPCODE_STRING:
        `debugl_message += `debuglexpr_j[1]
        continue
      ENDIF
      `evalue_j = THIS.`_interpExpr(`debuglexpr_j)
      `debugl_message += `utils.`stringify(`evalue_j)
    ENDFOR
    THIS.`_error = NULL
    VAR `debugl_lines = `split(`debugl_message, `chr_lf)
    VAR `debugl_line
    FORINCR `j(0 `length(`debugl_lines)):
      IF `not(`isnull(THIS.`_max_debugl_lines)) AND (`length(THIS.`_debugl_lines) >= THIS.`_max_debugl_lines):
        `unqueue(THIS.`_debugl_lines)
      ENDIF
      `debugl_line = `debugl_lines[`j]
      IF `not(`isnull(THIS.`_max_debugl_chars_per_line)) AND (`length(`debugl_line) > THIS.`_max_debugl_chars_per_line):
        `debugl_line = `substring(`debugl_line, 0, THIS.`_max_debugl_chars_per_line-3)+"..."
      ENDIF
      `push(THIS.`_debugl_lines, `debugl_line)
    ENDFOR
    THIS.`_pcounter = `next_pcounter

  METHOD `_interpExpr(`expression):
    VAR `opcode = `expression[0]
    return THIS.`_dispatch_expr[`opcode](`expression)

  METHOD `_iexprNumber(`expression):
    VAR `n = `expression[1]
    THIS.`_tmpNumber[1] = `n
    return THIS.`_tmpNumber

  METHOD `_iexprList(`expression):
    VAR `exprs = `expression[1]
    VAR `nsize = 0
    VAR `lsize = 1
    VAR `lvalue = []
    VAR `j
    VAR `evalue
    FORINCR `j(0 `length(`exprs)):
      `evalue = `utils.`deepCopy(THIS.`_interpExpr(`exprs[`j]))
      IF `isnull(`evalue):
        return NULL
      ENDIF
      `push(`lvalue, `evalue)
      `nsize += `utils.`nsizeEvalue(`evalue)
      `lsize += `utils.`lsizeEvalue(`evalue)
    ENDFOR
    return [`key_interp_list, `lvalue, `lsize, `nsize]

  METHOD `_iexprOr(`expression):
    VAR `exprs = `expression[1]
    VAR `j
    VAR `evalue
    FORINCR `j(0 `length(`exprs)):
      `evalue = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`evalue):
        return NULL
      ENDIF
      IF `evalue[1]:
        THIS.`_tmpNumber[1] = `fp[0].FromFloat(1)
        return THIS.`_tmpNumber
      ENDIF
    ENDFOR
    THIS.`_tmpNumber[1] = 0
    return THIS.`_tmpNumber

  METHOD `_iexprAnd(`expression):
    VAR `exprs = `expression[1]
    VAR `j
    VAR `evalue
    FORINCR `j(0 `length(`exprs)):
      `evalue = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`evalue):
        return NULL
      ENDIF
      IF `not(`evalue[1]):
        THIS.`_tmpNumber[1] = 0
        return THIS.`_tmpNumber
      ENDIF
    ENDFOR
    THIS.`_tmpNumber[1] = `fp[0].FromFloat(1)
    return THIS.`_tmpNumber

  METHOD `_iexprNot(`expression):
    VAR `expr = `expression[1]
    VAR `evalue = THIS.`_interpExpr(`expr)
    IF `isnull(`evalue):
      return NULL
    ENDIF
    THIS.`_tmpNumber[1] = TERNARY{`not(`evalue[1])}{`fp[0].FromFloat(1)}{0}
    return THIS.`_tmpNumber

  METHOD `_iexprRelOp(`expression `binOp):
    VAR `expr1 = `expression[1]
    VAR `expr2 = `expression[2]
    VAR `evalue1 = THIS.`_interpExpr(`expr1)
    IF `isnull(`evalue1):
      return NULL
    ENDIF
    VAR `isNumberExpr1 = (`evalue1[0] == `key_interp_number)
    VAR `evalue1n = `evalue1[1]
    VAR `evalue2 = THIS.`_interpExpr(`expr2)
    IF `isnull(`evalue2):
      return NULL
    ENDIF
    VAR `value
    IF `isNumberExpr1:
      IF `evalue2[0] == `key_interp_number:
        `value = `binOp(`evalue1n, `evalue2[1])
      ELSE:
        `value = `binOp(0, 1)
      ENDIF
    ELSE:
      `value = THIS.`_iexprRelOp_cmp(`evalue1, `evalue2)
      IF `value == 0:
        `value = `binOp(0, 0)
      ELSIF `value < 0:
        `value = `binOp(0, 1)
      ELSE:
        `value = `binOp(1, 0)
      ENDIF
    ENDIF
    THIS.`_tmpNumber[1] = TERNARY{`value}{`fp[0].FromFloat(1)}{0}
    return THIS.`_tmpNumber

  METHOD `_iexprRelOp_cmp(`evalue1 `evalue2):
    IF `evalue1[0] == `key_interp_number:
      IF `evalue2[0] == `key_interp_number:
        IF `evalue1[1] == `evalue2[1]:
          return 0
        ELSIF `evalue1[1] < `evalue2[1]:
          return -1
        ELSE:
          return 1
        ENDIF
      ENDIF
      return -1
    ENDIF
    IF `evalue2[0] == `key_interp_number:
      return 1
    ENDIF
    VAR `j
    VAR `value
    VAR `len1 = `length(`evalue1[1])
    VAR `len2 = `length(`evalue2[1])
    IF `len1 <= `len2:
      FORINCR `j(0 `len1):
        `value = THIS.`_iexprRelOp_cmp(`evalue1[1][`j], `evalue2[1][`j])
        IF `value != 0:
          return `value
        ENDIF
      ENDFOR
      IF `len1 < `len2:
        return -1
      ENDIF
      return 0
    ENDIF
    FORINCR `j(0 `len2):
      `value = THIS.`_iexprRelOp_cmp(`evalue1[1][`j], `evalue2[1][`j])
      IF `value != 0:
        return `value
      ENDIF
    ENDFOR
    return 1

  METHOD `_iexprUnaryOp(`expression `unaryOp):
    VAR `expr = `expression[1]
    VAR `evalue = THIS.`_interpExpr(`expr)
    IF `isnull(`evalue):
      return NULL
    ENDIF
    IF `evalue[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return NULL
    ENDIF
    VAR `value = `unaryOp(`evalue[1])
    THIS.`_tmpNumber[1] = `value
    return THIS.`_tmpNumber

  METHOD `_iexprAddOp(`expression `binOp):
    VAR `expr1 = `expression[1]
    VAR `expr2 = `expression[2]
    VAR `evalue1 = THIS.`_interpExpr(`expr1)
    IF `isnull(`evalue1):
      return NULL
    ENDIF
    IF `evalue1[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return NULL
    ENDIF
    VAR `evalue1n = `evalue1[1]
    VAR `evalue2 = THIS.`_interpExpr(`expr2)
    IF `isnull(`evalue2):
      return NULL
    ENDIF
    IF `evalue2[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return NULL
    ENDIF
    VAR `value = `binOp(`evalue1n, `evalue2[1])
    THIS.`_tmpNumber[1] = `value
    return THIS.`_tmpNumber

  METHOD `_iexprMulOp(`expression `binOp):
    VAR `expr1 = `expression[1]
    VAR `expr2 = `expression[2]
    VAR `evalue1 = THIS.`_interpExpr(`expr1)
    IF `isnull(`evalue1):
      return NULL
    ENDIF
    IF `evalue1[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return NULL
    ENDIF
    VAR `evalue1n = `evalue1[1]
    VAR `evalue2 = THIS.`_interpExpr(`expr2)
    IF `isnull(`evalue2):
      return NULL
    ENDIF
    IF `evalue2[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return NULL
    ENDIF
    VAR `value = `binOp(`evalue1n, `evalue2[1])
    THIS.`_tmpNumber[1] = `value
    return THIS.`_tmpNumber

  METHOD `_iexprByRef(`expression):
    VAR `vvar = `expression[1][0]
    VAR `vmod = `expression[1][1]
    VAR `values = [`vvar, `vmod]
    VAR `lindex
    VAR `lindexn
    VAR `j
    FORINCR `j(2 `length(`expression[1])):
      `lindex = THIS.`_interpExpr(`expression[1][`j])
      IF `isnull(`lindex):
        return NULL
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX")
        return NULL
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      `push(`values, `lindexn)
    ENDFOR
    THIS.`_tmpByRef[1] = `values
    return THIS.`_tmpByRef

  METHOD `_iexprModuleName(`expression):
    VAR `module_name = `expression[1]
    THIS.`_tmpModuleName[1] = `module_name
    return THIS.`_tmpModuleName

  METHOD `_iexprString(`expression):
    VAR `str_ = `expression[1]
    THIS.`_tmpString[1] = `str_
    return THIS.`_tmpString

  METHOD `_iexprIvar(`expression):
    VAR `vvar = `expression[1]
    VAR `evalue = THIS.`getVar(`vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE")
      return NULL
    ENDIF
    IF (`evalue[0] != `key_interp_number) AND (`evalue[0] != `key_interp_list):
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER"+" "+"OR"+" "+"LIST")
      return NULL
    ENDIF
    return `evalue

  METHOD `_iexprEvar(`expression):
    VAR `vvar = `expression[1]
    VAR `evalue = THIS.`_getEvar(`vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE")
      return NULL
    ENDIF
    IF (`evalue[0] != `key_interp_number) AND (`evalue[0] != `key_interp_list):
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER"+" "+"OR"+" "+"LIST")
      return NULL
    ENDIF
    return `evalue

  METHOD `_iexprCsvar(`expression):
    VAR `vvar = `expression[1]
    VAR `vmod = `expression[2]
    VAR `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
    IF `isnull(`csinstance):
      THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
      return NULL
    ENDIF
    IF `csinstance == THIS.`_instance:
      return THIS.`_iexprIvar(`expression)
    ENDIF
    VAR `evalue = THIS.`_getInstanceCsvar(`csinstance, `vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"CALLSTACK"+" "+"VARIABLE")
      return NULL
    ENDIF
    IF (`evalue[0] != `key_interp_number) AND (`evalue[0] != `key_interp_list):
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER"+" "+"OR"+" "+"LIST")
      return NULL
    ENDIF
    return `evalue

  METHOD `_iexprIs(`expression):
    VAR `vvarexprs = `expression[1]
    VAR `vvar_typetokenid = `expression[2]
    VAR `vvar = `vvarexprs[1]
    VAR `vmod
    VAR `csinstance
    VAR `evalue
    IF `vvarexprs[0] == `OPCODE_IVAR:
      `evalue = THIS.`getVar(`vvar)
    ELSIF `vvarexprs[0] == `OPCODE_EVAR:
      `evalue = THIS.`_getEvar(`vvar)
    ELSIF `vvarexprs[0] == `OPCODE_CSVAR:
      `vmod = `vvarexprs[2]
      `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
      IF `isnull(`csinstance):
        THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
        return NULL
      ENDIF
      `evalue = THIS.`_getInstanceCsvar(`csinstance, `vvar)
    ELSE:
      `evalue = THIS.`_interpExpr(`vvarexprs)
      IF `isnull(`evalue):
        return NULL
      ENDIF
    ENDIF
    IF `isnull(`evalue):
      THIS.`_tmpNumber[1] = TERNARY{(`vvar_typetokenid == `key_token_UNDEFINED)}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    IF `evalue[0] == `key_interp_number:
      THIS.`_tmpNumber[1] = TERNARY{(`vvar_typetokenid == `key_token_NUMBER)}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    IF `evalue[0] == `key_interp_list:
      THIS.`_tmpNumber[1] = TERNARY{((`vvar_typetokenid == `key_token_LIST) OR ((`vvar_typetokenid == `key_token_EMPTY) AND (`length(`evalue[1]) == 0)))}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    IF `evalue[0] == `key_interp_procedure:
      THIS.`_tmpNumber[1] = TERNARY{(`vvar_typetokenid == `key_token_PROCEDURE)}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    THIS.`_tmpNumber[1] = 0
    return THIS.`_tmpNumber

  METHOD `_iexprIsNot(`expression):
    VAR `vvarexprs = `expression[1]
    VAR `vvar_typetokenid = `expression[2]
    VAR `vvar = `vvarexprs[1]
    VAR `vmod
    VAR `csinstance
    VAR `evalue
    IF `vvarexprs[0] == `OPCODE_IVAR:
      `evalue = THIS.`getVar(`vvar)
    ELSIF `vvarexprs[0] == `OPCODE_EVAR:
      `evalue = THIS.`_getEvar(`vvar)
    ELSIF `vvarexprs[0] == `OPCODE_CSVAR:
      `vmod = `vvarexprs[2]
      `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
      IF `isnull(`csinstance):
        THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
        return NULL
      ENDIF
      `evalue = THIS.`_getInstanceCsvar(`csinstance, `vvar)
    ELSE:
      `evalue = THIS.`_interpExpr(`vvarexprs)
      IF `isnull(`evalue):
        return NULL
      ENDIF
    ENDIF
    IF `isnull(`evalue):
      THIS.`_tmpNumber[1] = TERNARY{(`vvar_typetokenid != `key_token_UNDEFINED)}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    IF `evalue[0] == `key_interp_number:
      THIS.`_tmpNumber[1] = TERNARY{(`vvar_typetokenid != `key_token_NUMBER)}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    IF `evalue[0] == `key_interp_list:
      THIS.`_tmpNumber[1] = TERNARY{((`vvar_typetokenid != `key_token_LIST) AND ((`vvar_typetokenid != `key_token_EMPTY) OR (`length(`evalue[1]) > 0)))}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    IF `evalue[0] == `key_interp_procedure:
      THIS.`_tmpNumber[1] = TERNARY{(`vvar_typetokenid != `key_token_PROCEDURE)}{`fp[0].FromFloat(1)}{0}
      return THIS.`_tmpNumber
    ENDIF
    THIS.`_tmpNumber[1] = `fp[0].FromFloat(1)
    return THIS.`_tmpNumber

  METHOD `_iexprLengthVar(`expression):
    VAR `vvarexprs = `expression[1]
    VAR `evalue = THIS.`_interpExpr(`vvarexprs)
    IF `isnull(`evalue):
      return NULL
    ENDIF
    IF `evalue[0] != `key_interp_list:
      THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
      return NULL
    ENDIF
    VAR `lenn = `length(`evalue[1])
    IF `lenn > 0x7fff:
      THIS.`_setRuntimeError("VALUE"+" "+"EXCEEDS"+" "+"NUMERIC"+" "+"TYPE")
      return NULL
    ENDIF
    THIS.`_tmpNumber[1] = `fp[0].FromFloat(`lenn)
    return THIS.`_tmpNumber

  METHOD `_iexprSizeVar(`expression `projection):
    VAR `vvarexprs = `expression[1]
    VAR `evalue = THIS.`_interpExpr(`vvarexprs)
    IF `isnull(`evalue):
      return NULL
    ENDIF
    IF (`evalue[0] != `key_interp_number) AND (`evalue[0] != `key_interp_list):
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER"+" "+"OR"+" "+"LIST")
      return NULL
    ENDIF
    VAR `value = `projection(`utils.`lsizeEvalue(`evalue), `utils.`nsizeEvalue(`evalue))
    IF `value > 0x7fff:
      THIS.`_setRuntimeError("VALUE"+" "+"EXCEEDS"+" "+"NUMERIC"+" "+"TYPE")
      return NULL
    ENDIF
    THIS.`_tmpNumber[1] = `fp[0].FromFloat(`value)
    return THIS.`_tmpNumber

  METHOD `_iexprIndexofVar(`expression):
    VAR `vvarexprs = `expression[1]
    VAR `expr = `expression[2]
    VAR `ariexpr = `expression[3]
    VAR `evalue = THIS.`_interpExpr(`vvarexprs)
    IF `isnull(`evalue):
      return NULL
    ENDIF
    IF `evalue[0] != `key_interp_list:
      THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
      return NULL
    ENDIF
    VAR `varvalue = `utils.`decodeData(`evalue)
    VAR `from = THIS.`_interpExpr(`ariexpr)
    IF `isnull(`from):
      return NULL
    ENDIF
    IF `from[0] != `key_interp_number:
      THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
      return NULL
    ENDIF
    VAR `fromn = `fp[0].FloorToInt(`from[1])
    VAR `indexof_ = THIS.`_interpExpr(`expr)
    IF `isnull(`indexof_):
      return NULL
    ENDIF
    IF (`indexof_[0] != `key_interp_number) AND (`indexof_[0] != `key_interp_list):
      THIS.`_setRuntimeError("INVALID"+" "+"INDEXOF"+" "+"EXPRESSION")
      return NULL
    ENDIF
    VAR `indexofvalue = `utils.`decodeData(`indexof_)
    VAR `result
    IF `isnull(`varvalue) OR `isnull(`indexofvalue):
      `result = -1
    ELSE:
      `result = `utils.`structuralIndexOf(`varvalue[1], `indexofvalue[1], `fromn)
    ENDIF
    IF `result > 0x7fff:
      THIS.`_setRuntimeError("VALUE"+" "+"EXCEEDS"+" "+"NUMERIC"+" "+"TYPE")
      return NULL
    ENDIF
    THIS.`_tmpNumber[1] = `fp[0].FromFloat(`result)
    return THIS.`_tmpNumber

  METHOD `_iexprListAtList(`expression):
    VAR `exprs = `expression[1]
    VAR `nsize = 0
    VAR `lsize = 1
    VAR `lvalue = []
    VAR `j
    VAR `evalue
    FORINCR `j(0 `length(`exprs)):
      `evalue = `utils.`deepCopy(THIS.`_interpExpr(`exprs[`j]))
      IF `isnull(`evalue):
        return NULL
      ENDIF
      `push(`lvalue, `evalue)
      `nsize += `utils.`nsizeEvalue(`evalue)
      `lsize += `utils.`lsizeEvalue(`evalue)
    ENDFOR
    `evalue = [`key_interp_list, `lvalue, `lsize, `nsize]
    VAR `idxexprs = `expression[2]
    VAR `lindex
    VAR `lindexn
    FORINCR `j(0 `length(`idxexprs)):
      IF `evalue[0] != `key_interp_list:
        THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
        return NULL
      ENDIF
      `lindex = THIS.`_interpExpr(`idxexprs[`j])
      IF `isnull(`lindex):
        return NULL
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX")
        return NULL
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn >= `length(`evalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE")
        return NULL
      ENDIF
      `evalue = `evalue[1][`lindexn]
    ENDFOR
    return `evalue

  METHOD `_iexprListAtIvar(`expression):
    VAR `vvar = `expression[1]
    VAR `exprs = `expression[2]
    VAR `evalue = THIS.`getVar(`vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE")
      return NULL
    ENDIF
    VAR `lindex
    VAR `lindexn
    VAR `j
    FORINCR `j(0 `length(`exprs)):
      IF `evalue[0] != `key_interp_list:
        THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
        return NULL
      ENDIF
      `lindex = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`lindex):
        return NULL
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX")
        return NULL
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn >= `length(`evalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE")
        return NULL
      ENDIF
      `evalue = `evalue[1][`lindexn]
    ENDFOR
    return `evalue

  METHOD `_iexprListAtEvar(`expression):
    VAR `vvar = `expression[1]
    VAR `exprs = `expression[2]
    VAR `evalue = THIS.`_getEvar(`vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"VARIABLE")
      return NULL
    ENDIF
    VAR `lindex
    VAR `lindexn
    VAR `j
    FORINCR `j(0 `length(`exprs)):
      IF `evalue[0] != `key_interp_list:
        THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
        return NULL
      ENDIF
      `lindex = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`lindex):
        return NULL
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX")
        return NULL
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn >= `length(`evalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE")
        return NULL
      ENDIF
      `evalue = `evalue[1][`lindexn]
    ENDFOR
    return `evalue

  METHOD `_iexprListAtCsvar(`expression):
    VAR `vvar = `expression[1]
    VAR `vmod = `expression[3]
    VAR `csinstance = THIS.`_getCsinstance(`vvar, `vmod, THIS.`_instance)
    IF `isnull(`csinstance):
      THIS.`_setRuntimeError("INVALID"+" "+"CALLSTACK"+" "+"VARIABLE")
      return NULL
    ENDIF
    IF `csinstance == THIS.`_instance:
      return THIS.`_iexprListAtIvar(`expression)
    ENDIF
    VAR `evalue = THIS.`_getInstanceCsvar(`csinstance, `vvar)
    IF `isnull(`evalue):
      THIS.`_setRuntimeError("UNDEFINED"+" "+"CALLSTACK"+" "+"VARIABLE")
      return NULL
    ENDIF
    VAR `exprs = `expression[2]
    VAR `lindex
    VAR `lindexn
    VAR `j
    FORINCR `j(0 `length(`exprs)):
      IF `evalue[0] != `key_interp_list:
        THIS.`_setRuntimeError("EXPECTED"+" "+"LIST")
        return NULL
      ENDIF
      `lindex = THIS.`_interpExpr(`exprs[`j])
      IF `isnull(`lindex):
        return NULL
      ENDIF
      IF `lindex[0] != `key_interp_number:
        THIS.`_setRuntimeError("INVALID"+" "+"INDEX")
        return NULL
      ENDIF
      `lindexn = `fp[0].FloorToInt(`lindex[1])
      IF (`lindexn < 0) OR (`lindexn >= `length(`evalue[1])):
        THIS.`_setRuntimeError("INDEX"+" "+"OUT-OF-RANGE")
        return NULL
      ENDIF
      `evalue = `evalue[1][`lindexn]
    ENDFOR
    return `evalue

  METHOD `_iexprMathOp(`expression `mathOp):
    VAR `expr1
    VAR `evalue1
    VAR `evalue1n
    VAR `value
    IF `length(`expression[1]) == 1:
      `expr1 = `expression[1][0]
      `evalue1 = THIS.`_interpExpr(`expr1)
      IF `isnull(`evalue1):
        return NULL
      ENDIF
      IF `evalue1[0] != `key_interp_number:
        THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
        return NULL
      ENDIF
      `evalue1n = `evalue1[1]
      `value = `mathOp(`evalue1n)
      THIS.`_tmpNumber[1] = `value
      return THIS.`_tmpNumber
    ENDIF
    VAR `expr2
    VAR `evalue2
    IF `length(`expression[1]) == 2:
      `expr1 = `expression[1][0]
      `evalue1 = THIS.`_interpExpr(`expr1)
      IF `isnull(`evalue1):
        return NULL
      ENDIF
      IF `evalue1[0] != `key_interp_number:
        THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
        return NULL
      ENDIF
      `evalue1n = `evalue1[1]
      `expr2 = `expression[1][1]
      `evalue2 = THIS.`_interpExpr(`expr2)
      IF `isnull(`evalue2):
        return NULL
      ENDIF
      IF `evalue2[0] != `key_interp_number:
        THIS.`_setRuntimeError("EXPECTED"+" "+"NUMBER")
        return NULL
      ENDIF
      `value = `mathOp(`evalue1n, `evalue2[1])
      THIS.`_tmpNumber[1] = `value
      return THIS.`_tmpNumber
    ENDIF
    THIS.`_setRuntimeError("NOT"+" "+"IMPLEMENTED")
    return NULL

  METHOD `destroy():
    VAR `x = NULL

ENDCLASS

VAR `key_modules_module_name = 0
VAR `key_modules_module_name_lcase = 1
VAR `key_modules_editor_m = 2
VAR `key_modules_instances = 3

VAR `key_envs_environment = 0
VAR `key_envs_varnames = 1
VAR `key_envs_procnames = 2
VAR `key_envs_instances = 3

VAR `key_instances_interp_m = 0
VAR `key_instances_module = 1
VAR `key_instances_envs = 2
VAR `key_instances_state = 3

CLASS `PrequelM:

  METHOD_INIT(`args):
    VAR `x = NULL

  METHOD `init(`onProcedure `onYieldResume `rnd32b):
    THIS.`_ihandle = NEW `ResourceIds()
    THIS.`_modules = {}
    THIS.`_module_list = []
    THIS.`_instances = {}
    THIS.`_instance_list = []
    THIS.`_envs = {}
    THIS.`_env_list = []
    THIS.`_running_instance = NULL
    THIS.`_ready_instances = []
    THIS.`_limit_instances = []
    THIS.`_pause_instances = []
    THIS.`_yield_instances = []
    THIS.`_error_instances = []
    THIS.`_ended_instances = []
    THIS.`_onProcedure = `onProcedure
    THIS.`_onYieldResume = `onYieldResume
    THIS.`_rnd32b = `rnd32b
    VAR `that = THIS
    CLOSURE `closure_getEvar(`evar):
      IF `isnull(`that.`_running_instance):
        return NULL
      ENDIF
      VAR `instance = `that.`_running_instance
      VAR `envs = `that.`_instances[`instance][`key_instances_envs]
      VAR `j
      VAR `env
      VAR `evalue
      FORDECR `j(`length(`envs)-1 0):
        `env = `envs[`j]
        `evalue = `that.`_envs[`env][`key_envs_environment].`get(`evar)
        IF `not(`isnull(`evalue)):
          return `evalue
        ENDIF
      ENDFOR
      return NULL
    ENDCLOSURE
    THIS.`_getEvar = `closure_getEvar
    CLOSURE `closure_existsInstanceCsvar(`csinstance `vvar):
      VAR `ivarnames = `that.`getInstanceVarNames(`csinstance)
      return (`indexof(`ivarnames, `vvar) >= 0)
    ENDCLOSURE
    THIS.`_existsInstanceCsvar = `closure_existsInstanceCsvar
    CLOSURE `closure_getInstanceCsvar(`csinstance `vvar):
      VAR `evalue = `that.`getInstanceVar(`csinstance, `vvar)
      return `evalue
    ENDCLOSURE
    THIS.`_getInstanceCsvar = `closure_getInstanceCsvar
    CLOSURE `closure_addInstanceCsvar(`instance `vvar `evalue `csinstance):
      return `that.`addInstanceCsvar(`instance, `vvar, `evalue, `csinstance)
    ENDCLOSURE
    THIS.`_addInstanceCsvar = `closure_addInstanceCsvar
    CLOSURE `closure_removeInstanceCsvar(`instance `vvar `csinstance):
      `that.`removeInstanceCsvar(`instance, `vvar, `csinstance)
    ENDCLOSURE
    THIS.`_removeInstanceCsvar = `closure_removeInstanceCsvar
    CLOSURE `closure_updateInstanceCsvarDeltaCost(`instance `vvar `csinstance `delta_cost_n `delta_cost_l):
      `that.`updateInstanceCsvarDeltaCost(`instance, `vvar, `csinstance, `delta_cost_n, `delta_cost_l)
    ENDCLOSURE
    THIS.`_updateInstanceCsvarDeltaCost = `closure_updateInstanceCsvarDeltaCost
    CLOSURE `closure_inInstanceRepeatCsvars(`csinstance `vvar):
      return `that.`inRepeatVars(`csinstance, `vvar)
    ENDCLOSURE
    THIS.`_inInstanceRepeatCsvars = `closure_inInstanceRepeatCsvars
    CLOSURE `closure_isCsinstanceStatusCodeNull(`csinstance):
      return `isnull(`that.`getStatusCode(`csinstance))
    ENDCLOSURE
    THIS.`_isCsinstanceStatusCodeNull = `closure_isCsinstanceStatusCodeNull
    CLOSURE `closure_getCsinstance(`vvar `vmod `instance):
      return `instance
    ENDCLOSURE
    THIS.`_getCsinstance = `closure_getCsinstance

  METHOD `setCallbacks(`onProcedure `onYieldResume `rnd32b):
    THIS.`_onProcedure = `onProcedure
    THIS.`_onYieldResume = `onYieldResume
    THIS.`_rnd32b = `rnd32b

  METHOD `setCbGetCsinstance(`cbGetCsinstance):
    THIS.`_getCsinstance = `cbGetCsinstance

  METHOD `getModules():
    return THIS.`_module_list

  METHOD `openModule(`source_code `module_name):
    VAR `j
    VAR `module_idx
    VAR `module_j
    VAR `module_name_lcase
    VAR `num
    VAR `ok
    VAR `prefix
    IF `isnull(`module_name):
      `prefix = "untitled"
      `num = 1
      WHILE TRUE:
        `ok = TRUE
        `module_name = `prefix+`str(`num)
        `module_name_lcase = `lowercase(`module_name)
        `module_idx = `length(THIS.`_module_list)
        FORINCR `j(0 `length(THIS.`_module_list)):
          `module_j = THIS.`_module_list[`j]
          IF THIS.`_modules[`module_j][`key_modules_module_name_lcase] < `module_name_lcase:
            continue
          ENDIF
          IF THIS.`_modules[`module_j][`key_modules_module_name_lcase] > `module_name_lcase:
            `module_idx = `j
            break
          ENDIF
          `ok = FALSE
          break
        ENDFOR
        IF `ok:
          break
        ENDIF
        `num += 1
      ENDWHILE
    ELSE:
      `module_name_lcase = `lowercase(`module_name)
      `module_idx = `length(THIS.`_module_list)
      FORINCR `j(0 `length(THIS.`_module_list)):
        `module_j = THIS.`_module_list[`j]
        IF THIS.`_modules[`module_j][`key_modules_module_name_lcase] < `module_name_lcase:
          continue
        ENDIF
        `module_idx = `j
        break
      ENDFOR
    ENDIF
    VAR `module = THIS.`_ihandle.`alloc()
    VAR `editor_m = NEW `EditorM(`source_code)
    `poke(THIS.`_module_list, `module_idx, `module)
    THIS.`_modules[`module] = {}
    THIS.`_modules[`module][`key_modules_module_name] = `module_name
    THIS.`_modules[`module][`key_modules_module_name_lcase] = `module_name_lcase
    THIS.`_modules[`module][`key_modules_editor_m] = `editor_m
    THIS.`_modules[`module][`key_modules_instances] = []
    return `module

  METHOD `getModuleName(`module):
    return THIS.`_modules[`module][`key_modules_module_name]

  METHOD `getModuleNameLcase(`module):
    return THIS.`_modules[`module][`key_modules_module_name_lcase]

  METHOD `renameModule(`module `module_name):
    THIS.`_modules[`module][`key_modules_module_name] = `module_name
    THIS.`_modules[`module][`key_modules_module_name_lcase] = `lowercase(`module_name)

  METHOD `getModuleInstances(`module):
    return THIS.`_modules[`module][`key_modules_instances]

  METHOD `getParserError(`module):
    return THIS.`_modules[`module][`key_modules_editor_m].`getParserError()

  METHOD `getEntryLnno(`module):
    return THIS.`_modules[`module][`key_modules_editor_m].`getEntryLnno()

  METHOD `getSourceCode(`module):
    return THIS.`_modules[`module][`key_modules_editor_m].`getSourceCode()

  METHOD `setSourceCode(`module `source_code):
    THIS.`_modules[`module][`key_modules_editor_m].`setSourceCode(`source_code)

  METHOD `getLnnoCount(`module):
    return THIS.`_modules[`module][`key_modules_editor_m].`getLnnoCount()

  METHOD `getTokens(`module `lnno):
    return THIS.`_modules[`module][`key_modules_editor_m].`getTokens(`lnno)

  METHOD `hasBreakpoint(`module `lnno):
    return THIS.`_modules[`module][`key_modules_editor_m].`hasBreakpoint(`lnno)

  METHOD `setBreakpoint(`module `lnno):
    THIS.`_modules[`module][`key_modules_editor_m].`setBreakpoint(`lnno)

  METHOD `clearBreakpoint(`module `lnno):
    THIS.`_modules[`module][`key_modules_editor_m].`clearBreakpoint(`lnno)

  METHOD `isCompiled(`module):
    return THIS.`_modules[`module][`key_modules_editor_m].`isCompiled()

  METHOD `compile(`module):
    THIS.`_modules[`module][`key_modules_editor_m].`compile()

  METHOD `closeModule(`module):
    VAR `module_idx = `indexof(THIS.`_module_list, `module)
    THIS.`_modules[`module][`key_modules_editor_m].`destroy()
    THIS.`_modules[`module][`key_modules_editor_m] = NULL
    `pick(THIS.`_module_list, `module_idx)
    `delete(THIS.`_modules, `module)
    THIS.`_ihandle.`free(`module)

  METHOD `getEnvs():
    return THIS.`_env_list

  METHOD `createEnv():
    VAR `env = THIS.`_ihandle.`alloc()
    `push(THIS.`_env_list, `env)
    THIS.`_envs[`env] = {}
    THIS.`_envs[`env][`key_envs_environment] = NEW `Environment()
    THIS.`_envs[`env][`key_envs_varnames] = []
    THIS.`_envs[`env][`key_envs_procnames] = []
    THIS.`_envs[`env][`key_envs_instances] = []
    return `env

  METHOD `getEnvInstances(`env):
    return THIS.`_envs[`env][`key_envs_instances]

  METHOD `deleteEnv(`env):
    VAR `env_idx = `indexof(THIS.`_env_list, `env)
    THIS.`_envs[`env][`key_envs_environment].`destroy()
    THIS.`_envs[`env][`key_envs_environment] = NULL
    THIS.`_envs[`env][`key_envs_varnames] = NULL
    THIS.`_envs[`env][`key_envs_procnames] = NULL
    THIS.`_envs[`env][`key_envs_instances] = NULL
    `pick(THIS.`_env_list, `env_idx)
    `delete(THIS.`_envs, `env)
    THIS.`_ihandle.`free(`env)

  METHOD `getInstances():
    return THIS.`_instance_list

  METHOD `addInstance(`module):
    VAR `instance = THIS.`_ihandle.`alloc()
    VAR `interp_m = NEW `InterpM(THIS.`_modules[`module][`key_modules_editor_m], THIS.`_getEvar, THIS.`_onProcedure, THIS.`_onYieldResume, THIS.`_rnd32b, `instance, THIS.`_existsInstanceCsvar, THIS.`_getInstanceCsvar, THIS.`_addInstanceCsvar, THIS.`_removeInstanceCsvar, THIS.`_updateInstanceCsvarDeltaCost, THIS.`_inInstanceRepeatCsvars, THIS.`_isCsinstanceStatusCodeNull, THIS.`_getCsinstance)
    `push(THIS.`_instance_list, `instance)
    THIS.`_instances[`instance] = {}
    THIS.`_instances[`instance][`key_instances_interp_m] = `interp_m
    THIS.`_instances[`instance][`key_instances_module] = `module
    THIS.`_instances[`instance][`key_instances_envs] = []
    THIS.`_instances[`instance][`key_instances_state] = `INTERP_STATE_READY
    `push(THIS.`_modules[`module][`key_modules_instances], `instance)
    `push(THIS.`_ready_instances, `instance)
    return `instance

  METHOD `cloneInstance(`instance):
    VAR `module = THIS.`_instances[`instance][`key_instances_module]
    VAR `cloned_instance = THIS.`addInstance(`module)
    VAR `instance_envs = THIS.`_instances[`instance][`key_instances_envs]
    VAR `j
    VAR `env
    FORINCR `j(0 `length(`instance_envs)):
      `env = `instance_envs[`j]
      THIS.`pushEnv(`cloned_instance, `env)
    ENDFOR
    VAR `ivarnames = THIS.`getInstanceVarNames(`instance)
    VAR `ivarname
    VAR `ivarvalue
    FORINCR `j(0 `length(`ivarnames)):
      `ivarname = `ivarnames[`j]
      `ivarvalue = THIS.`getInstanceVar(`instance, `ivarname)
      THIS.`addInstanceVar(`cloned_instance, `ivarname, `ivarvalue)
    ENDFOR
    return `cloned_instance

  METHOD `getInstanceModule(`instance):
    return THIS.`_instances[`instance][`key_instances_module]

  METHOD `getInstanceEnvs(`instance):
    return THIS.`_instances[`instance][`key_instances_envs]

  METHOD `getInstanceState(`instance):
    return THIS.`_instances[`instance][`key_instances_state]

  METHOD `removeInstance(`instance):
    THIS.`_instances[`instance][`key_instances_interp_m].`destroy()
    VAR `module = THIS.`_instances[`instance][`key_instances_module]
    VAR `module_instance_idx = `indexof(THIS.`_modules[`module][`key_modules_instances], `instance)
    `pick(THIS.`_modules[`module][`key_modules_instances], `module_instance_idx)
    VAR `envs = THIS.`_instances[`instance][`key_instances_envs]
    VAR `j
    VAR `env
    VAR `env_instance_idx
    FORINCR `j(0 `length(`envs)):
      `env = `envs[`j]
      `env_instance_idx = `indexof(THIS.`_envs[`env][`key_envs_instances], `env)
      `pick(THIS.`_envs[`env][`key_envs_instances], `env_instance_idx)
    ENDFOR
    VAR `state = THIS.`_instances[`instance][`key_instances_state]
    VAR `ready_instance_idx
    VAR `limit_instance_idx
    VAR `pause_instance_idx
    VAR `yield_instance_idx
    VAR `error_instance_idx
    VAR `ended_instance_idx
    IF `state == `INTERP_STATE_READY:
      `ready_instance_idx = `indexof(THIS.`_ready_instances, `instance)
      `pick(THIS.`_ready_instances, `ready_instance_idx)
    ELSIF `state == `INTERP_STATE_LIMIT:
      `limit_instance_idx = `indexof(THIS.`_limit_instances, `instance)
      `pick(THIS.`_limit_instances, `limit_instance_idx)
    ELSIF `state == `INTERP_STATE_PAUSE:
      `pause_instance_idx = `indexof(THIS.`_pause_instances, `instance)
      `pick(THIS.`_pause_instances, `pause_instance_idx)
    ELSIF `state == `INTERP_STATE_YIELD:
      `yield_instance_idx = `indexof(THIS.`_yield_instances, `instance)
      `pick(THIS.`_yield_instances, `yield_instance_idx)
    ELSIF `state == `INTERP_STATE_ERROR:
      `error_instance_idx = `indexof(THIS.`_error_instances, `instance)
      `pick(THIS.`_error_instances, `error_instance_idx)
    ELSIF `state == `INTERP_STATE_ENDED:
      `ended_instance_idx = `indexof(THIS.`_ended_instances, `instance)
      `pick(THIS.`_ended_instances, `ended_instance_idx)
    ENDIF
    VAR `instance_idx = `indexof(THIS.`_instance_list, `instance)
    `pick(THIS.`_instance_list, `instance_idx)
    THIS.`_instances[`instance][`key_instances_interp_m] = NULL
    THIS.`_instances[`instance][`key_instances_module] = NULL
    THIS.`_instances[`instance][`key_instances_envs] = NULL
    THIS.`_instances[`instance][`key_instances_state] = NULL
    `delete(THIS.`_instances, `instance)
    THIS.`_ihandle.`free(`instance)

  METHOD `pushEnv(`instance `env):
    `push(THIS.`_instances[`instance][`key_instances_envs], `env)
    `push(THIS.`_envs[`env][`key_envs_instances], `instance)

  METHOD `removeEnv(`instance `env):
    VAR `instance_env_idx = `indexof(THIS.`_instances[`instance][`key_instances_envs], `env)
    `pick(THIS.`_instances[`instance][`key_instances_envs], `instance_env_idx)
    VAR `env_instance_idx = `indexof(THIS.`_envs[`env][`key_envs_instances], `instance)
    `pick(THIS.`_envs[`env][`key_envs_instances], `env_instance_idx)

  METHOD `getVarNames(`env):
    return THIS.`_envs[`env][`key_envs_varnames]

  METHOD `addVar(`env `varname `evalue):
    `push(THIS.`_envs[`env][`key_envs_varnames], `varname)
    THIS.`_envs[`env][`key_envs_environment].`set(`varname, `evalue)

  METHOD `overwriteVar(`env `varname `varvalue):
    return THIS.`_envs[`env][`key_envs_environment].`overwrite(`varname, `varvalue)

  METHOD `getVar(`env `varname):
    return THIS.`_envs[`env][`key_envs_environment].`get(`varname)

  METHOD `removeVar(`env `varname):
    VAR `idx = `indexof(THIS.`_envs[`env][`key_envs_varnames], `varname)
    `pick(THIS.`_envs[`env][`key_envs_varnames], `idx)
    THIS.`_envs[`env][`key_envs_environment].`del(`varname)

  METHOD `getProcedureNames(`env):
    return THIS.`_envs[`env][`key_envs_procnames]

  METHOD `addProcedure(`env `procname `evalue):
    `push(THIS.`_envs[`env][`key_envs_procnames], `procname)
    THIS.`_envs[`env][`key_envs_environment].`set(`procname, `evalue)

  METHOD `removeProcedure(`env `procname):
    VAR `idx = `indexof(THIS.`_envs[`env][`key_envs_procnames], `procname)
    `pick(THIS.`_envs[`env][`key_envs_procnames], `idx)
    THIS.`_envs[`env][`key_envs_environment].`del(`procname)

  METHOD `getInstanceVarNames(`instance):
    return THIS.`_instances[`instance][`key_instances_interp_m].`getVarNames()

  METHOD `addInstanceVar(`instance `ivarname `evalue):
    THIS.`_instances[`instance][`key_instances_interp_m].`addVar(`ivarname, `evalue)

  METHOD `getInstanceVar(`instance `ivarname):
    return THIS.`_instances[`instance][`key_instances_interp_m].`getVar(`ivarname)

  METHOD `removeInstanceVar(`instance `ivarname):
    THIS.`_instances[`instance][`key_instances_interp_m].`removeVar(`ivarname)

  METHOD `addInstanceCsvar(`instance `ivarname `evalue `csinstance):
    VAR `csvarname = `ivarname+"@"+THIS.`getModuleName(THIS.`getInstanceModule(`csinstance))
    THIS.`_instances[`csinstance][`key_instances_interp_m].`addCsvar(`ivarname, `evalue)
    THIS.`_instances[`instance][`key_instances_interp_m].`addCsvarCost(`csvarname, `evalue)

  METHOD `removeInstanceCsvar(`instance `ivarname `csinstance):
    VAR `csvarname = `ivarname+"@"+THIS.`getModuleName(THIS.`getInstanceModule(`csinstance))
    VAR `evalue = THIS.`_instances[`csinstance][`key_instances_interp_m].`removeCsvar(`ivarname)
    THIS.`_instances[`instance][`key_instances_interp_m].`removeCsvarCost(`csvarname, `evalue)

  METHOD `updateInstanceCsvarDeltaCost(`instance `ivarname `csinstance `delta_cost_n `delta_cost_l):
    VAR `csvarname
    IF `instance == `csinstance:
      THIS.`_instances[`instance][`key_instances_interp_m].`updateCsvarDeltaCost(`ivarname, `delta_cost_n, `delta_cost_l)
    ELSE:
      `csvarname = `ivarname+"@"+THIS.`getModuleName(THIS.`getInstanceModule(`csinstance))
      THIS.`_instances[`instance][`key_instances_interp_m].`updateCsvarDeltaCost(`csvarname, `delta_cost_n, `delta_cost_l)
    ENDIF

  METHOD `getRunningInstance():
    return THIS.`_running_instance

  METHOD `getReadyInstances():
    return THIS.`_ready_instances

  METHOD `getLimitInstances():
    return THIS.`_limit_instances

  METHOD `getPauseInstances():
    return THIS.`_pause_instances

  METHOD `getYieldInstances():
    return THIS.`_yield_instances

  METHOD `getErrorInstances():
    return THIS.`_error_instances

  METHOD `getEndedInstances():
    return THIS.`_ended_instances

  METHOD `inRepeatVars(`instance `ivarname):
    return THIS.`_instances[`instance][`key_instances_interp_m].`inRepeatVars(`ivarname)

  METHOD `run(`instance `stepping `limits):
    THIS.`_running_instance = `instance
    VAR `result_list = THIS.`_instances[`instance][`key_instances_interp_m].`run(`instance, `stepping, `limits)
    THIS.`_running_instance = NULL
    VAR `state = `result_list[0]
    THIS.`_updateInstanceState(`instance, `state)
    return `result_list

  METHOD `resume(`instance `stepping `limits):
    VAR `resume_yield = (THIS.`_instances[`instance][`key_instances_state] == `INTERP_STATE_YIELD)
    THIS.`_running_instance = `instance
    VAR `result_list = THIS.`_instances[`instance][`key_instances_interp_m].`resume(`instance, `resume_yield, `stepping, `limits)
    THIS.`_running_instance = NULL
    VAR `state = `result_list[0]
    THIS.`_updateInstanceState(`instance, `state)
    return `result_list

  METHOD `reap(`instance):
    THIS.`_instances[`instance][`key_instances_interp_m].`reap()
    THIS.`_updateInstanceState(`instance, `INTERP_STATE_READY)

  METHOD `reset(`instance):
    THIS.`_instances[`instance][`key_instances_interp_m].`reset()

  METHOD `returnWithStatus(`instance `status_code):
    THIS.`_instances[`instance][`key_instances_interp_m].`returnWithStatus(`status_code)

  METHOD `prequelYield(`instance):
    THIS.`_instances[`instance][`key_instances_interp_m].`prequelYield()

  METHOD `runtimeError(`instance `error_message):
    THIS.`_instances[`instance][`key_instances_interp_m].`runtimeError(`error_message)

  METHOD `getStatusCode(`instance):
    return THIS.`_instances[`instance][`key_instances_interp_m].`getStatusCode()

  METHOD `readDebugl(`instance):
    return THIS.`_instances[`instance][`key_instances_interp_m].`readDebugl()

  METHOD `readChangedVars(`instance):
    return THIS.`_instances[`instance][`key_instances_interp_m].`readChangedVars()

  METHOD `_updateInstanceState(`instance `state):
    VAR `old_state = THIS.`_instances[`instance][`key_instances_state]
    IF `old_state == `state:
      return
    ENDIF
    THIS.`_instances[`instance][`key_instances_state] = `state
    VAR `idx
    IF `old_state == `INTERP_STATE_READY:
      `idx = `indexof(THIS.`_ready_instances, `instance)
      `pick(THIS.`_ready_instances, `idx)
    ELSIF `old_state == `INTERP_STATE_LIMIT:
      `idx = `indexof(THIS.`_limit_instances, `instance)
      `pick(THIS.`_limit_instances, `idx)
    ELSIF `old_state == `INTERP_STATE_PAUSE:
      `idx = `indexof(THIS.`_pause_instances, `instance)
      `pick(THIS.`_pause_instances, `idx)
    ELSIF `old_state == `INTERP_STATE_YIELD:
      `idx = `indexof(THIS.`_yield_instances, `instance)
      `pick(THIS.`_yield_instances, `idx)
    ELSIF `old_state == `INTERP_STATE_ERROR:
      `idx = `indexof(THIS.`_error_instances, `instance)
      `pick(THIS.`_error_instances, `idx)
    ELSIF `old_state == `INTERP_STATE_ENDED:
      `idx = `indexof(THIS.`_ended_instances, `instance)
      `pick(THIS.`_ended_instances, `idx)
    ENDIF
    IF `state == `INTERP_STATE_READY:
      `push(THIS.`_ready_instances, `instance)
    ELSIF `state == `INTERP_STATE_LIMIT:
      `push(THIS.`_limit_instances, `instance)
    ELSIF `state == `INTERP_STATE_PAUSE:
      `push(THIS.`_pause_instances, `instance)
    ELSIF `state == `INTERP_STATE_YIELD:
      `push(THIS.`_yield_instances, `instance)
    ELSIF `state == `INTERP_STATE_ERROR:
      `push(THIS.`_error_instances, `instance)
    ELSIF `state == `INTERP_STATE_ENDED:
      `push(THIS.`_ended_instances, `instance)
    ENDIF

ENDCLASS

CLASS Prequel:

  METHOD_INIT(`onProcedure `onYieldResume `rnd32b `_fp):
    `fp[0] = `_fp
    THIS.`_prequel_m = NEW `PrequelM({})
    THIS.`_prequel_m.`init(`onProcedure, `onYieldResume, `rnd32b)
    THIS.`_error = NULL

  METHOD getVersion():
    return "1.0"

  METHOD setFP(`_fp):
    `fp[0] = `_fp

  METHOD setCallbacks(`onProcedure `onYieldResume `rnd32b):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `length(`instances) > 0:
      THIS.`_error = "NON"+"-"+"EMPTY"+" "+"INSTANCES"
      return NULL
    ENDIF
    THIS.`_prequel_m.`setCallbacks(`onProcedure, `onYieldResume, `rnd32b)
    return TRUE

  METHOD setCbGetCsinstance(`cbGetCsinstance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `length(`instances) > 0:
      THIS.`_error = "NON"+"-"+"EMPTY"+" "+"INSTANCES"
      return NULL
    ENDIF
    THIS.`_prequel_m.`setCbGetCsinstance(`cbGetCsinstance)
    return TRUE

  METHOD getModules():
    return `utils.`deepCopy(THIS.`_prequel_m.`getModules())

  METHOD openModule(`source_code `module_name):
    IF `not(`lexer.`isValidSourceCode(`source_code)):
      THIS.`_error = "INVALID"+" "+"SOURCE"+" "+"CODE"
      return NULL
    ENDIF
    VAR `module_name_lcase
    VAR `modules
    VAR `j
    VAR `module_name_lcase_j
    IF `is_type_str(`get_type(`module_name)):
      IF `length(`module_name) == 0:
        THIS.`_error = "EMPTY"+" "+"MODULE"+" "+"NAME"
        return NULL
      ENDIF
      IF `not(`lexer.`isValidModuleName(`module_name)):
        THIS.`_error = "INVALID"+" "+"CHARACTERS"+" "+"IN"+" "+"MODULE"+" "+"NAME"
        return NULL
      ENDIF
      `module_name_lcase = `lowercase(`module_name)
      `modules = THIS.`_prequel_m.`getModules()
      FORINCR `j(0 `length(`modules)):
        `module_name_lcase_j = THIS.`_prequel_m.`getModuleNameLcase(`modules[`j])
        IF `module_name_lcase_j > `module_name_lcase:
          break
        ENDIF
        IF `module_name_lcase_j == `module_name_lcase:
          THIS.`_error = "DUPLICATE"+" "+"MODULE"+" "+"NAME"
          return NULL
        ENDIF
      ENDFOR
    ELSIF `not(`isnull(`module_name)):
      THIS.`_error = "INVALID"+" "+"MODULE"+" "+"NAME"
      return NULL
    ENDIF
    VAR `module = THIS.`_prequel_m.`openModule(`source_code, `module_name)
    VAR `parser_error_info = THIS.`_prequel_m.`getParserError(`module)
    VAR `parser_error = {}
    VAR `entry_lnno
    IF `not(`isnull(`parser_error_info)):
      `parser_error["lnno"] = `parser_error_info[1]
      `parser_error["startcol"] = `parser_error_info[2]
      `parser_error["endcol"] = `parser_error_info[3]
      `parser_error["error_message"] = `parser_error_info[4]
    ELSE:
      IF `not(THIS.`_prequel_m.`isCompiled(`module)):
        THIS.`_prequel_m.`compile(`module)
      ENDIF
      `entry_lnno = THIS.`_prequel_m.`getEntryLnno(`module)
      IF `entry_lnno < 0:
        `parser_error["lnno"] = -1
        `parser_error["startcol"] = -1
        `parser_error["endcol"] = -1
        `parser_error["error_message"] = "NO"+" "+"INSTRUCTION"+" "+"FOUND"
      ELSE:
        `parser_error["error_message"] = ""
      ENDIF
    ENDIF
    VAR `result = {}
    `result["module"] = `module
    `result["parser_error"] = `parser_error
    `result["source_code"] = THIS.`_prequel_m.`getSourceCode(`module)
    `result["module_name"] = THIS.`_prequel_m.`getModuleName(`module)
    return `result

  METHOD closeModule(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    VAR `module_instances = THIS.`_prequel_m.`getModuleInstances(`module)
    IF `length(`module_instances) > 0:
      THIS.`_error = "MODULE"+" "+"HAS"+" "+"INSTANCES"
      return NULL
    ENDIF
    THIS.`_prequel_m.`closeModule(`module)
    return TRUE

  METHOD getSourceCode(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`getSourceCode(`module)

  METHOD setSourceCode(`module `source_code):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidSourceCode(`source_code)):
      THIS.`_error = "INVALID"+" "+"SOURCE"+" "+"CODE"
      return NULL
    ENDIF
    VAR `module_instances = THIS.`_prequel_m.`getModuleInstances(`module)
    IF `length(`module_instances) > 0:
      THIS.`_error = "MODULE"+" "+"HAS"+" "+"INSTANCES"
      return NULL
    ENDIF
    THIS.`_prequel_m.`setSourceCode(`module, `source_code)
    return THIS.`_prequel_m.`getSourceCode(`module)

  METHOD getModuleName(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`getModuleName(`module)

  METHOD renameModule(`module `module_name):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    IF `not(`is_type_str(`get_type(`module_name))):
      THIS.`_error = "INVALID"+" "+"MODULE"+" "+"NAME"
      return NULL
    ENDIF
    IF `length(`module_name) == 0:
      THIS.`_error = "EMPTY"+" "+"MODULE"+" "+"NAME"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidModuleName(`module_name)):
      THIS.`_error = "INVALID"+" "+"CHARACTERS"+" "+"IN"+" "+"MODULE"+" "+"NAME"
      return NULL
    ENDIF
    VAR `module_name_lcase = `lowercase(`module_name)
    VAR `old_module_name_lcase = THIS.`_prequel_m.`getModuleNameLcase(`module)
    VAR `j
    VAR `module_name_lcase_j
    IF `module_name_lcase != `old_module_name_lcase:
      FORINCR `j(0 `length(`modules)):
        `module_name_lcase_j = THIS.`_prequel_m.`getModuleNameLcase(`modules[`j])
        IF `module_name_lcase_j > `module_name_lcase:
          break
        ENDIF
        IF `module_name_lcase_j == `module_name_lcase:
          THIS.`_error = "DUPLICATE"+" "+"MODULE"+" "+"NAME"
          return NULL
        ENDIF
      ENDFOR
    ENDIF
    THIS.`_prequel_m.`renameModule(`module, `module_name)
    return TRUE

  METHOD getLnnoCount(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`getLnnoCount(`module)

  METHOD getTokens(`module `lnno):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    IF `not(`is_type_num(`get_type(`lnno))) OR (`lnno != `trunc(`lnno)) OR (`lnno < 0):
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    VAR `lnno_count = THIS.`_prequel_m.`getLnnoCount(`module)
    IF `lnno >= `lnno_count:
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    VAR `raw_tokens = THIS.`_prequel_m.`getTokens(`module, `lnno)
    VAR `tokens = []
    VAR `j
    VAR `token_str
    VAR `token_value
    VAR `token_extra
    VAR `indexof_csvar
    FORINCR `j(0 `length(`raw_tokens)-1):
      `token_str = `tokenIdToString(`lexer.`tokenId(`raw_tokens[`j]))
      `token_value = `lexer.`tokenValue(`raw_tokens[`j])
      `push(`tokens, [`token_str, `token_value])
    ENDFOR
    return `tokens

  METHOD getParserError(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    VAR `parser_error_info = THIS.`_prequel_m.`getParserError(`module)
    VAR `parser_error = {}
    VAR `entry_lnno
    IF `not(`isnull(`parser_error_info)):
      `parser_error["lnno"] = `parser_error_info[1]
      `parser_error["startcol"] = `parser_error_info[2]
      `parser_error["endcol"] = `parser_error_info[3]
      `parser_error["error_message"] = `parser_error_info[4]
    ELSE:
      IF `not(THIS.`_prequel_m.`isCompiled(`module)):
        THIS.`_prequel_m.`compile(`module)
      ENDIF
      `entry_lnno = THIS.`_prequel_m.`getEntryLnno(`module)
      IF `entry_lnno < 0:
        `parser_error["lnno"] = -1
        `parser_error["startcol"] = -1
        `parser_error["endcol"] = -1
        `parser_error["error_message"] = "NO"+" "+"INSTRUCTION"+" "+"FOUND"
      ELSE:
        `parser_error["error_message"] = ""
      ENDIF
    ENDIF
    return `parser_error

  METHOD getEntryLnno(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    VAR `parser_error = THIS.`_prequel_m.`getParserError(`module)
    IF `not(`isnull(`parser_error)):
      THIS.`_error = "PARSER"+" "+"ERROR"
      return NULL
    ENDIF
    IF `not(THIS.`_prequel_m.`isCompiled(`module)):
      THIS.`_prequel_m.`compile(`module)
    ENDIF
    VAR `entry_lnno = THIS.`_prequel_m.`getEntryLnno(`module)
    IF `entry_lnno < 0:
      THIS.`_error = "PARSER"+" "+"ERROR"
      return NULL
    ENDIF
    return `entry_lnno

  METHOD hasBreakpoint(`module `lnno):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    IF `not(`is_type_num(`get_type(`lnno))) OR (`lnno != `trunc(`lnno)) OR (`lnno < 0):
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    VAR `lnno_count = THIS.`_prequel_m.`getLnnoCount(`module)
    IF `lnno >= `lnno_count:
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`hasBreakpoint(`module, `lnno)

  METHOD setBreakpoint(`module `lnno):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    IF `not(`is_type_num(`get_type(`lnno))) OR (`lnno != `trunc(`lnno)) OR (`lnno < 0):
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    VAR `lnno_count = THIS.`_prequel_m.`getLnnoCount(`module)
    IF `lnno >= `lnno_count:
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    THIS.`_prequel_m.`setBreakpoint(`module, `lnno)
    return TRUE

  METHOD clearBreakpoint(`module `lnno):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    IF `not(`is_type_num(`get_type(`lnno))) OR (`lnno != `trunc(`lnno)) OR (`lnno < 0):
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    VAR `lnno_count = THIS.`_prequel_m.`getLnnoCount(`module)
    IF `lnno >= `lnno_count:
      THIS.`_error = "INVALID"+" "+"LNNO"
      return NULL
    ENDIF
    THIS.`_prequel_m.`clearBreakpoint(`module, `lnno)
    return TRUE

  METHOD getEnvs():
    return `utils.`deepCopy(THIS.`_prequel_m.`getEnvs())

  METHOD createEnv():
    return THIS.`_prequel_m.`createEnv()

  METHOD deleteEnv(`env):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `env_instances = THIS.`_prequel_m.`getEnvInstances(`env)
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)) AND (`indexof(`env_instances, `running_instance) >= 0):
      THIS.`_error = "ENV"+" "+"IN"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`deleteEnv(`env)
    return TRUE

  METHOD getModuleInstances(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    return `utils.`deepCopy(THIS.`_prequel_m.`getModuleInstances(`module))

  METHOD addInstance(`module):
    VAR `modules = THIS.`_prequel_m.`getModules()
    IF `indexof(`modules, `module) < 0:
      THIS.`_error = "INVALID"+" "+"MODULE"
      return NULL
    ENDIF
    VAR `parser_error = THIS.`_prequel_m.`getParserError(`module)
    IF `not(`isnull(`parser_error)):
      THIS.`_error = "PARSER"+" "+"ERROR"
      return NULL
    ENDIF
    IF `not(THIS.`_prequel_m.`isCompiled(`module)):
      THIS.`_prequel_m.`compile(`module)
    ENDIF
    VAR `entry_lnno = THIS.`_prequel_m.`getEntryLnno(`module)
    IF `entry_lnno < 0:
      THIS.`_error = "PARSER"+" "+"ERROR"
      return NULL
    ENDIF
    VAR `instance = THIS.`_prequel_m.`addInstance(`module)
    return `instance

  METHOD cloneInstance(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `running_instance == `instance:
      THIS.`_error = "RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instance_state = THIS.`_prequel_m.`getInstanceState(`instance)
    IF `instance_state != `INTERP_STATE_READY:
      THIS.`_error = "ACTIVE"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `cloned_instance = THIS.`_prequel_m.`cloneInstance(`instance)
    return `cloned_instance

  METHOD removeInstance(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `running_instance == `instance:
      THIS.`_error = "RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instance_state = THIS.`_prequel_m.`getInstanceState(`instance)
    IF `instance_state != `INTERP_STATE_READY:
      THIS.`_error = "ACTIVE"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`removeInstance(`instance)
    return TRUE

  METHOD getInstanceEnvs(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    return `utils.`deepCopy(THIS.`_prequel_m.`getInstanceEnvs(`instance))

  METHOD pushEnv(`instance `env):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `running_instance == `instance:
      THIS.`_error = "RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`pushEnv(`instance, `env)
    return TRUE

  METHOD removeEnv(`instance `env):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `running_instance == `instance:
      THIS.`_error = "RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`removeEnv(`instance, `env)
    return TRUE

  METHOD getVarNames(`env):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    return `utils.`deepCopy(THIS.`_prequel_m.`getVarNames(`env))

  METHOD addVar(`env `varname `varvalue):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `env_instances = THIS.`_prequel_m.`getEnvInstances(`env)
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)) AND (`indexof(`env_instances, `running_instance) >= 0):
      THIS.`_error = "ENV"+" "+"IN"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidVarname(`varname)):
      THIS.`_error = "INVALID"+" "+"VARNAME"
      return NULL
    ENDIF
    VAR `varnames = THIS.`_prequel_m.`getVarNames(`env)
    IF `indexof(`varnames, `varname) >= 0:
      THIS.`_error = "DUPLICATE"+" "+"VARNAME"
      return NULL
    ENDIF
    VAR `procnames = THIS.`_prequel_m.`getProcedureNames(`env)
    IF `indexof(`procnames, `varname) >= 0:
      THIS.`_error = "PROCEDURE"+" "+"NAMED"+" "+"VARNAME"+" "+"ALREADY"+" "+"EXISTS"
      return NULL
    ENDIF
    VAR `evalue = `utils.`encodeData(`varvalue)
    IF `isnull(`evalue):
      THIS.`_error = "INVALID"+" "+"VARVALUE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`addVar(`env, `varname, `evalue)
    return TRUE

  METHOD overwriteVar(`env `varname `varvalue):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `env_instances = THIS.`_prequel_m.`getEnvInstances(`env)
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)) AND (`indexof(`env_instances, `running_instance) >= 0):
      THIS.`_error = "ENV"+" "+"IN"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `varnames = THIS.`_prequel_m.`getVarNames(`env)
    VAR `procnames
    VAR `evalue
    IF `indexof(`varnames, `varname) < 0:
      IF `not(`lexer.`isValidVarname(`varname)):
        THIS.`_error = "INVALID"+" "+"VARNAME"
        return NULL
      ENDIF
      `procnames = THIS.`_prequel_m.`getProcedureNames(`env)
      IF `indexof(`procnames, `varname) >= 0:
        THIS.`_error = "PROCEDURE"+" "+"NAMED"+" "+"VARNAME"+" "+"ALREADY"+" "+"EXISTS"
        return NULL
      ENDIF
      `evalue = `utils.`encodeData(`varvalue)
      IF `isnull(`evalue):
        THIS.`_error = "INVALID"+" "+"VARVALUE"
        return NULL
      ENDIF
      THIS.`_prequel_m.`addVar(`env, `varname, `evalue)
      return TRUE
    ENDIF
    IF `not(THIS.`_prequel_m.`overwriteVar(`env, `varname, `varvalue)):
      THIS.`_error = "INVALID"+" "+"VARVALUE"
      return NULL
    ENDIF
    return TRUE

  METHOD getVar(`env `varname):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `varnames = THIS.`_prequel_m.`getVarNames(`env)
    IF `indexof(`varnames, `varname) < 0:
      IF `not(`lexer.`isValidVarname(`varname)):
        THIS.`_error = "INVALID"+" "+"VARNAME"
        return NULL
      ENDIF
      return ""
    ENDIF
    VAR `evalue = THIS.`_prequel_m.`getVar(`env, `varname)
    VAR `varvalue = `utils.`decodeData(`evalue)
    IF `isnull(`varvalue):
      THIS.`_error = "INVALID"+" "+"VARVALUE"
      return NULL
    ENDIF
    return `varvalue[1]

  METHOD removeVar(`env `varname):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `env_instances = THIS.`_prequel_m.`getEnvInstances(`env)
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)) AND (`indexof(`env_instances, `running_instance) >= 0) AND `isnull(THIS.`_prequel_m.`getStatusCode(`running_instance)):
      THIS.`_error = "ENV"+" "+"IN"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `varnames = THIS.`_prequel_m.`getVarNames(`env)
    IF `indexof(`varnames, `varname) < 0:
      IF `not(`lexer.`isValidVarname(`varname)):
        THIS.`_error = "INVALID"+" "+"VARNAME"
        return NULL
      ENDIF
      THIS.`_error = "UNKNOWN"+" "+"VARNAME"
      return NULL
    ENDIF
    THIS.`_prequel_m.`removeVar(`env, `varname)
    return TRUE

  METHOD getProcedureNames(`env):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    return `utils.`deepCopy(THIS.`_prequel_m.`getProcedureNames(`env))

  METHOD addProcedure(`env `procname `args_synopsis):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `env_instances = THIS.`_prequel_m.`getEnvInstances(`env)
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)) AND (`indexof(`env_instances, `running_instance) >= 0):
      THIS.`_error = "ENV"+" "+"IN"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidVarname(`procname)) AND (`procname != "CALL") AND (`procname != "RETURN"):
      THIS.`_error = "INVALID"+" "+"PROCNAME"
      return NULL
    ENDIF
    VAR `procnames = THIS.`_prequel_m.`getProcedureNames(`env)
    IF `indexof(`procnames, `procname) >= 0:
      THIS.`_error = "DUPLICATE"+" "+"PROCNAME"
      return NULL
    ENDIF
    VAR `varnames = THIS.`_prequel_m.`getVarNames(`env)
    IF `indexof(`varnames, `procname) >= 0:
      THIS.`_error = "VAR"+" "+"NAMED"+" "+"PROCNAME"+" "+"ALREADY"+" "+"EXISTS"
      return NULL
    ENDIF
    VAR `evalue = `utils.`encodeProcedure(`args_synopsis)
    IF `isnull(`evalue):
      THIS.`_error = "INVALID"+" "+"ARGS"+" "+"SYNOPSIS"
      return NULL
    ENDIF
    THIS.`_prequel_m.`addProcedure(`env, `procname, `evalue)
    return TRUE

  METHOD existsProcedure(`env `procname):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `procnames = THIS.`_prequel_m.`getProcedureNames(`env)
    IF `indexof(`procnames, `procname) < 0:
      IF `not(`lexer.`isValidVarname(`procname)) AND (`procname != "CALL") AND (`procname != "RETURN"):
        THIS.`_error = "INVALID"+" "+"PROCNAME"
        return NULL
      ENDIF
      return FALSE
    ENDIF
    return TRUE

  METHOD removeProcedure(`env `procname):
    VAR `envs = THIS.`_prequel_m.`getEnvs()
    IF `indexof(`envs, `env) < 0:
      THIS.`_error = "INVALID"+" "+"ENV"
      return NULL
    ENDIF
    VAR `env_instances = THIS.`_prequel_m.`getEnvInstances(`env)
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)) AND (`indexof(`env_instances, `running_instance) >= 0):
      THIS.`_error = "ENV"+" "+"IN"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `procnames = THIS.`_prequel_m.`getProcedureNames(`env)
    IF `indexof(`procnames, `procname) < 0:
      IF `not(`lexer.`isValidVarname(`procname)) AND (`procname != "CALL") AND (`procname != "RETURN"):
        THIS.`_error = "INVALID"+" "+"PROCNAME"
        return NULL
      ENDIF
      THIS.`_error = "UNKNOWN"+" "+"PROCNAME"
      return NULL
    ENDIF
    THIS.`_prequel_m.`removeProcedure(`env, `procname)
    return TRUE

  METHOD getInstanceVarNames(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    return `utils.`deepCopy(THIS.`_prequel_m.`getInstanceVarNames(`instance))

  METHOD existsInstanceVar(`instance `ivarname):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      return FALSE
    ENDIF
    VAR `ivarnames = THIS.`_prequel_m.`getInstanceVarNames(`instance)
    return (`indexof(`ivarnames, `ivarname) >= 0)

  METHOD addInstanceVar(`ivarname `ivarvalue):
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidIvarname(`ivarname)):
      THIS.`_error = "INVALID"+" "+"IVARNAME"
      return NULL
    ENDIF
    VAR `ivarnames = THIS.`_prequel_m.`getInstanceVarNames(`instance)
    IF `indexof(`ivarnames, `ivarname) >= 0:
      THIS.`_error = "DUPLICATE"+" "+"IVARNAME"
      return NULL
    ENDIF
    VAR `evalue = `utils.`encodeData(`ivarvalue)
    IF `isnull(`evalue):
      THIS.`_error = "INVALID"+" "+"IVARVALUE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`addInstanceVar(`instance, `ivarname, `evalue)
    return TRUE

  METHOD getInstanceVar(`instance `ivarname):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidIvarname(`ivarname)):
      THIS.`_error = "INVALID"+" "+"IVARNAME"
      return NULL
    ENDIF
    VAR `evalue = THIS.`_prequel_m.`getInstanceVar(`instance, `ivarname)
    VAR `ivarvalue
    IF `not(`isnull(`evalue)):
      `ivarvalue = `utils.`decodeData(`evalue)
      IF `isnull(`ivarvalue):
        THIS.`_error = "INVALID"+" "+"IVARVALUE"
        return NULL
      ENDIF
      return `ivarvalue[1]
    ENDIF
    return ""

  METHOD removeInstanceVar(`ivarname):
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `ivarnames = THIS.`_prequel_m.`getInstanceVarNames(`instance)
    IF `indexof(`ivarnames, `ivarname) < 0:
      IF `not(`lexer.`isValidIvarname(`ivarname)):
        THIS.`_error = "INVALID"+" "+"IVARNAME"
        return NULL
      ENDIF
      THIS.`_error = "UNKNOWN"+" "+"IVARNAME"
      return NULL
    ENDIF
    IF THIS.`_prequel_m.`inRepeatVars(`instance, `ivarname) AND `isnull(THIS.`_prequel_m.`getStatusCode(`instance)):
      THIS.`_error = "IVARNAME"+" "+"IN"+" "+"REPEAT"+" "+"VARIABLES"
      return NULL
    ENDIF
    THIS.`_prequel_m.`removeInstanceVar(`instance, `ivarname)
    return TRUE

  METHOD addInstanceCsvar(`csinstance `ivarname `ivarvalue):
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `instance == `csinstance:
      return THIS.addInstanceVar(`ivarname, `ivarvalue)
    ENDIF
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`lexer.`isValidIvarname(`ivarname)):
      THIS.`_error = "INVALID"+" "+"IVARNAME"
      return NULL
    ENDIF
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `csinstance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF (THIS.`_prequel_m.`getInstanceState(`csinstance) != `INTERP_STATE_YIELD) AND (`csinstance != `instance):
      THIS.`_error = "INSTANCE"+" "+"NOT"+" "+"IN"+" "+"CALLSTACK"
      return NULL
    ENDIF
    VAR `ivarnames = THIS.`_prequel_m.`getInstanceVarNames(`csinstance)
    IF `indexof(`ivarnames, `ivarname) >= 0:
      THIS.`_error = "DUPLICATE"+" "+"IVARNAME"
      return NULL
    ENDIF
    VAR `evalue = `utils.`encodeData(`ivarvalue)
    IF `isnull(`evalue):
      THIS.`_error = "INVALID"+" "+"IVARVALUE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`addInstanceCsvar(`instance, `ivarname, `evalue, `csinstance)
    return TRUE

  METHOD removeInstanceCsvar(`csinstance `ivarname):
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `instance == `csinstance:
      return THIS.removeInstanceVar(`ivarname)
    ENDIF
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `csinstance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF (THIS.`_prequel_m.`getInstanceState(`csinstance) != `INTERP_STATE_YIELD) AND (`csinstance != `instance):
      THIS.`_error = "INSTANCE"+" "+"NOT"+" "+"IN"+" "+"CALLSTACK"
      return NULL
    ENDIF
    VAR `ivarnames = THIS.`_prequel_m.`getInstanceVarNames(`csinstance)
    IF `indexof(`ivarnames, `ivarname) < 0:
      IF `not(`lexer.`isValidIvarname(`ivarname)):
        THIS.`_error = "INVALID"+" "+"IVARNAME"
        return NULL
      ENDIF
      THIS.`_error = "UNKNOWN"+" "+"IVARNAME"
      return NULL
    ENDIF
    IF THIS.`_prequel_m.`inRepeatVars(`csinstance, `ivarname) AND `isnull(THIS.`_prequel_m.`getStatusCode(`csinstance)):
      THIS.`_error = "IVARNAME"+" "+"IN"+" "+"REPEAT"+" "+"VARIABLES"
      return NULL
    ENDIF
    THIS.`_prequel_m.`removeInstanceCsvar(`instance, `ivarname, `csinstance)
    return TRUE

  METHOD getInstanceState(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`getInstanceState(`instance)

  METHOD run(`instance `stepping `limits):
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)):
      THIS.`_error = "ALREADY"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instance_state = THIS.`_prequel_m.`getInstanceState(`instance)
    IF `instance_state != `INTERP_STATE_READY:
      THIS.`_error = "NOT"+" "+"READY"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`is_type_bool(`get_type(`stepping))):
      THIS.`_error = "STEPPING"+" "+"IS"+" "+"NOT"+" "+"BOOLEAN"
      return NULL
    ENDIF
    `limits = `utils.`getNormalizedLimits(`limits)
    IF `isnull(`limits):
      THIS.`_error = "INVALID"+" "+"LIMITS"
      return NULL
    ENDIF
    VAR `result_list = THIS.`_prequel_m.`run(`instance, `stepping, `limits)
    `instance_state = `result_list[0]
    VAR `result = {}
    `result["state"] = `instance_state
    `result["count"] = `utils.`setNormalizedLimits(`result_list[1])
    `result["lnno"] = `result_list[2]
    IF `instance_state == `INTERP_STATE_ENDED:
      `result["status_code"] = `result_list[3]
    ELSIF `instance_state == `INTERP_STATE_ERROR:
      `result["error_message"] = `result_list[3]
    ENDIF
    return `result

  METHOD resume(`instance `stepping `limits):
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)):
      THIS.`_error = "ALREADY"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instance_state = THIS.`_prequel_m.`getInstanceState(`instance)
    IF (`instance_state < `INTERP_STATE_LIMIT) OR (`instance_state > `INTERP_STATE_YIELD):
      THIS.`_error = "INVALID"+" "+"INSTANCE"+" "+"STATE"
      return NULL
    ENDIF
    IF `not(`is_type_bool(`get_type(`stepping))):
      THIS.`_error = "STEPPING"+" "+"IS"+" "+"NOT"+" "+"BOOLEAN"
      return NULL
    ENDIF
    IF `not(`isnull(`limits)):
      `limits = `utils.`getNormalizedLimits(`limits)
      IF `isnull(`limits):
        THIS.`_error = "INVALID"+" "+"LIMITS"
        return NULL
      ENDIF
    ENDIF
    VAR `result_list = THIS.`_prequel_m.`resume(`instance, `stepping, `limits)
    `instance_state = `result_list[0]
    VAR `result = {}
    `result["state"] = `instance_state
    `result["count"] = `utils.`setNormalizedLimits(`result_list[1])
    `result["lnno"] = `result_list[2]
    IF `instance_state == `INTERP_STATE_ENDED:
      `result["status_code"] = `result_list[3]
    ELSIF `instance_state == `INTERP_STATE_ERROR:
      `result["error_message"] = `result_list[3]
    ENDIF
    return `result

  METHOD reap(`instance):
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)):
      THIS.`_error = "RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`reap(`instance)
    return TRUE

  METHOD reset(`instance):
    VAR `running_instance = THIS.`_prequel_m.`getRunningInstance()
    IF `not(`isnull(`running_instance)):
      THIS.`_error = "RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    VAR `instance_state = THIS.`_prequel_m.`getInstanceState(`instance)
    IF `instance_state != `INTERP_STATE_READY:
      THIS.`_error = "NOT"+" "+"READY"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`reset(`instance)
    return TRUE

  METHOD returnWithStatus(`status_code):
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`is_type_num(`get_type(`status_code))) OR (`status_code != `trunc(`status_code)) OR (`status_code != `int32(`status_code)):
      THIS.`_error = "INVALID"+" "+"STATUS"+" "+"CODE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`returnWithStatus(`instance, `status_code)
    return TRUE

  METHOD prequelYield():
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`prequelYield(`instance)
    return TRUE

  METHOD runtimeError(`error_message):
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    IF `not(`utils.`isValidErrorMessage(`error_message)):
      THIS.`_error = "INVALID"+" "+"ERROR"+" "+"MESSAGE"
      return NULL
    ENDIF
    THIS.`_prequel_m.`runtimeError(`instance, `error_message)
    return TRUE

  METHOD readDebugl(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`readDebugl(`instance)

  METHOD readChangedVars(`instance):
    VAR `instances = THIS.`_prequel_m.`getInstances()
    IF `indexof(`instances, `instance) < 0:
      THIS.`_error = "INVALID"+" "+"INSTANCE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`readChangedVars(`instance)

  METHOD getRunningModule():
    VAR `instance = THIS.`_prequel_m.`getRunningInstance()
    IF `isnull(`instance):
      THIS.`_error = "NOT"+" "+"RUNNING"+" "+"INSTANCE"
      return NULL
    ENDIF
    return THIS.`_prequel_m.`getInstanceModule(`instance)

  METHOD edAddLine(`module `lnno):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edSetLine(`module `lnno `line):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edDelLine(`module `lnno):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edAddLineAfter(`module `lnno):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edCutLine(`module `lnno):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edPasteLines(`module `lnno):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edIndentLine(`module `lnno):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edCanUndo(`module):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edCanRedo(`module):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edUndo(`module):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD edRedo(`module):
    THIS.`_error = "NOT"+" "+"IMPLEMENTED"
    return NULL

  METHOD isInstanceStateReady(`instance_state):
    return (`instance_state == `INTERP_STATE_READY)

  METHOD isInstanceStateLimit(`instance_state):
    return (`instance_state == `INTERP_STATE_LIMIT)

  METHOD isInstanceStatePause(`instance_state):
    return (`instance_state == `INTERP_STATE_PAUSE)

  METHOD isInstanceStateYield(`instance_state):
    return (`instance_state == `INTERP_STATE_YIELD)

  METHOD isInstanceStateError(`instance_state):
    return (`instance_state == `INTERP_STATE_ERROR)

  METHOD isInstanceStateEnded(`instance_state):
    return (`instance_state == `INTERP_STATE_ENDED)

  METHOD isArgTypeNumber(`arg):
    IF `not(`utils.`isArgData(`arg)):
      THIS.`_error = "INVALID"+" "+"ARG"
      return NULL
    ENDIF
    return (`arg[0] == `ARG_TYPE_NUMBER)

  METHOD isArgTypeList(`arg):
    IF `not(`utils.`isArgData(`arg)):
      THIS.`_error = "INVALID"+" "+"ARG"
      return NULL
    ENDIF
    return (`arg[0] == `ARG_TYPE_LIST)

  METHOD isArgTypeString(`arg):
    IF `not(`utils.`isArgData(`arg)):
      THIS.`_error = "INVALID"+" "+"ARG"
      return NULL
    ENDIF
    return (`arg[0] == `ARG_TYPE_STRING)

  METHOD isArgTypeVarname(`arg):
    IF `not(`utils.`isArgData(`arg)):
      THIS.`_error = "INVALID"+" "+"ARG"
      return NULL
    ENDIF
    return (`arg[0] == `ARG_TYPE_VARNAME)

  METHOD isArgTypeModname(`arg):
    IF `not(`utils.`isArgData(`arg)):
      THIS.`_error = "INVALID"+" "+"ARG"
      return NULL
    ENDIF
    return (`arg[0] == `ARG_TYPE_MODNAME)

  METHOD getArgValue(`arg):
    IF `not(`utils.`isArgData(`arg)):
      THIS.`_error = "INVALID"+" "+"ARG"
      return NULL
    ENDIF
    return `arg[1]

  METHOD getCostValue(`varvalue):
    VAR `evalue = `utils.`encodeData(`varvalue)
    IF `isnull(`evalue):
      THIS.`_error = "INVALID"+" "+"VARVALUE"
      return NULL
    ENDIF
    VAR `nsize = `utils.`nsizeEvalue(`evalue)
    VAR `lsize = `utils.`lsizeEvalue(`evalue)
    VAR `cost = {}
    `cost["memory"] = `lsize+`nsize
    `cost["memory_n"] = `nsize
    `cost["memory_l"] = `lsize
    return `cost

  METHOD isValidSourceCode(`source_code):
    return `lexer.`isValidSourceCode(`source_code)

  METHOD isValidModuleName(`module_name):
    return `lexer.`isValidModuleName(`module_name)

  METHOD isValidVarname(`varname):
    return `lexer.`isValidVarname(`varname)

  METHOD isValidIvarname(`ivarname):
    return `lexer.`isValidIvarname(`ivarname)

  METHOD readError():
    VAR `error = THIS.`_error
    THIS.`_error = NULL
    return `error

  METHOD clearError():
    THIS.`_error = NULL
    return TRUE

ENDCLASS