<reponame>russells-crockpot/roll-with-it
# This file was generated from grammar.peg
# See http://canopy.jcoglan.com/ for documentation.

from collections import defaultdict
import re


class TreeNode(object):
    def __init__(self, text, offset, elements):
        self.text = text
        self.offset = offset
        self.elements = elements

    def __iter__(self):
        for el in self.elements:
            yield el


class TreeNode1(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode1, self).__init__(text, offset, elements)
        self._ws = elements[2]


class TreeNode2(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode2, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.statement = elements[1]


class TreeNode3(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode3, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode4(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode4, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode5(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode5, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode6(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode6, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode7(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode7, self).__init__(text, offset, elements)
        self.keyword = elements[0]


class TreeNode8(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode8, self).__init__(text, offset, elements)
        self._ws = elements[4]
        self._ = elements[5]
        self.statement = elements[3]


class TreeNode9(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode9, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.statement = elements[1]


class TreeNode10(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode10, self).__init__(text, offset, elements)
        self._ = elements[2]


class TreeNode11(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode11, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self._ = elements[1]


class TreeNode12(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode12, self).__init__(text, offset, elements)
        self.expression = elements[3]
        self._ = elements[2]


class TreeNode13(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode13, self).__init__(text, offset, elements)
        self._ws = elements[3]
        self._ = elements[4]


class TreeNode14(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode14, self).__init__(text, offset, elements)
        self.roll_item = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode15(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode15, self).__init__(text, offset, elements)
        self._ = elements[3]


class TreeNode16(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode16, self).__init__(text, offset, elements)
        self._ws = elements[3]
        self.expression = elements[2]
        self._ = elements[4]


class TreeNode17(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode17, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode18(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode18, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode19(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode19, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.two_sided_op = elements[1]


class TreeNode20(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode20, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.two_sided_op = elements[1]


class TreeNode21(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode21, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.one_sided_op = elements[1]


class TreeNode22(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode22, self).__init__(text, offset, elements)
        self.basic_name = elements[0]
        self._ = elements[1]


class TreeNode23(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode23, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.special_accessor = elements[1]


class TreeNode24(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode24, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.special_entry = elements[2]


class TreeNode25(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode25, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.expression = elements[2]


class TreeNode26(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode26, self).__init__(text, offset, elements)
        self.reduce = elements[0]
        self._ = elements[1]


class TreeNode27(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode27, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.special_entry = elements[2]


class TreeNode28(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode28, self).__init__(text, offset, elements)
        self.accessing = elements[0]


class TreeNode29(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode29, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.accessor = elements[1]


class TreeNode30(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode30, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.special_entry = elements[2]


class TreeNode31(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode31, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode32(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode32, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode33(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode33, self).__init__(text, offset, elements)
        self._ = elements[6]
        self.expression = elements[7]
        self.anor = elements[4]


class TreeNode34(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode34, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.anor = elements[1]


class TreeNode35(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode35, self).__init__(text, offset, elements)
        self.comparison = elements[0]
        self._ = elements[3]
        self.anor_op = elements[2]
        self.anor = elements[4]


class TreeNode36(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode36, self).__init__(text, offset, elements)
        self.roll_math = elements[0]
        self._ = elements[3]
        self.comp_op = elements[2]
        self.comparison = elements[4]


class TreeNode37(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode37, self).__init__(text, offset, elements)
        self.add_math = elements[0]
        self._ = elements[4]
        self.roll_math = elements[5]


class TreeNode38(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode38, self).__init__(text, offset, elements)
        self.mult_math = elements[0]
        self._ = elements[4]
        self.add_op = elements[2]
        self.add_math = elements[5]


class TreeNode39(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode39, self).__init__(text, offset, elements)
        self.lambda_expr = elements[0]
        self._ = elements[4]
        self.mult_op = elements[2]
        self.mult_math = elements[5]


class TreeNode40(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode40, self).__init__(text, offset, elements)
        self.first_modifier_call = elements[0]


class TreeNode41(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode41, self).__init__(text, offset, elements)
        self.reduce_expr = elements[5]
        self._ = elements[3]


class TreeNode42(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode42, self).__init__(text, offset, elements)
        self._ws = elements[2]
        self.expression = elements[1]
        self._ = elements[3]


class TreeNode43(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode43, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[1]


class TreeNode44(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode44, self).__init__(text, offset, elements)
        self.dice = elements[0]
        self._ = elements[3]
        self.modifier_tail = elements[4]


class TreeNode45(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode45, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self._ = elements[1]
        self.modifier_tail = elements[2]


class TreeNode46(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode46, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self._ = elements[4]


class TreeNode47(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode47, self).__init__(text, offset, elements)
        self.expression = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode48(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode48, self).__init__(text, offset, elements)
        self.basic_name = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode49(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode49, self).__init__(text, offset, elements)
        self.modifier_params = elements[0]
        self._ = elements[4]
        self.expression = elements[5]


class TreeNode50(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode50, self).__init__(text, offset, elements)
        self.modifier_params = elements[0]
        self._ = elements[6]
        self._ws = elements[2]


class TreeNode51(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode51, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.special_entry = elements[1]


class TreeNode52(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode52, self).__init__(text, offset, elements)
        self.modifier_def_target = elements[0]
        self._ = elements[1]
        self._ws = elements[3]


class TreeNode53(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode53, self).__init__(text, offset, elements)
        self._ = elements[1]
        self._ws = elements[3]


class TreeNode54(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode54, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.stmt_or_expr = elements[1]


class TreeNode55(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode55, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.expression = elements[1]
        self.then = elements[3]


class TreeNode56(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode56, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.expression = elements[1]
        self.then = elements[3]


class TreeNode57(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode57, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.stmt_or_expr = elements[1]


class TreeNode58(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode58, self).__init__(text, offset, elements)
        self.basic_name = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode59(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode59, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode60(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode60, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.access = elements[1]


class TreeNode61(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode61, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.loadable = elements[1]


class TreeNode62(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode62, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.load_from = elements[3]


class TreeNode63(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode63, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.loadable = elements[1]
        self.load_from = elements[3]
        self.load_into = elements[5]


class TreeNode64(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode64, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.loadable = elements[1]
        self.load_from = elements[3]


class TreeNode65(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode65, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.loadable = elements[1]
        self.load_into = elements[3]


class TreeNode66(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode66, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.loadable = elements[1]


class TreeNode67(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode67, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.expression = elements[2]
        self.then = elements[4]


class TreeNode68(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode68, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode69(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode69, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode70(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode70, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode71(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode71, self).__init__(text, offset, elements)
        self._ = elements[1]
        self.statement = elements[2]


class TreeNode72(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode72, self).__init__(text, offset, elements)
        self.statement = elements[0]
        self._ = elements[1]


class TreeNode73(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode73, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.basic_name = elements[1]


class TreeNode74(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode74, self).__init__(text, offset, elements)
        self.stmt_or_expr = elements[0]


class TreeNode75(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode75, self).__init__(text, offset, elements)
        self.expression = elements[0]
        self._ = elements[1]


class TreeNode76(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode76, self).__init__(text, offset, elements)
        self._ = elements[5]
        self.then = elements[6]


class TreeNode77(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode77, self).__init__(text, offset, elements)
        self._ = elements[0]
        self._ws = elements[1]
        self.stmt_or_expr = elements[2]


class TreeNode78(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode78, self).__init__(text, offset, elements)
        self._ws = elements[2]
        self.but_if_stmt = elements[1]
        self.always = elements[3]


class TreeNode79(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode79, self).__init__(text, offset, elements)
        self._ws = elements[2]
        self.but_if_stmt = elements[1]


class TreeNode80(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode80, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.always = elements[1]


class TreeNode81(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode81, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.but_if_stmt = elements[1]


class TreeNode82(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode82, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.expression = elements[1]


class TreeNode83(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode83, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.access = elements[1]


class TreeNode84(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode84, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.restart_pos = elements[1]


class TreeNode85(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode85, self).__init__(text, offset, elements)
        self._ws = elements[3]
        self.block_body = elements[2]
        self._ = elements[4]


class TreeNode86(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode86, self).__init__(text, offset, elements)
        self._ws = elements[1]
        self._ = elements[2]


class TreeNode87(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode87, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.access = elements[2]


class TreeNode88(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode88, self).__init__(text, offset, elements)
        self.if_then = elements[0]


class TreeNode89(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode89, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.unless = elements[1]


class TreeNode90(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode90, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.otherwise = elements[1]


class TreeNode91(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode91, self).__init__(text, offset, elements)
        self._ = elements[9]
        self.basic_name = elements[4]
        self.expression = elements[7]
        self.loop_body = elements[10]


class TreeNode92(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode92, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.expression = elements[3]
        self.loop_body = elements[5]
        self._ws = elements[6]


class TreeNode93(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode93, self).__init__(text, offset, elements)
        self.except_when = elements[0]
        self._ws = elements[1]


class TreeNode94(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode94, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[2]
        self.modifier_tail = elements[3]


class TreeNode95(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode95, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[1]
        self.assign_op = elements[2]
        self._ws = elements[3]
        self.expression = elements[4]


class TreeNode96(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode96, self).__init__(text, offset, elements)
        self.expression = elements[0]
        self._ = elements[1]
        self.eos = elements[2]


class ParseError(SyntaxError):
    pass


FAILURE = object()


class Grammar(object):
    REGEX_1 = re.compile('^[^\\n\\r\\f]')
    REGEX_2 = re.compile('^[^\\n\\r\\f]')
    REGEX_3 = re.compile('^[ \\t]')
    REGEX_4 = re.compile('^[\\n\\r\\f]')
    REGEX_5 = re.compile('^[0-9a-zA-Z_]')
    REGEX_6 = re.compile('^[0-9a-zA-Z_]')
    REGEX_7 = re.compile('^[0-9a-zA-Z_]')
    REGEX_8 = re.compile('^[0-9a-zA-Z_]')
    REGEX_9 = re.compile('^[0-9a-zA-Z_]')
    REGEX_10 = re.compile('^[0-9a-zA-Z_]')
    REGEX_11 = re.compile('^[0-9a-zA-Z_]')
    REGEX_12 = re.compile('^[0-9a-zA-Z_]')
    REGEX_13 = re.compile('^[0-9a-zA-Z_]')
    REGEX_14 = re.compile('^[0-9a-zA-Z_]')
    REGEX_15 = re.compile('^[0-9a-zA-Z_]')
    REGEX_16 = re.compile('^[0-9a-zA-Z_]')
    REGEX_17 = re.compile('^[0-9a-zA-Z_]')
    REGEX_18 = re.compile('^[0-9a-zA-Z_]')
    REGEX_19 = re.compile('^[0-9a-zA-Z_]')
    REGEX_20 = re.compile('^[0-9a-zA-Z_]')
    REGEX_21 = re.compile('^[0-9a-zA-Z_]')
    REGEX_22 = re.compile('^[0-9a-zA-Z_]')
    REGEX_23 = re.compile('^[0-9a-zA-Z_]')
    REGEX_24 = re.compile('^[0-9a-zA-Z_]')
    REGEX_25 = re.compile('^[0-9a-zA-Z_]')
    REGEX_26 = re.compile('^[0-9a-zA-Z_]')
    REGEX_27 = re.compile('^[0-9a-zA-Z_]')
    REGEX_28 = re.compile('^[0-9a-zA-Z_]')
    REGEX_29 = re.compile('^[0-9a-zA-Z_]')
    REGEX_30 = re.compile('^[0-9a-zA-Z_]')
    REGEX_31 = re.compile('^[0-9a-zA-Z_]')
    REGEX_32 = re.compile('^[0-9a-zA-Z_]')
    REGEX_33 = re.compile('^[0-9a-zA-Z_]')
    REGEX_34 = re.compile('^[0-9a-zA-Z_]')
    REGEX_35 = re.compile('^[0-9a-zA-Z_]')
    REGEX_36 = re.compile('^[0-9a-zA-Z_]')
    REGEX_37 = re.compile('^[0-9a-zA-Z_]')
    REGEX_38 = re.compile('^[0-9a-zA-Z_]')
    REGEX_39 = re.compile('^[0-9a-zA-Z_]')
    REGEX_40 = re.compile('^[0-9a-zA-Z_]')
    REGEX_41 = re.compile('^[\\n\\r\\f \\t]')
    REGEX_42 = re.compile('^[\\n\\r\\f]')
    REGEX_43 = re.compile('^[0-9]')
    REGEX_44 = re.compile('^[0-9]')
    REGEX_45 = re.compile('^[0-9]')
    REGEX_46 = re.compile('^[\\\\runftvb\']')
    REGEX_47 = re.compile('^[^\']')
    REGEX_48 = re.compile('^[a-zA-Z_]')
    REGEX_49 = re.compile('^[a-zA-Z_0-9]')
    REGEX_50 = re.compile('^[a-z_A-Z]')

    def _read_start(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['start'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        address1 = self._read_shebang()
        if address1 is FAILURE:
            address1 = TreeNode(self._input[index2:index2], index2, [])
            self._offset = index2
        if address1 is not FAILURE:
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                index4, elements2 = self._offset, []
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    address5 = self._read_statement()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address3 = FAILURE
                else:
                    address3 = TreeNode2(self._input[index4:self._offset], index4, elements2)
                    self._offset = self._offset
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address7 = FAILURE
                index5 = self._offset
                address7 = self._read_stmt_or_expr()
                if address7 is FAILURE:
                    address7 = TreeNode(self._input[index5:index5], index5, [])
                    self._offset = index5
                if address7 is not FAILURE:
                    elements0.append(address7)
                    address8 = FAILURE
                    address8 = self._read__ws()
                    if address8 is not FAILURE:
                        elements0.append(address8)
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.statements(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['start'][index0] = (address0, self._offset)
        return address0

    def _read_shebang(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['shebang'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '#!':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'#!\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index2, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_1.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[^\\n\\r\\f]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index2:self._offset], index2, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['shebang'][index0] = (address0, self._offset)
        return address0

    def _read_comment(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['comment'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '//':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'//\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index2, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_2.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[^\\n\\r\\f]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index2:self._offset], index2, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['comment'][index0] = (address0, self._offset)
        return address0

    def _read__(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['_'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        remaining0, index1, elements0, address1 = 0, self._offset, [], True
        while address1 is not FAILURE:
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 is not None and Grammar.REGEX_3.search(chunk0):
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[ \\t]')
            if address1 is not FAILURE:
                elements0.append(address1)
                remaining0 -= 1
        if remaining0 <= 0:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        else:
            address0 = FAILURE
        self._cache['_'][index0] = (address0, self._offset)
        return address0

    def _read_eol(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['eol'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        remaining0, index2, elements0, address1 = 1, self._offset, [], True
        while address1 is not FAILURE:
            address1 = self._read_comment()
            if address1 is not FAILURE:
                elements0.append(address1)
                remaining0 -= 1
        if remaining0 <= 0:
            address0 = TreeNode(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        else:
            address0 = FAILURE
        if address0 is FAILURE:
            self._offset = index1
            remaining1, index3, elements1, address2 = 1, self._offset, [], True
            while address2 is not FAILURE:
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 is not None and Grammar.REGEX_4.search(chunk0):
                    address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address2 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[\\n\\r\\f]')
                if address2 is not FAILURE:
                    elements1.append(address2)
                    remaining1 -= 1
            if remaining1 <= 0:
                address0 = self._actions.ignore(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            else:
                address0 = FAILURE
            if address0 is FAILURE:
                self._offset = index1
        self._cache['eol'][index0] = (address0, self._offset)
        return address0

    def _read_keyword(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['keyword'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 5
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'leave':
            address1 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
            self._offset = self._offset + 5
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'leave\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            index3 = self._offset
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 is not None and Grammar.REGEX_5.search(chunk1):
                address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[0-9a-zA-Z_]')
            self._offset = index3
            if address2 is FAILURE:
                address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index4, elements1 = self._offset, []
            address3 = FAILURE
            chunk2, max2 = None, self._offset + 5
            if max2 <= self._input_size:
                chunk2 = self._input[self._offset:max2]
            if chunk2 == 'until':
                address3 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                self._offset = self._offset + 5
            else:
                address3 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'until\'')
            if address3 is not FAILURE:
                elements1.append(address3)
                address4 = FAILURE
                index5 = self._offset
                chunk3, max3 = None, self._offset + 1
                if max3 <= self._input_size:
                    chunk3 = self._input[self._offset:max3]
                if chunk3 is not None and Grammar.REGEX_6.search(chunk3):
                    address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address4 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[0-9a-zA-Z_]')
                self._offset = index5
                if address4 is FAILURE:
                    address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address4 = FAILURE
                if address4 is not FAILURE:
                    elements1.append(address4)
                else:
                    elements1 = None
                    self._offset = index4
            else:
                elements1 = None
                self._offset = index4
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode(self._input[index4:self._offset], index4, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index6, elements2 = self._offset, []
                address5 = FAILURE
                chunk4, max4 = None, self._offset + 2
                if max4 <= self._input_size:
                    chunk4 = self._input[self._offset:max4]
                if chunk4 == 'do':
                    address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address5 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'do\'')
                if address5 is not FAILURE:
                    elements2.append(address5)
                    address6 = FAILURE
                    index7 = self._offset
                    chunk5, max5 = None, self._offset + 1
                    if max5 <= self._input_size:
                        chunk5 = self._input[self._offset:max5]
                    if chunk5 is not None and Grammar.REGEX_7.search(chunk5):
                        address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address6 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[0-9a-zA-Z_]')
                    self._offset = index7
                    if address6 is FAILURE:
                        address6 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address6 = FAILURE
                    if address6 is not FAILURE:
                        elements2.append(address6)
                    else:
                        elements2 = None
                        self._offset = index6
                else:
                    elements2 = None
                    self._offset = index6
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = TreeNode(self._input[index6:self._offset], index6, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index8, elements3 = self._offset, []
                    address7 = FAILURE
                    chunk6, max6 = None, self._offset + 6
                    if max6 <= self._input_size:
                        chunk6 = self._input[self._offset:max6]
                    if chunk6 == 'except':
                        address7 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                        self._offset = self._offset + 6
                    else:
                        address7 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'except\'')
                    if address7 is not FAILURE:
                        elements3.append(address7)
                        address8 = FAILURE
                        index9 = self._offset
                        chunk7, max7 = None, self._offset + 1
                        if max7 <= self._input_size:
                            chunk7 = self._input[self._offset:max7]
                        if chunk7 is not None and Grammar.REGEX_8.search(chunk7):
                            address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address8 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('[0-9a-zA-Z_]')
                        self._offset = index9
                        if address8 is FAILURE:
                            address8 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address8 = FAILURE
                        if address8 is not FAILURE:
                            elements3.append(address8)
                        else:
                            elements3 = None
                            self._offset = index8
                    else:
                        elements3 = None
                        self._offset = index8
                    if elements3 is None:
                        address0 = FAILURE
                    else:
                        address0 = TreeNode(self._input[index8:self._offset], index8, elements3)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index10, elements4 = self._offset, []
                        address9 = FAILURE
                        chunk8, max8 = None, self._offset + 3
                        if max8 <= self._input_size:
                            chunk8 = self._input[self._offset:max8]
                        if chunk8 == 'for':
                            address9 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                            self._offset = self._offset + 3
                        else:
                            address9 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'for\'')
                        if address9 is not FAILURE:
                            elements4.append(address9)
                            address10 = FAILURE
                            index11 = self._offset
                            chunk9, max9 = None, self._offset + 1
                            if max9 <= self._input_size:
                                chunk9 = self._input[self._offset:max9]
                            if chunk9 is not None and Grammar.REGEX_9.search(chunk9):
                                address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address10 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('[0-9a-zA-Z_]')
                            self._offset = index11
                            if address10 is FAILURE:
                                address10 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                self._offset = self._offset
                            else:
                                address10 = FAILURE
                            if address10 is not FAILURE:
                                elements4.append(address10)
                            else:
                                elements4 = None
                                self._offset = index10
                        else:
                            elements4 = None
                            self._offset = index10
                        if elements4 is None:
                            address0 = FAILURE
                        else:
                            address0 = TreeNode(self._input[index10:self._offset], index10, elements4)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
                            index12, elements5 = self._offset, []
                            address11 = FAILURE
                            chunk10, max10 = None, self._offset + 5
                            if max10 <= self._input_size:
                                chunk10 = self._input[self._offset:max10]
                            if chunk10 == 'every':
                                address11 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                self._offset = self._offset + 5
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'every\'')
                            if address11 is not FAILURE:
                                elements5.append(address11)
                                address12 = FAILURE
                                index13 = self._offset
                                chunk11, max11 = None, self._offset + 1
                                if max11 <= self._input_size:
                                    chunk11 = self._input[self._offset:max11]
                                if chunk11 is not None and Grammar.REGEX_10.search(chunk11):
                                    address12 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address12 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('[0-9a-zA-Z_]')
                                self._offset = index13
                                if address12 is FAILURE:
                                    address12 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                    self._offset = self._offset
                                else:
                                    address12 = FAILURE
                                if address12 is not FAILURE:
                                    elements5.append(address12)
                                else:
                                    elements5 = None
                                    self._offset = index12
                            else:
                                elements5 = None
                                self._offset = index12
                            if elements5 is None:
                                address0 = FAILURE
                            else:
                                address0 = TreeNode(self._input[index12:self._offset], index12, elements5)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
                                index14, elements6 = self._offset, []
                                address13 = FAILURE
                                chunk12, max12 = None, self._offset + 4
                                if max12 <= self._input_size:
                                    chunk12 = self._input[self._offset:max12]
                                if chunk12 == 'that':
                                    address13 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                    self._offset = self._offset + 4
                                else:
                                    address13 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'that\'')
                                if address13 is not FAILURE:
                                    elements6.append(address13)
                                    address14 = FAILURE
                                    index15 = self._offset
                                    chunk13, max13 = None, self._offset + 1
                                    if max13 <= self._input_size:
                                        chunk13 = self._input[self._offset:max13]
                                    if chunk13 is not None and Grammar.REGEX_11.search(chunk13):
                                        address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address14 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('[0-9a-zA-Z_]')
                                    self._offset = index15
                                    if address14 is FAILURE:
                                        address14 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                        self._offset = self._offset
                                    else:
                                        address14 = FAILURE
                                    if address14 is not FAILURE:
                                        elements6.append(address14)
                                    else:
                                        elements6 = None
                                        self._offset = index14
                                else:
                                    elements6 = None
                                    self._offset = index14
                                if elements6 is None:
                                    address0 = FAILURE
                                else:
                                    address0 = TreeNode(self._input[index14:self._offset], index14, elements6)
                                    self._offset = self._offset
                                if address0 is FAILURE:
                                    self._offset = index1
                                    index16, elements7 = self._offset, []
                                    address15 = FAILURE
                                    chunk14, max14 = None, self._offset + 2
                                    if max14 <= self._input_size:
                                        chunk14 = self._input[self._offset:max14]
                                    if chunk14 == 'at':
                                        address15 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                        self._offset = self._offset + 2
                                    else:
                                        address15 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'at\'')
                                    if address15 is not FAILURE:
                                        elements7.append(address15)
                                        address16 = FAILURE
                                        index17 = self._offset
                                        chunk15, max15 = None, self._offset + 1
                                        if max15 <= self._input_size:
                                            chunk15 = self._input[self._offset:max15]
                                        if chunk15 is not None and Grammar.REGEX_12.search(chunk15):
                                            address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address16 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('[0-9a-zA-Z_]')
                                        self._offset = index17
                                        if address16 is FAILURE:
                                            address16 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                            self._offset = self._offset
                                        else:
                                            address16 = FAILURE
                                        if address16 is not FAILURE:
                                            elements7.append(address16)
                                        else:
                                            elements7 = None
                                            self._offset = index16
                                    else:
                                        elements7 = None
                                        self._offset = index16
                                    if elements7 is None:
                                        address0 = FAILURE
                                    else:
                                        address0 = TreeNode(self._input[index16:self._offset], index16, elements7)
                                        self._offset = self._offset
                                    if address0 is FAILURE:
                                        self._offset = index1
                                        index18, elements8 = self._offset, []
                                        address17 = FAILURE
                                        chunk16, max16 = None, self._offset + 5
                                        if max16 <= self._input_size:
                                            chunk16 = self._input[self._offset:max16]
                                        if chunk16 == 'after':
                                            address17 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                            self._offset = self._offset + 5
                                        else:
                                            address17 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'after\'')
                                        if address17 is not FAILURE:
                                            elements8.append(address17)
                                            address18 = FAILURE
                                            index19 = self._offset
                                            chunk17, max17 = None, self._offset + 1
                                            if max17 <= self._input_size:
                                                chunk17 = self._input[self._offset:max17]
                                            if chunk17 is not None and Grammar.REGEX_13.search(chunk17):
                                                address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                self._offset = self._offset + 1
                                            else:
                                                address18 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('[0-9a-zA-Z_]')
                                            self._offset = index19
                                            if address18 is FAILURE:
                                                address18 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                self._offset = self._offset
                                            else:
                                                address18 = FAILURE
                                            if address18 is not FAILURE:
                                                elements8.append(address18)
                                            else:
                                                elements8 = None
                                                self._offset = index18
                                        else:
                                            elements8 = None
                                            self._offset = index18
                                        if elements8 is None:
                                            address0 = FAILURE
                                        else:
                                            address0 = TreeNode(self._input[index18:self._offset], index18, elements8)
                                            self._offset = self._offset
                                        if address0 is FAILURE:
                                            self._offset = index1
                                            index20, elements9 = self._offset, []
                                            address19 = FAILURE
                                            chunk18, max18 = None, self._offset + 7
                                            if max18 <= self._input_size:
                                                chunk18 = self._input[self._offset:max18]
                                            if chunk18 == 'restart':
                                                address19 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                                self._offset = self._offset + 7
                                            else:
                                                address19 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('\'restart\'')
                                            if address19 is not FAILURE:
                                                elements9.append(address19)
                                                address20 = FAILURE
                                                index21 = self._offset
                                                chunk19, max19 = None, self._offset + 1
                                                if max19 <= self._input_size:
                                                    chunk19 = self._input[self._offset:max19]
                                                if chunk19 is not None and Grammar.REGEX_14.search(chunk19):
                                                    address20 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                    self._offset = self._offset + 1
                                                else:
                                                    address20 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('[0-9a-zA-Z_]')
                                                self._offset = index21
                                                if address20 is FAILURE:
                                                    address20 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                    self._offset = self._offset
                                                else:
                                                    address20 = FAILURE
                                                if address20 is not FAILURE:
                                                    elements9.append(address20)
                                                else:
                                                    elements9 = None
                                                    self._offset = index20
                                            else:
                                                elements9 = None
                                                self._offset = index20
                                            if elements9 is None:
                                                address0 = FAILURE
                                            else:
                                                address0 = TreeNode(self._input[index20:self._offset], index20, elements9)
                                                self._offset = self._offset
                                            if address0 is FAILURE:
                                                self._offset = index1
                                                index22, elements10 = self._offset, []
                                                address21 = FAILURE
                                                chunk20, max20 = None, self._offset + 6
                                                if max20 <= self._input_size:
                                                    chunk20 = self._input[self._offset:max20]
                                                if chunk20 == 'before':
                                                    address21 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                    self._offset = self._offset + 6
                                                else:
                                                    address21 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('\'before\'')
                                                if address21 is not FAILURE:
                                                    elements10.append(address21)
                                                    address22 = FAILURE
                                                    index23 = self._offset
                                                    chunk21, max21 = None, self._offset + 1
                                                    if max21 <= self._input_size:
                                                        chunk21 = self._input[self._offset:max21]
                                                    if chunk21 is not None and Grammar.REGEX_15.search(chunk21):
                                                        address22 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                        self._offset = self._offset + 1
                                                    else:
                                                        address22 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('[0-9a-zA-Z_]')
                                                    self._offset = index23
                                                    if address22 is FAILURE:
                                                        address22 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                        self._offset = self._offset
                                                    else:
                                                        address22 = FAILURE
                                                    if address22 is not FAILURE:
                                                        elements10.append(address22)
                                                    else:
                                                        elements10 = None
                                                        self._offset = index22
                                                else:
                                                    elements10 = None
                                                    self._offset = index22
                                                if elements10 is None:
                                                    address0 = FAILURE
                                                else:
                                                    address0 = TreeNode(self._input[index22:self._offset], index22, elements10)
                                                    self._offset = self._offset
                                                if address0 is FAILURE:
                                                    self._offset = index1
                                                    index24, elements11 = self._offset, []
                                                    address23 = FAILURE
                                                    chunk22, max22 = None, self._offset + 4
                                                    if max22 <= self._input_size:
                                                        chunk22 = self._input[self._offset:max22]
                                                    if chunk22 == 'when':
                                                        address23 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                        self._offset = self._offset + 4
                                                    else:
                                                        address23 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('\'when\'')
                                                    if address23 is not FAILURE:
                                                        elements11.append(address23)
                                                        address24 = FAILURE
                                                        index25 = self._offset
                                                        chunk23, max23 = None, self._offset + 1
                                                        if max23 <= self._input_size:
                                                            chunk23 = self._input[self._offset:max23]
                                                        if chunk23 is not None and Grammar.REGEX_16.search(chunk23):
                                                            address24 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                            self._offset = self._offset + 1
                                                        else:
                                                            address24 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('[0-9a-zA-Z_]')
                                                        self._offset = index25
                                                        if address24 is FAILURE:
                                                            address24 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                            self._offset = self._offset
                                                        else:
                                                            address24 = FAILURE
                                                        if address24 is not FAILURE:
                                                            elements11.append(address24)
                                                        else:
                                                            elements11 = None
                                                            self._offset = index24
                                                    else:
                                                        elements11 = None
                                                        self._offset = index24
                                                    if elements11 is None:
                                                        address0 = FAILURE
                                                    else:
                                                        address0 = TreeNode(self._input[index24:self._offset], index24, elements11)
                                                        self._offset = self._offset
                                                    if address0 is FAILURE:
                                                        self._offset = index1
                                                        index26, elements12 = self._offset, []
                                                        address25 = FAILURE
                                                        chunk24, max24 = None, self._offset + 7
                                                        if max24 <= self._input_size:
                                                            chunk24 = self._input[self._offset:max24]
                                                        if chunk24 == 'attempt':
                                                            address25 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                                            self._offset = self._offset + 7
                                                        else:
                                                            address25 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('\'attempt\'')
                                                        if address25 is not FAILURE:
                                                            elements12.append(address25)
                                                            address26 = FAILURE
                                                            index27 = self._offset
                                                            chunk25, max25 = None, self._offset + 1
                                                            if max25 <= self._input_size:
                                                                chunk25 = self._input[self._offset:max25]
                                                            if chunk25 is not None and Grammar.REGEX_17.search(chunk25):
                                                                address26 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                self._offset = self._offset + 1
                                                            else:
                                                                address26 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                            self._offset = index27
                                                            if address26 is FAILURE:
                                                                address26 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                self._offset = self._offset
                                                            else:
                                                                address26 = FAILURE
                                                            if address26 is not FAILURE:
                                                                elements12.append(address26)
                                                            else:
                                                                elements12 = None
                                                                self._offset = index26
                                                        else:
                                                            elements12 = None
                                                            self._offset = index26
                                                        if elements12 is None:
                                                            address0 = FAILURE
                                                        else:
                                                            address0 = TreeNode(self._input[index26:self._offset], index26, elements12)
                                                            self._offset = self._offset
                                                        if address0 is FAILURE:
                                                            self._offset = index1
                                                            index28, elements13 = self._offset, []
                                                            address27 = FAILURE
                                                            chunk26, max26 = None, self._offset + 3
                                                            if max26 <= self._input_size:
                                                                chunk26 = self._input[self._offset:max26]
                                                            if chunk26 == 'but':
                                                                address27 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                self._offset = self._offset + 3
                                                            else:
                                                                address27 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'but\'')
                                                            if address27 is not FAILURE:
                                                                elements13.append(address27)
                                                                address28 = FAILURE
                                                                index29 = self._offset
                                                                chunk27, max27 = None, self._offset + 1
                                                                if max27 <= self._input_size:
                                                                    chunk27 = self._input[self._offset:max27]
                                                                if chunk27 is not None and Grammar.REGEX_18.search(chunk27):
                                                                    address28 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                    self._offset = self._offset + 1
                                                                else:
                                                                    address28 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                self._offset = index29
                                                                if address28 is FAILURE:
                                                                    address28 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                    self._offset = self._offset
                                                                else:
                                                                    address28 = FAILURE
                                                                if address28 is not FAILURE:
                                                                    elements13.append(address28)
                                                                else:
                                                                    elements13 = None
                                                                    self._offset = index28
                                                            else:
                                                                elements13 = None
                                                                self._offset = index28
                                                            if elements13 is None:
                                                                address0 = FAILURE
                                                            else:
                                                                address0 = TreeNode(self._input[index28:self._offset], index28, elements13)
                                                                self._offset = self._offset
                                                            if address0 is FAILURE:
                                                                self._offset = index1
                                                                index30, elements14 = self._offset, []
                                                                address29 = FAILURE
                                                                chunk28, max28 = None, self._offset + 6
                                                                if max28 <= self._input_size:
                                                                    chunk28 = self._input[self._offset:max28]
                                                                if chunk28 == 'always':
                                                                    address29 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                                    self._offset = self._offset + 6
                                                                else:
                                                                    address29 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('\'always\'')
                                                                if address29 is not FAILURE:
                                                                    elements14.append(address29)
                                                                    address30 = FAILURE
                                                                    index31 = self._offset
                                                                    chunk29, max29 = None, self._offset + 1
                                                                    if max29 <= self._input_size:
                                                                        chunk29 = self._input[self._offset:max29]
                                                                    if chunk29 is not None and Grammar.REGEX_19.search(chunk29):
                                                                        address30 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                        self._offset = self._offset + 1
                                                                    else:
                                                                        address30 = FAILURE
                                                                        if self._offset > self._failure:
                                                                            self._failure = self._offset
                                                                            self._expected = []
                                                                        if self._offset == self._failure:
                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                    self._offset = index31
                                                                    if address30 is FAILURE:
                                                                        address30 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                        self._offset = self._offset
                                                                    else:
                                                                        address30 = FAILURE
                                                                    if address30 is not FAILURE:
                                                                        elements14.append(address30)
                                                                    else:
                                                                        elements14 = None
                                                                        self._offset = index30
                                                                else:
                                                                    elements14 = None
                                                                    self._offset = index30
                                                                if elements14 is None:
                                                                    address0 = FAILURE
                                                                else:
                                                                    address0 = TreeNode(self._input[index30:self._offset], index30, elements14)
                                                                    self._offset = self._offset
                                                                if address0 is FAILURE:
                                                                    self._offset = index1
                                                                    index32, elements15 = self._offset, []
                                                                    address31 = FAILURE
                                                                    chunk30, max30 = None, self._offset + 6
                                                                    if max30 <= self._input_size:
                                                                        chunk30 = self._input[self._offset:max30]
                                                                    if chunk30 == 'occurs':
                                                                        address31 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                                        self._offset = self._offset + 6
                                                                    else:
                                                                        address31 = FAILURE
                                                                        if self._offset > self._failure:
                                                                            self._failure = self._offset
                                                                            self._expected = []
                                                                        if self._offset == self._failure:
                                                                            self._expected.append('\'occurs\'')
                                                                    if address31 is not FAILURE:
                                                                        elements15.append(address31)
                                                                        address32 = FAILURE
                                                                        index33 = self._offset
                                                                        chunk31, max31 = None, self._offset + 1
                                                                        if max31 <= self._input_size:
                                                                            chunk31 = self._input[self._offset:max31]
                                                                        if chunk31 is not None and Grammar.REGEX_20.search(chunk31):
                                                                            address32 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                            self._offset = self._offset + 1
                                                                        else:
                                                                            address32 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                        self._offset = index33
                                                                        if address32 is FAILURE:
                                                                            address32 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                            self._offset = self._offset
                                                                        else:
                                                                            address32 = FAILURE
                                                                        if address32 is not FAILURE:
                                                                            elements15.append(address32)
                                                                        else:
                                                                            elements15 = None
                                                                            self._offset = index32
                                                                    else:
                                                                        elements15 = None
                                                                        self._offset = index32
                                                                    if elements15 is None:
                                                                        address0 = FAILURE
                                                                    else:
                                                                        address0 = TreeNode(self._input[index32:self._offset], index32, elements15)
                                                                        self._offset = self._offset
                                                                    if address0 is FAILURE:
                                                                        self._offset = index1
                                                                        index34, elements16 = self._offset, []
                                                                        address33 = FAILURE
                                                                        chunk32, max32 = None, self._offset + 4
                                                                        if max32 <= self._input_size:
                                                                            chunk32 = self._input[self._offset:max32]
                                                                        if chunk32 == 'oops':
                                                                            address33 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                            self._offset = self._offset + 4
                                                                        else:
                                                                            address33 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('\'oops\'')
                                                                        if address33 is not FAILURE:
                                                                            elements16.append(address33)
                                                                            address34 = FAILURE
                                                                            index35 = self._offset
                                                                            chunk33, max33 = None, self._offset + 1
                                                                            if max33 <= self._input_size:
                                                                                chunk33 = self._input[self._offset:max33]
                                                                            if chunk33 is not None and Grammar.REGEX_21.search(chunk33):
                                                                                address34 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                self._offset = self._offset + 1
                                                                            else:
                                                                                address34 = FAILURE
                                                                                if self._offset > self._failure:
                                                                                    self._failure = self._offset
                                                                                    self._expected = []
                                                                                if self._offset == self._failure:
                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                            self._offset = index35
                                                                            if address34 is FAILURE:
                                                                                address34 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                self._offset = self._offset
                                                                            else:
                                                                                address34 = FAILURE
                                                                            if address34 is not FAILURE:
                                                                                elements16.append(address34)
                                                                            else:
                                                                                elements16 = None
                                                                                self._offset = index34
                                                                        else:
                                                                            elements16 = None
                                                                            self._offset = index34
                                                                        if elements16 is None:
                                                                            address0 = FAILURE
                                                                        else:
                                                                            address0 = TreeNode(self._input[index34:self._offset], index34, elements16)
                                                                            self._offset = self._offset
                                                                        if address0 is FAILURE:
                                                                            self._offset = index1
                                                                            index36, elements17 = self._offset, []
                                                                            address35 = FAILURE
                                                                            chunk34, max34 = None, self._offset + 4
                                                                            if max34 <= self._input_size:
                                                                                chunk34 = self._input[self._offset:max34]
                                                                            if chunk34 == 'load':
                                                                                address35 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                self._offset = self._offset + 4
                                                                            else:
                                                                                address35 = FAILURE
                                                                                if self._offset > self._failure:
                                                                                    self._failure = self._offset
                                                                                    self._expected = []
                                                                                if self._offset == self._failure:
                                                                                    self._expected.append('\'load\'')
                                                                            if address35 is not FAILURE:
                                                                                elements17.append(address35)
                                                                                address36 = FAILURE
                                                                                index37 = self._offset
                                                                                chunk35, max35 = None, self._offset + 1
                                                                                if max35 <= self._input_size:
                                                                                    chunk35 = self._input[self._offset:max35]
                                                                                if chunk35 is not None and Grammar.REGEX_22.search(chunk35):
                                                                                    address36 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                    self._offset = self._offset + 1
                                                                                else:
                                                                                    address36 = FAILURE
                                                                                    if self._offset > self._failure:
                                                                                        self._failure = self._offset
                                                                                        self._expected = []
                                                                                    if self._offset == self._failure:
                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                self._offset = index37
                                                                                if address36 is FAILURE:
                                                                                    address36 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                    self._offset = self._offset
                                                                                else:
                                                                                    address36 = FAILURE
                                                                                if address36 is not FAILURE:
                                                                                    elements17.append(address36)
                                                                                else:
                                                                                    elements17 = None
                                                                                    self._offset = index36
                                                                            else:
                                                                                elements17 = None
                                                                                self._offset = index36
                                                                            if elements17 is None:
                                                                                address0 = FAILURE
                                                                            else:
                                                                                address0 = TreeNode(self._input[index36:self._offset], index36, elements17)
                                                                                self._offset = self._offset
                                                                            if address0 is FAILURE:
                                                                                self._offset = index1
                                                                                index38, elements18 = self._offset, []
                                                                                address37 = FAILURE
                                                                                chunk36, max36 = None, self._offset + 4
                                                                                if max36 <= self._input_size:
                                                                                    chunk36 = self._input[self._offset:max36]
                                                                                if chunk36 == 'from':
                                                                                    address37 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                    self._offset = self._offset + 4
                                                                                else:
                                                                                    address37 = FAILURE
                                                                                    if self._offset > self._failure:
                                                                                        self._failure = self._offset
                                                                                        self._expected = []
                                                                                    if self._offset == self._failure:
                                                                                        self._expected.append('\'from\'')
                                                                                if address37 is not FAILURE:
                                                                                    elements18.append(address37)
                                                                                    address38 = FAILURE
                                                                                    index39 = self._offset
                                                                                    chunk37, max37 = None, self._offset + 1
                                                                                    if max37 <= self._input_size:
                                                                                        chunk37 = self._input[self._offset:max37]
                                                                                    if chunk37 is not None and Grammar.REGEX_23.search(chunk37):
                                                                                        address38 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                        self._offset = self._offset + 1
                                                                                    else:
                                                                                        address38 = FAILURE
                                                                                        if self._offset > self._failure:
                                                                                            self._failure = self._offset
                                                                                            self._expected = []
                                                                                        if self._offset == self._failure:
                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                    self._offset = index39
                                                                                    if address38 is FAILURE:
                                                                                        address38 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                        self._offset = self._offset
                                                                                    else:
                                                                                        address38 = FAILURE
                                                                                    if address38 is not FAILURE:
                                                                                        elements18.append(address38)
                                                                                    else:
                                                                                        elements18 = None
                                                                                        self._offset = index38
                                                                                else:
                                                                                    elements18 = None
                                                                                    self._offset = index38
                                                                                if elements18 is None:
                                                                                    address0 = FAILURE
                                                                                else:
                                                                                    address0 = TreeNode(self._input[index38:self._offset], index38, elements18)
                                                                                    self._offset = self._offset
                                                                                if address0 is FAILURE:
                                                                                    self._offset = index1
                                                                                    index40, elements19 = self._offset, []
                                                                                    address39 = FAILURE
                                                                                    chunk38, max38 = None, self._offset + 4
                                                                                    if max38 <= self._input_size:
                                                                                        chunk38 = self._input[self._offset:max38]
                                                                                    if chunk38 == 'into':
                                                                                        address39 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                        self._offset = self._offset + 4
                                                                                    else:
                                                                                        address39 = FAILURE
                                                                                        if self._offset > self._failure:
                                                                                            self._failure = self._offset
                                                                                            self._expected = []
                                                                                        if self._offset == self._failure:
                                                                                            self._expected.append('\'into\'')
                                                                                    if address39 is not FAILURE:
                                                                                        elements19.append(address39)
                                                                                        address40 = FAILURE
                                                                                        index41 = self._offset
                                                                                        chunk39, max39 = None, self._offset + 1
                                                                                        if max39 <= self._input_size:
                                                                                            chunk39 = self._input[self._offset:max39]
                                                                                        if chunk39 is not None and Grammar.REGEX_24.search(chunk39):
                                                                                            address40 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                            self._offset = self._offset + 1
                                                                                        else:
                                                                                            address40 = FAILURE
                                                                                            if self._offset > self._failure:
                                                                                                self._failure = self._offset
                                                                                                self._expected = []
                                                                                            if self._offset == self._failure:
                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                        self._offset = index41
                                                                                        if address40 is FAILURE:
                                                                                            address40 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                            self._offset = self._offset
                                                                                        else:
                                                                                            address40 = FAILURE
                                                                                        if address40 is not FAILURE:
                                                                                            elements19.append(address40)
                                                                                        else:
                                                                                            elements19 = None
                                                                                            self._offset = index40
                                                                                    else:
                                                                                        elements19 = None
                                                                                        self._offset = index40
                                                                                    if elements19 is None:
                                                                                        address0 = FAILURE
                                                                                    else:
                                                                                        address0 = TreeNode(self._input[index40:self._offset], index40, elements19)
                                                                                        self._offset = self._offset
                                                                                    if address0 is FAILURE:
                                                                                        self._offset = index1
                                                                                        index42, elements20 = self._offset, []
                                                                                        address41 = FAILURE
                                                                                        chunk40, max40 = None, self._offset + 3
                                                                                        if max40 <= self._input_size:
                                                                                            chunk40 = self._input[self._offset:max40]
                                                                                        if chunk40 == 'use':
                                                                                            address41 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                            self._offset = self._offset + 3
                                                                                        else:
                                                                                            address41 = FAILURE
                                                                                            if self._offset > self._failure:
                                                                                                self._failure = self._offset
                                                                                                self._expected = []
                                                                                            if self._offset == self._failure:
                                                                                                self._expected.append('\'use\'')
                                                                                        if address41 is not FAILURE:
                                                                                            elements20.append(address41)
                                                                                            address42 = FAILURE
                                                                                            index43 = self._offset
                                                                                            chunk41, max41 = None, self._offset + 1
                                                                                            if max41 <= self._input_size:
                                                                                                chunk41 = self._input[self._offset:max41]
                                                                                            if chunk41 is not None and Grammar.REGEX_25.search(chunk41):
                                                                                                address42 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                self._offset = self._offset + 1
                                                                                            else:
                                                                                                address42 = FAILURE
                                                                                                if self._offset > self._failure:
                                                                                                    self._failure = self._offset
                                                                                                    self._expected = []
                                                                                                if self._offset == self._failure:
                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                            self._offset = index43
                                                                                            if address42 is FAILURE:
                                                                                                address42 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                self._offset = self._offset
                                                                                            else:
                                                                                                address42 = FAILURE
                                                                                            if address42 is not FAILURE:
                                                                                                elements20.append(address42)
                                                                                            else:
                                                                                                elements20 = None
                                                                                                self._offset = index42
                                                                                        else:
                                                                                            elements20 = None
                                                                                            self._offset = index42
                                                                                        if elements20 is None:
                                                                                            address0 = FAILURE
                                                                                        else:
                                                                                            address0 = TreeNode(self._input[index42:self._offset], index42, elements20)
                                                                                            self._offset = self._offset
                                                                                        if address0 is FAILURE:
                                                                                            self._offset = index1
                                                                                            index44, elements21 = self._offset, []
                                                                                            address43 = FAILURE
                                                                                            chunk42, max42 = None, self._offset + 2
                                                                                            if max42 <= self._input_size:
                                                                                                chunk42 = self._input[self._offset:max42]
                                                                                            if chunk42 == 'if':
                                                                                                address43 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                                                self._offset = self._offset + 2
                                                                                            else:
                                                                                                address43 = FAILURE
                                                                                                if self._offset > self._failure:
                                                                                                    self._failure = self._offset
                                                                                                    self._expected = []
                                                                                                if self._offset == self._failure:
                                                                                                    self._expected.append('\'if\'')
                                                                                            if address43 is not FAILURE:
                                                                                                elements21.append(address43)
                                                                                                address44 = FAILURE
                                                                                                index45 = self._offset
                                                                                                chunk43, max43 = None, self._offset + 1
                                                                                                if max43 <= self._input_size:
                                                                                                    chunk43 = self._input[self._offset:max43]
                                                                                                if chunk43 is not None and Grammar.REGEX_26.search(chunk43):
                                                                                                    address44 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                    self._offset = self._offset + 1
                                                                                                else:
                                                                                                    address44 = FAILURE
                                                                                                    if self._offset > self._failure:
                                                                                                        self._failure = self._offset
                                                                                                        self._expected = []
                                                                                                    if self._offset == self._failure:
                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                self._offset = index45
                                                                                                if address44 is FAILURE:
                                                                                                    address44 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                    self._offset = self._offset
                                                                                                else:
                                                                                                    address44 = FAILURE
                                                                                                if address44 is not FAILURE:
                                                                                                    elements21.append(address44)
                                                                                                else:
                                                                                                    elements21 = None
                                                                                                    self._offset = index44
                                                                                            else:
                                                                                                elements21 = None
                                                                                                self._offset = index44
                                                                                            if elements21 is None:
                                                                                                address0 = FAILURE
                                                                                            else:
                                                                                                address0 = TreeNode(self._input[index44:self._offset], index44, elements21)
                                                                                                self._offset = self._offset
                                                                                            if address0 is FAILURE:
                                                                                                self._offset = index1
                                                                                                index46, elements22 = self._offset, []
                                                                                                address45 = FAILURE
                                                                                                chunk44, max44 = None, self._offset + 4
                                                                                                if max44 <= self._input_size:
                                                                                                    chunk44 = self._input[self._offset:max44]
                                                                                                if chunk44 == 'then':
                                                                                                    address45 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                                    self._offset = self._offset + 4
                                                                                                else:
                                                                                                    address45 = FAILURE
                                                                                                    if self._offset > self._failure:
                                                                                                        self._failure = self._offset
                                                                                                        self._expected = []
                                                                                                    if self._offset == self._failure:
                                                                                                        self._expected.append('\'then\'')
                                                                                                if address45 is not FAILURE:
                                                                                                    elements22.append(address45)
                                                                                                    address46 = FAILURE
                                                                                                    index47 = self._offset
                                                                                                    chunk45, max45 = None, self._offset + 1
                                                                                                    if max45 <= self._input_size:
                                                                                                        chunk45 = self._input[self._offset:max45]
                                                                                                    if chunk45 is not None and Grammar.REGEX_27.search(chunk45):
                                                                                                        address46 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                        self._offset = self._offset + 1
                                                                                                    else:
                                                                                                        address46 = FAILURE
                                                                                                        if self._offset > self._failure:
                                                                                                            self._failure = self._offset
                                                                                                            self._expected = []
                                                                                                        if self._offset == self._failure:
                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                    self._offset = index47
                                                                                                    if address46 is FAILURE:
                                                                                                        address46 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                        self._offset = self._offset
                                                                                                    else:
                                                                                                        address46 = FAILURE
                                                                                                    if address46 is not FAILURE:
                                                                                                        elements22.append(address46)
                                                                                                    else:
                                                                                                        elements22 = None
                                                                                                        self._offset = index46
                                                                                                else:
                                                                                                    elements22 = None
                                                                                                    self._offset = index46
                                                                                                if elements22 is None:
                                                                                                    address0 = FAILURE
                                                                                                else:
                                                                                                    address0 = TreeNode(self._input[index46:self._offset], index46, elements22)
                                                                                                    self._offset = self._offset
                                                                                                if address0 is FAILURE:
                                                                                                    self._offset = index1
                                                                                                    index48, elements23 = self._offset, []
                                                                                                    address47 = FAILURE
                                                                                                    chunk46, max46 = None, self._offset + 3
                                                                                                    if max46 <= self._input_size:
                                                                                                        chunk46 = self._input[self._offset:max46]
                                                                                                    if chunk46 == 'and':
                                                                                                        address47 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                        self._offset = self._offset + 3
                                                                                                    else:
                                                                                                        address47 = FAILURE
                                                                                                        if self._offset > self._failure:
                                                                                                            self._failure = self._offset
                                                                                                            self._expected = []
                                                                                                        if self._offset == self._failure:
                                                                                                            self._expected.append('\'and\'')
                                                                                                    if address47 is not FAILURE:
                                                                                                        elements23.append(address47)
                                                                                                        address48 = FAILURE
                                                                                                        index49 = self._offset
                                                                                                        chunk47, max47 = None, self._offset + 1
                                                                                                        if max47 <= self._input_size:
                                                                                                            chunk47 = self._input[self._offset:max47]
                                                                                                        if chunk47 is not None and Grammar.REGEX_28.search(chunk47):
                                                                                                            address48 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                            self._offset = self._offset + 1
                                                                                                        else:
                                                                                                            address48 = FAILURE
                                                                                                            if self._offset > self._failure:
                                                                                                                self._failure = self._offset
                                                                                                                self._expected = []
                                                                                                            if self._offset == self._failure:
                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                        self._offset = index49
                                                                                                        if address48 is FAILURE:
                                                                                                            address48 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                            self._offset = self._offset
                                                                                                        else:
                                                                                                            address48 = FAILURE
                                                                                                        if address48 is not FAILURE:
                                                                                                            elements23.append(address48)
                                                                                                        else:
                                                                                                            elements23 = None
                                                                                                            self._offset = index48
                                                                                                    else:
                                                                                                        elements23 = None
                                                                                                        self._offset = index48
                                                                                                    if elements23 is None:
                                                                                                        address0 = FAILURE
                                                                                                    else:
                                                                                                        address0 = TreeNode(self._input[index48:self._offset], index48, elements23)
                                                                                                        self._offset = self._offset
                                                                                                    if address0 is FAILURE:
                                                                                                        self._offset = index1
                                                                                                        index50, elements24 = self._offset, []
                                                                                                        address49 = FAILURE
                                                                                                        chunk48, max48 = None, self._offset + 2
                                                                                                        if max48 <= self._input_size:
                                                                                                            chunk48 = self._input[self._offset:max48]
                                                                                                        if chunk48 == 'or':
                                                                                                            address49 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                                                            self._offset = self._offset + 2
                                                                                                        else:
                                                                                                            address49 = FAILURE
                                                                                                            if self._offset > self._failure:
                                                                                                                self._failure = self._offset
                                                                                                                self._expected = []
                                                                                                            if self._offset == self._failure:
                                                                                                                self._expected.append('\'or\'')
                                                                                                        if address49 is not FAILURE:
                                                                                                            elements24.append(address49)
                                                                                                            address50 = FAILURE
                                                                                                            index51 = self._offset
                                                                                                            chunk49, max49 = None, self._offset + 1
                                                                                                            if max49 <= self._input_size:
                                                                                                                chunk49 = self._input[self._offset:max49]
                                                                                                            if chunk49 is not None and Grammar.REGEX_29.search(chunk49):
                                                                                                                address50 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                self._offset = self._offset + 1
                                                                                                            else:
                                                                                                                address50 = FAILURE
                                                                                                                if self._offset > self._failure:
                                                                                                                    self._failure = self._offset
                                                                                                                    self._expected = []
                                                                                                                if self._offset == self._failure:
                                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                                            self._offset = index51
                                                                                                            if address50 is FAILURE:
                                                                                                                address50 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                self._offset = self._offset
                                                                                                            else:
                                                                                                                address50 = FAILURE
                                                                                                            if address50 is not FAILURE:
                                                                                                                elements24.append(address50)
                                                                                                            else:
                                                                                                                elements24 = None
                                                                                                                self._offset = index50
                                                                                                        else:
                                                                                                            elements24 = None
                                                                                                            self._offset = index50
                                                                                                        if elements24 is None:
                                                                                                            address0 = FAILURE
                                                                                                        else:
                                                                                                            address0 = TreeNode(self._input[index50:self._offset], index50, elements24)
                                                                                                            self._offset = self._offset
                                                                                                        if address0 is FAILURE:
                                                                                                            self._offset = index1
                                                                                                            index52, elements25 = self._offset, []
                                                                                                            address51 = FAILURE
                                                                                                            chunk50, max50 = None, self._offset + 3
                                                                                                            if max50 <= self._input_size:
                                                                                                                chunk50 = self._input[self._offset:max50]
                                                                                                            if chunk50 == 'not':
                                                                                                                address51 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                self._offset = self._offset + 3
                                                                                                            else:
                                                                                                                address51 = FAILURE
                                                                                                                if self._offset > self._failure:
                                                                                                                    self._failure = self._offset
                                                                                                                    self._expected = []
                                                                                                                if self._offset == self._failure:
                                                                                                                    self._expected.append('\'not\'')
                                                                                                            if address51 is not FAILURE:
                                                                                                                elements25.append(address51)
                                                                                                                address52 = FAILURE
                                                                                                                index53 = self._offset
                                                                                                                chunk51, max51 = None, self._offset + 1
                                                                                                                if max51 <= self._input_size:
                                                                                                                    chunk51 = self._input[self._offset:max51]
                                                                                                                if chunk51 is not None and Grammar.REGEX_30.search(chunk51):
                                                                                                                    address52 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                    self._offset = self._offset + 1
                                                                                                                else:
                                                                                                                    address52 = FAILURE
                                                                                                                    if self._offset > self._failure:
                                                                                                                        self._failure = self._offset
                                                                                                                        self._expected = []
                                                                                                                    if self._offset == self._failure:
                                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                                self._offset = index53
                                                                                                                if address52 is FAILURE:
                                                                                                                    address52 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                    self._offset = self._offset
                                                                                                                else:
                                                                                                                    address52 = FAILURE
                                                                                                                if address52 is not FAILURE:
                                                                                                                    elements25.append(address52)
                                                                                                                else:
                                                                                                                    elements25 = None
                                                                                                                    self._offset = index52
                                                                                                            else:
                                                                                                                elements25 = None
                                                                                                                self._offset = index52
                                                                                                            if elements25 is None:
                                                                                                                address0 = FAILURE
                                                                                                            else:
                                                                                                                address0 = TreeNode(self._input[index52:self._offset], index52, elements25)
                                                                                                                self._offset = self._offset
                                                                                                            if address0 is FAILURE:
                                                                                                                self._offset = index1
                                                                                                                index54, elements26 = self._offset, []
                                                                                                                address53 = FAILURE
                                                                                                                chunk52, max52 = None, self._offset + 3
                                                                                                                if max52 <= self._input_size:
                                                                                                                    chunk52 = self._input[self._offset:max52]
                                                                                                                if chunk52 == 'has':
                                                                                                                    address53 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                    self._offset = self._offset + 3
                                                                                                                else:
                                                                                                                    address53 = FAILURE
                                                                                                                    if self._offset > self._failure:
                                                                                                                        self._failure = self._offset
                                                                                                                        self._expected = []
                                                                                                                    if self._offset == self._failure:
                                                                                                                        self._expected.append('\'has\'')
                                                                                                                if address53 is not FAILURE:
                                                                                                                    elements26.append(address53)
                                                                                                                    address54 = FAILURE
                                                                                                                    index55 = self._offset
                                                                                                                    chunk53, max53 = None, self._offset + 1
                                                                                                                    if max53 <= self._input_size:
                                                                                                                        chunk53 = self._input[self._offset:max53]
                                                                                                                    if chunk53 is not None and Grammar.REGEX_31.search(chunk53):
                                                                                                                        address54 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                        self._offset = self._offset + 1
                                                                                                                    else:
                                                                                                                        address54 = FAILURE
                                                                                                                        if self._offset > self._failure:
                                                                                                                            self._failure = self._offset
                                                                                                                            self._expected = []
                                                                                                                        if self._offset == self._failure:
                                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                                    self._offset = index55
                                                                                                                    if address54 is FAILURE:
                                                                                                                        address54 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                        self._offset = self._offset
                                                                                                                    else:
                                                                                                                        address54 = FAILURE
                                                                                                                    if address54 is not FAILURE:
                                                                                                                        elements26.append(address54)
                                                                                                                    else:
                                                                                                                        elements26 = None
                                                                                                                        self._offset = index54
                                                                                                                else:
                                                                                                                    elements26 = None
                                                                                                                    self._offset = index54
                                                                                                                if elements26 is None:
                                                                                                                    address0 = FAILURE
                                                                                                                else:
                                                                                                                    address0 = TreeNode(self._input[index54:self._offset], index54, elements26)
                                                                                                                    self._offset = self._offset
                                                                                                                if address0 is FAILURE:
                                                                                                                    self._offset = index1
                                                                                                                    index56, elements27 = self._offset, []
                                                                                                                    address55 = FAILURE
                                                                                                                    chunk54, max54 = None, self._offset + 9
                                                                                                                    if max54 <= self._input_size:
                                                                                                                        chunk54 = self._input[self._offset:max54]
                                                                                                                    if chunk54 == 'otherwise':
                                                                                                                        address55 = TreeNode(self._input[self._offset:self._offset + 9], self._offset, [])
                                                                                                                        self._offset = self._offset + 9
                                                                                                                    else:
                                                                                                                        address55 = FAILURE
                                                                                                                        if self._offset > self._failure:
                                                                                                                            self._failure = self._offset
                                                                                                                            self._expected = []
                                                                                                                        if self._offset == self._failure:
                                                                                                                            self._expected.append('\'otherwise\'')
                                                                                                                    if address55 is not FAILURE:
                                                                                                                        elements27.append(address55)
                                                                                                                        address56 = FAILURE
                                                                                                                        index57 = self._offset
                                                                                                                        chunk55, max55 = None, self._offset + 1
                                                                                                                        if max55 <= self._input_size:
                                                                                                                            chunk55 = self._input[self._offset:max55]
                                                                                                                        if chunk55 is not None and Grammar.REGEX_32.search(chunk55):
                                                                                                                            address56 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                            self._offset = self._offset + 1
                                                                                                                        else:
                                                                                                                            address56 = FAILURE
                                                                                                                            if self._offset > self._failure:
                                                                                                                                self._failure = self._offset
                                                                                                                                self._expected = []
                                                                                                                            if self._offset == self._failure:
                                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                                        self._offset = index57
                                                                                                                        if address56 is FAILURE:
                                                                                                                            address56 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                            self._offset = self._offset
                                                                                                                        else:
                                                                                                                            address56 = FAILURE
                                                                                                                        if address56 is not FAILURE:
                                                                                                                            elements27.append(address56)
                                                                                                                        else:
                                                                                                                            elements27 = None
                                                                                                                            self._offset = index56
                                                                                                                    else:
                                                                                                                        elements27 = None
                                                                                                                        self._offset = index56
                                                                                                                    if elements27 is None:
                                                                                                                        address0 = FAILURE
                                                                                                                    else:
                                                                                                                        address0 = TreeNode(self._input[index56:self._offset], index56, elements27)
                                                                                                                        self._offset = self._offset
                                                                                                                    if address0 is FAILURE:
                                                                                                                        self._offset = index1
                                                                                                                        index58, elements28 = self._offset, []
                                                                                                                        address57 = FAILURE
                                                                                                                        chunk56, max56 = None, self._offset + 6
                                                                                                                        if max56 <= self._input_size:
                                                                                                                            chunk56 = self._input[self._offset:max56]
                                                                                                                        if chunk56 == 'unless':
                                                                                                                            address57 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                                                                                            self._offset = self._offset + 6
                                                                                                                        else:
                                                                                                                            address57 = FAILURE
                                                                                                                            if self._offset > self._failure:
                                                                                                                                self._failure = self._offset
                                                                                                                                self._expected = []
                                                                                                                            if self._offset == self._failure:
                                                                                                                                self._expected.append('\'unless\'')
                                                                                                                        if address57 is not FAILURE:
                                                                                                                            elements28.append(address57)
                                                                                                                            address58 = FAILURE
                                                                                                                            index59 = self._offset
                                                                                                                            chunk57, max57 = None, self._offset + 1
                                                                                                                            if max57 <= self._input_size:
                                                                                                                                chunk57 = self._input[self._offset:max57]
                                                                                                                            if chunk57 is not None and Grammar.REGEX_33.search(chunk57):
                                                                                                                                address58 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                self._offset = self._offset + 1
                                                                                                                            else:
                                                                                                                                address58 = FAILURE
                                                                                                                                if self._offset > self._failure:
                                                                                                                                    self._failure = self._offset
                                                                                                                                    self._expected = []
                                                                                                                                if self._offset == self._failure:
                                                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                                                            self._offset = index59
                                                                                                                            if address58 is FAILURE:
                                                                                                                                address58 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                self._offset = self._offset
                                                                                                                            else:
                                                                                                                                address58 = FAILURE
                                                                                                                            if address58 is not FAILURE:
                                                                                                                                elements28.append(address58)
                                                                                                                            else:
                                                                                                                                elements28 = None
                                                                                                                                self._offset = index58
                                                                                                                        else:
                                                                                                                            elements28 = None
                                                                                                                            self._offset = index58
                                                                                                                        if elements28 is None:
                                                                                                                            address0 = FAILURE
                                                                                                                        else:
                                                                                                                            address0 = TreeNode(self._input[index58:self._offset], index58, elements28)
                                                                                                                            self._offset = self._offset
                                                                                                                        if address0 is FAILURE:
                                                                                                                            self._offset = index1
                                                                                                                            index60, elements29 = self._offset, []
                                                                                                                            address59 = FAILURE
                                                                                                                            chunk58, max58 = None, self._offset + 3
                                                                                                                            if max58 <= self._input_size:
                                                                                                                                chunk58 = self._input[self._offset:max58]
                                                                                                                            if chunk58 == 'and':
                                                                                                                                address59 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                self._offset = self._offset + 3
                                                                                                                            else:
                                                                                                                                address59 = FAILURE
                                                                                                                                if self._offset > self._failure:
                                                                                                                                    self._failure = self._offset
                                                                                                                                    self._expected = []
                                                                                                                                if self._offset == self._failure:
                                                                                                                                    self._expected.append('\'and\'')
                                                                                                                            if address59 is not FAILURE:
                                                                                                                                elements29.append(address59)
                                                                                                                                address60 = FAILURE
                                                                                                                                index61 = self._offset
                                                                                                                                chunk59, max59 = None, self._offset + 1
                                                                                                                                if max59 <= self._input_size:
                                                                                                                                    chunk59 = self._input[self._offset:max59]
                                                                                                                                if chunk59 is not None and Grammar.REGEX_34.search(chunk59):
                                                                                                                                    address60 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                    self._offset = self._offset + 1
                                                                                                                                else:
                                                                                                                                    address60 = FAILURE
                                                                                                                                    if self._offset > self._failure:
                                                                                                                                        self._failure = self._offset
                                                                                                                                        self._expected = []
                                                                                                                                    if self._offset == self._failure:
                                                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                self._offset = index61
                                                                                                                                if address60 is FAILURE:
                                                                                                                                    address60 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                    self._offset = self._offset
                                                                                                                                else:
                                                                                                                                    address60 = FAILURE
                                                                                                                                if address60 is not FAILURE:
                                                                                                                                    elements29.append(address60)
                                                                                                                                else:
                                                                                                                                    elements29 = None
                                                                                                                                    self._offset = index60
                                                                                                                            else:
                                                                                                                                elements29 = None
                                                                                                                                self._offset = index60
                                                                                                                            if elements29 is None:
                                                                                                                                address0 = FAILURE
                                                                                                                            else:
                                                                                                                                address0 = TreeNode(self._input[index60:self._offset], index60, elements29)
                                                                                                                                self._offset = self._offset
                                                                                                                            if address0 is FAILURE:
                                                                                                                                self._offset = index1
                                                                                                                                index62, elements30 = self._offset, []
                                                                                                                                address61 = FAILURE
                                                                                                                                chunk60, max60 = None, self._offset + 3
                                                                                                                                if max60 <= self._input_size:
                                                                                                                                    chunk60 = self._input[self._offset:max60]
                                                                                                                                if chunk60 == 'has':
                                                                                                                                    address61 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                    self._offset = self._offset + 3
                                                                                                                                else:
                                                                                                                                    address61 = FAILURE
                                                                                                                                    if self._offset > self._failure:
                                                                                                                                        self._failure = self._offset
                                                                                                                                        self._expected = []
                                                                                                                                    if self._offset == self._failure:
                                                                                                                                        self._expected.append('\'has\'')
                                                                                                                                if address61 is not FAILURE:
                                                                                                                                    elements30.append(address61)
                                                                                                                                    address62 = FAILURE
                                                                                                                                    index63 = self._offset
                                                                                                                                    chunk61, max61 = None, self._offset + 1
                                                                                                                                    if max61 <= self._input_size:
                                                                                                                                        chunk61 = self._input[self._offset:max61]
                                                                                                                                    if chunk61 is not None and Grammar.REGEX_35.search(chunk61):
                                                                                                                                        address62 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                        self._offset = self._offset + 1
                                                                                                                                    else:
                                                                                                                                        address62 = FAILURE
                                                                                                                                        if self._offset > self._failure:
                                                                                                                                            self._failure = self._offset
                                                                                                                                            self._expected = []
                                                                                                                                        if self._offset == self._failure:
                                                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                    self._offset = index63
                                                                                                                                    if address62 is FAILURE:
                                                                                                                                        address62 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                        self._offset = self._offset
                                                                                                                                    else:
                                                                                                                                        address62 = FAILURE
                                                                                                                                    if address62 is not FAILURE:
                                                                                                                                        elements30.append(address62)
                                                                                                                                    else:
                                                                                                                                        elements30 = None
                                                                                                                                        self._offset = index62
                                                                                                                                else:
                                                                                                                                    elements30 = None
                                                                                                                                    self._offset = index62
                                                                                                                                if elements30 is None:
                                                                                                                                    address0 = FAILURE
                                                                                                                                else:
                                                                                                                                    address0 = TreeNode(self._input[index62:self._offset], index62, elements30)
                                                                                                                                    self._offset = self._offset
                                                                                                                                if address0 is FAILURE:
                                                                                                                                    self._offset = index1
                                                                                                                                    index64, elements31 = self._offset, []
                                                                                                                                    address63 = FAILURE
                                                                                                                                    chunk62, max62 = None, self._offset + 3
                                                                                                                                    if max62 <= self._input_size:
                                                                                                                                        chunk62 = self._input[self._offset:max62]
                                                                                                                                    if chunk62 == 'not':
                                                                                                                                        address63 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                        self._offset = self._offset + 3
                                                                                                                                    else:
                                                                                                                                        address63 = FAILURE
                                                                                                                                        if self._offset > self._failure:
                                                                                                                                            self._failure = self._offset
                                                                                                                                            self._expected = []
                                                                                                                                        if self._offset == self._failure:
                                                                                                                                            self._expected.append('\'not\'')
                                                                                                                                    if address63 is not FAILURE:
                                                                                                                                        elements31.append(address63)
                                                                                                                                        address64 = FAILURE
                                                                                                                                        index65 = self._offset
                                                                                                                                        chunk63, max63 = None, self._offset + 1
                                                                                                                                        if max63 <= self._input_size:
                                                                                                                                            chunk63 = self._input[self._offset:max63]
                                                                                                                                        if chunk63 is not None and Grammar.REGEX_36.search(chunk63):
                                                                                                                                            address64 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                            self._offset = self._offset + 1
                                                                                                                                        else:
                                                                                                                                            address64 = FAILURE
                                                                                                                                            if self._offset > self._failure:
                                                                                                                                                self._failure = self._offset
                                                                                                                                                self._expected = []
                                                                                                                                            if self._offset == self._failure:
                                                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                        self._offset = index65
                                                                                                                                        if address64 is FAILURE:
                                                                                                                                            address64 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                            self._offset = self._offset
                                                                                                                                        else:
                                                                                                                                            address64 = FAILURE
                                                                                                                                        if address64 is not FAILURE:
                                                                                                                                            elements31.append(address64)
                                                                                                                                        else:
                                                                                                                                            elements31 = None
                                                                                                                                            self._offset = index64
                                                                                                                                    else:
                                                                                                                                        elements31 = None
                                                                                                                                        self._offset = index64
                                                                                                                                    if elements31 is None:
                                                                                                                                        address0 = FAILURE
                                                                                                                                    else:
                                                                                                                                        address0 = TreeNode(self._input[index64:self._offset], index64, elements31)
                                                                                                                                        self._offset = self._offset
                                                                                                                                    if address0 is FAILURE:
                                                                                                                                        self._offset = index1
                                                                                                                                        index66, elements32 = self._offset, []
                                                                                                                                        address65 = FAILURE
                                                                                                                                        chunk64, max64 = None, self._offset + 2
                                                                                                                                        if max64 <= self._input_size:
                                                                                                                                            chunk64 = self._input[self._offset:max64]
                                                                                                                                        if chunk64 == 'or':
                                                                                                                                            address65 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                                                                                            self._offset = self._offset + 2
                                                                                                                                        else:
                                                                                                                                            address65 = FAILURE
                                                                                                                                            if self._offset > self._failure:
                                                                                                                                                self._failure = self._offset
                                                                                                                                                self._expected = []
                                                                                                                                            if self._offset == self._failure:
                                                                                                                                                self._expected.append('\'or\'')
                                                                                                                                        if address65 is not FAILURE:
                                                                                                                                            elements32.append(address65)
                                                                                                                                            address66 = FAILURE
                                                                                                                                            index67 = self._offset
                                                                                                                                            chunk65, max65 = None, self._offset + 1
                                                                                                                                            if max65 <= self._input_size:
                                                                                                                                                chunk65 = self._input[self._offset:max65]
                                                                                                                                            if chunk65 is not None and Grammar.REGEX_37.search(chunk65):
                                                                                                                                                address66 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                self._offset = self._offset + 1
                                                                                                                                            else:
                                                                                                                                                address66 = FAILURE
                                                                                                                                                if self._offset > self._failure:
                                                                                                                                                    self._failure = self._offset
                                                                                                                                                    self._expected = []
                                                                                                                                                if self._offset == self._failure:
                                                                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                            self._offset = index67
                                                                                                                                            if address66 is FAILURE:
                                                                                                                                                address66 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                self._offset = self._offset
                                                                                                                                            else:
                                                                                                                                                address66 = FAILURE
                                                                                                                                            if address66 is not FAILURE:
                                                                                                                                                elements32.append(address66)
                                                                                                                                            else:
                                                                                                                                                elements32 = None
                                                                                                                                                self._offset = index66
                                                                                                                                        else:
                                                                                                                                            elements32 = None
                                                                                                                                            self._offset = index66
                                                                                                                                        if elements32 is None:
                                                                                                                                            address0 = FAILURE
                                                                                                                                        else:
                                                                                                                                            address0 = TreeNode(self._input[index66:self._offset], index66, elements32)
                                                                                                                                            self._offset = self._offset
                                                                                                                                        if address0 is FAILURE:
                                                                                                                                            self._offset = index1
                                                                                                                                            index68, elements33 = self._offset, []
                                                                                                                                            address67 = FAILURE
                                                                                                                                            chunk66, max66 = None, self._offset + 3
                                                                                                                                            if max66 <= self._input_size:
                                                                                                                                                chunk66 = self._input[self._offset:max66]
                                                                                                                                            if chunk66 == 'isa':
                                                                                                                                                address67 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                                self._offset = self._offset + 3
                                                                                                                                            else:
                                                                                                                                                address67 = FAILURE
                                                                                                                                                if self._offset > self._failure:
                                                                                                                                                    self._failure = self._offset
                                                                                                                                                    self._expected = []
                                                                                                                                                if self._offset == self._failure:
                                                                                                                                                    self._expected.append('\'isa\'')
                                                                                                                                            if address67 is not FAILURE:
                                                                                                                                                elements33.append(address67)
                                                                                                                                                address68 = FAILURE
                                                                                                                                                index69 = self._offset
                                                                                                                                                chunk67, max67 = None, self._offset + 1
                                                                                                                                                if max67 <= self._input_size:
                                                                                                                                                    chunk67 = self._input[self._offset:max67]
                                                                                                                                                if chunk67 is not None and Grammar.REGEX_38.search(chunk67):
                                                                                                                                                    address68 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                    self._offset = self._offset + 1
                                                                                                                                                else:
                                                                                                                                                    address68 = FAILURE
                                                                                                                                                    if self._offset > self._failure:
                                                                                                                                                        self._failure = self._offset
                                                                                                                                                        self._expected = []
                                                                                                                                                    if self._offset == self._failure:
                                                                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                                self._offset = index69
                                                                                                                                                if address68 is FAILURE:
                                                                                                                                                    address68 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                    self._offset = self._offset
                                                                                                                                                else:
                                                                                                                                                    address68 = FAILURE
                                                                                                                                                if address68 is not FAILURE:
                                                                                                                                                    elements33.append(address68)
                                                                                                                                                else:
                                                                                                                                                    elements33 = None
                                                                                                                                                    self._offset = index68
                                                                                                                                            else:
                                                                                                                                                elements33 = None
                                                                                                                                                self._offset = index68
                                                                                                                                            if elements33 is None:
                                                                                                                                                address0 = FAILURE
                                                                                                                                            else:
                                                                                                                                                address0 = TreeNode(self._input[index68:self._offset], index68, elements33)
                                                                                                                                                self._offset = self._offset
                                                                                                                                            if address0 is FAILURE:
                                                                                                                                                self._offset = index1
                                                                                                                                                index70, elements34 = self._offset, []
                                                                                                                                                address69 = FAILURE
                                                                                                                                                chunk68, max68 = None, self._offset + 5
                                                                                                                                                if max68 <= self._input_size:
                                                                                                                                                    chunk68 = self._input[self._offset:max68]
                                                                                                                                                if chunk68 == 'clear':
                                                                                                                                                    address69 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                                                                                                                                    self._offset = self._offset + 5
                                                                                                                                                else:
                                                                                                                                                    address69 = FAILURE
                                                                                                                                                    if self._offset > self._failure:
                                                                                                                                                        self._failure = self._offset
                                                                                                                                                        self._expected = []
                                                                                                                                                    if self._offset == self._failure:
                                                                                                                                                        self._expected.append('\'clear\'')
                                                                                                                                                if address69 is not FAILURE:
                                                                                                                                                    elements34.append(address69)
                                                                                                                                                    address70 = FAILURE
                                                                                                                                                    index71 = self._offset
                                                                                                                                                    chunk69, max69 = None, self._offset + 1
                                                                                                                                                    if max69 <= self._input_size:
                                                                                                                                                        chunk69 = self._input[self._offset:max69]
                                                                                                                                                    if chunk69 is not None and Grammar.REGEX_39.search(chunk69):
                                                                                                                                                        address70 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                        self._offset = self._offset + 1
                                                                                                                                                    else:
                                                                                                                                                        address70 = FAILURE
                                                                                                                                                        if self._offset > self._failure:
                                                                                                                                                            self._failure = self._offset
                                                                                                                                                            self._expected = []
                                                                                                                                                        if self._offset == self._failure:
                                                                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                                    self._offset = index71
                                                                                                                                                    if address70 is FAILURE:
                                                                                                                                                        address70 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                        self._offset = self._offset
                                                                                                                                                    else:
                                                                                                                                                        address70 = FAILURE
                                                                                                                                                    if address70 is not FAILURE:
                                                                                                                                                        elements34.append(address70)
                                                                                                                                                    else:
                                                                                                                                                        elements34 = None
                                                                                                                                                        self._offset = index70
                                                                                                                                                else:
                                                                                                                                                    elements34 = None
                                                                                                                                                    self._offset = index70
                                                                                                                                                if elements34 is None:
                                                                                                                                                    address0 = FAILURE
                                                                                                                                                else:
                                                                                                                                                    address0 = TreeNode(self._input[index70:self._offset], index70, elements34)
                                                                                                                                                    self._offset = self._offset
                                                                                                                                                if address0 is FAILURE:
                                                                                                                                                    self._offset = index1
                                                                                                                                                    index72, elements35 = self._offset, []
                                                                                                                                                    address71 = FAILURE
                                                                                                                                                    chunk70, max70 = None, self._offset + 7
                                                                                                                                                    if max70 <= self._input_size:
                                                                                                                                                        chunk70 = self._input[self._offset:max70]
                                                                                                                                                    if chunk70 == 'restart':
                                                                                                                                                        address71 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                                                                                                                                        self._offset = self._offset + 7
                                                                                                                                                    else:
                                                                                                                                                        address71 = FAILURE
                                                                                                                                                        if self._offset > self._failure:
                                                                                                                                                            self._failure = self._offset
                                                                                                                                                            self._expected = []
                                                                                                                                                        if self._offset == self._failure:
                                                                                                                                                            self._expected.append('\'restart\'')
                                                                                                                                                    if address71 is not FAILURE:
                                                                                                                                                        elements35.append(address71)
                                                                                                                                                        address72 = FAILURE
                                                                                                                                                        index73 = self._offset
                                                                                                                                                        chunk71, max71 = None, self._offset + 1
                                                                                                                                                        if max71 <= self._input_size:
                                                                                                                                                            chunk71 = self._input[self._offset:max71]
                                                                                                                                                        if chunk71 is not None and Grammar.REGEX_40.search(chunk71):
                                                                                                                                                            address72 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                            self._offset = self._offset + 1
                                                                                                                                                        else:
                                                                                                                                                            address72 = FAILURE
                                                                                                                                                            if self._offset > self._failure:
                                                                                                                                                                self._failure = self._offset
                                                                                                                                                                self._expected = []
                                                                                                                                                            if self._offset == self._failure:
                                                                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                                        self._offset = index73
                                                                                                                                                        if address72 is FAILURE:
                                                                                                                                                            address72 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                            self._offset = self._offset
                                                                                                                                                        else:
                                                                                                                                                            address72 = FAILURE
                                                                                                                                                        if address72 is not FAILURE:
                                                                                                                                                            elements35.append(address72)
                                                                                                                                                        else:
                                                                                                                                                            elements35 = None
                                                                                                                                                            self._offset = index72
                                                                                                                                                    else:
                                                                                                                                                        elements35 = None
                                                                                                                                                        self._offset = index72
                                                                                                                                                    if elements35 is None:
                                                                                                                                                        address0 = FAILURE
                                                                                                                                                    else:
                                                                                                                                                        address0 = TreeNode(self._input[index72:self._offset], index72, elements35)
                                                                                                                                                        self._offset = self._offset
                                                                                                                                                    if address0 is FAILURE:
                                                                                                                                                        self._offset = index1
        self._cache['keyword'][index0] = (address0, self._offset)
        return address0

    def _read_eos(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['eos'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_eol()
        if address0 is FAILURE:
            self._offset = index1
            remaining0, index2, elements0, address1 = 1, self._offset, [], True
            while address1 is not FAILURE:
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '|':
                    address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address1 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'|\'')
                if address1 is not FAILURE:
                    elements0.append(address1)
                    remaining0 -= 1
            if remaining0 <= 0:
                address0 = self._actions.ignore(self._input, index2, self._offset, elements0)
                self._offset = self._offset
            else:
                address0 = FAILURE
            if address0 is FAILURE:
                self._offset = index1
                index3, elements1 = self._offset, []
                address2 = FAILURE
                address2 = self._read__()
                if address2 is not FAILURE:
                    elements1.append(address2)
                    address3 = FAILURE
                    index4 = self._offset
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == ']':
                        address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address3 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\']\'')
                    self._offset = index4
                    if address3 is not FAILURE:
                        address3 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address3 = FAILURE
                    if address3 is not FAILURE:
                        elements1.append(address3)
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
                if elements1 is None:
                    address0 = FAILURE
                else:
                    address0 = TreeNode3(self._input[index3:self._offset], index3, elements1)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index5, elements2 = self._offset, []
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements2.append(address4)
                        address5 = FAILURE
                        index6 = self._offset
                        chunk2, max2 = None, self._offset + 2
                        if max2 <= self._input_size:
                            chunk2 = self._input[self._offset:max2]
                        if chunk2 == ':}':
                            address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                            self._offset = self._offset + 2
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\':}\'')
                        self._offset = index6
                        if address5 is not FAILURE:
                            address5 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address5 = FAILURE
                        if address5 is not FAILURE:
                            elements2.append(address5)
                        else:
                            elements2 = None
                            self._offset = index5
                    else:
                        elements2 = None
                        self._offset = index5
                    if elements2 is None:
                        address0 = FAILURE
                    else:
                        address0 = TreeNode4(self._input[index5:self._offset], index5, elements2)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index7, elements3 = self._offset, []
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements3.append(address6)
                            address7 = FAILURE
                            index8 = self._offset
                            chunk3, max3 = None, self._offset + 3
                            if max3 <= self._input_size:
                                chunk3 = self._input[self._offset:max3]
                            if chunk3 == 'but':
                                address7 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                self._offset = self._offset + 3
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'but\'')
                            self._offset = index8
                            if address7 is not FAILURE:
                                address7 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                self._offset = self._offset
                            else:
                                address7 = FAILURE
                            if address7 is not FAILURE:
                                elements3.append(address7)
                            else:
                                elements3 = None
                                self._offset = index7
                        else:
                            elements3 = None
                            self._offset = index7
                        if elements3 is None:
                            address0 = FAILURE
                        else:
                            address0 = TreeNode5(self._input[index7:self._offset], index7, elements3)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['eos'][index0] = (address0, self._offset)
        return address0

    def _read__ws(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['_ws'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        remaining0, index1, elements0, address1 = 0, self._offset, [], True
        while address1 is not FAILURE:
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 is not None and Grammar.REGEX_41.search(chunk0):
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[\\n\\r\\f \\t]')
            if address1 is not FAILURE:
                elements0.append(address1)
                remaining0 -= 1
        if remaining0 <= 0:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        else:
            address0 = FAILURE
        self._cache['_ws'][index0] = (address0, self._offset)
        return address0

    def _read_line_joining(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['line_joining'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '%>':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'%>\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index2, elements1, address4 = 1, self._offset, [], True
                while address4 is not FAILURE:
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 is not None and Grammar.REGEX_42.search(chunk1):
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[\\n\\r\\f]')
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index2:self._offset], index2, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['line_joining'][index0] = (address0, self._offset)
        return address0

    def _read_float(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['float'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '-':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'-\'')
        if address1 is FAILURE:
            address1 = TreeNode(self._input[index2:index2], index2, [])
            self._offset = index2
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_43.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[0-9]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address4 = FAILURE
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '.':
                    address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address4 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'.\'')
                if address4 is not FAILURE:
                    elements0.append(address4)
                    address5 = FAILURE
                    remaining1, index4, elements2, address6 = 1, self._offset, [], True
                    while address6 is not FAILURE:
                        chunk3, max3 = None, self._offset + 1
                        if max3 <= self._input_size:
                            chunk3 = self._input[self._offset:max3]
                        if chunk3 is not None and Grammar.REGEX_44.search(chunk3):
                            address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address6 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('[0-9]')
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            remaining1 -= 1
                    if remaining1 <= 0:
                        address5 = TreeNode(self._input[index4:self._offset], index4, elements2)
                        self._offset = self._offset
                    else:
                        address5 = FAILURE
                    if address5 is not FAILURE:
                        elements0.append(address5)
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.float_(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['float'][index0] = (address0, self._offset)
        return address0

    def _read_int(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['int'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '-':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'-\'')
        if address1 is FAILURE:
            address1 = TreeNode(self._input[index2:index2], index2, [])
            self._offset = index2
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 1, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_45.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[0-9]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.int_(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['int'][index0] = (address0, self._offset)
        return address0

    def _read_number(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['number'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_float()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_int()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['number'][index0] = (address0, self._offset)
        return address0

    def _read_string_escape(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['string_escape'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '\\':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('"\\\\"')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 is not None and Grammar.REGEX_46.search(chunk1):
                address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[\\\\runftvb\']')
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['string_escape'][index0] = (address0, self._offset)
        return address0

    def _read_string(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['string'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '\'':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('"\'"')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index2, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                index3 = self._offset
                address3 = self._read_string_escape()
                if address3 is FAILURE:
                    self._offset = index3
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 is not None and Grammar.REGEX_47.search(chunk1):
                        address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address3 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[^\']')
                    if address3 is FAILURE:
                        self._offset = index3
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index2:self._offset], index2, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address4 = FAILURE
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '\'':
                    address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address4 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('"\'"')
                if address4 is not FAILURE:
                    elements0.append(address4)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.string(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['string'][index0] = (address0, self._offset)
        return address0

    def _read_basic_name(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['basic_name'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        index3, elements1 = self._offset, []
        address2 = FAILURE
        address2 = self._read_keyword()
        if address2 is not FAILURE:
            elements1.append(address2)
            address3 = FAILURE
            index4 = self._offset
            address3 = self._read__()
            if address3 is FAILURE:
                self._offset = index4
                address3 = self._read_eos()
                if address3 is FAILURE:
                    self._offset = index4
            if address3 is not FAILURE:
                elements1.append(address3)
            else:
                elements1 = None
                self._offset = index3
        else:
            elements1 = None
            self._offset = index3
        if elements1 is None:
            address1 = FAILURE
        else:
            address1 = TreeNode7(self._input[index3:self._offset], index3, elements1)
            self._offset = self._offset
        self._offset = index2
        if address1 is FAILURE:
            address1 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address4 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 is not None and Grammar.REGEX_48.search(chunk0):
                address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address4 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[a-zA-Z_]')
            if address4 is not FAILURE:
                elements0.append(address4)
                address5 = FAILURE
                remaining0, index5, elements2, address6 = 0, self._offset, [], True
                while address6 is not FAILURE:
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 is not None and Grammar.REGEX_49.search(chunk1):
                        address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address6 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[a-zA-Z_0-9]')
                    if address6 is not FAILURE:
                        elements2.append(address6)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address5 = TreeNode(self._input[index5:self._offset], index5, elements2)
                    self._offset = self._offset
                else:
                    address5 = FAILURE
                if address5 is not FAILURE:
                    elements0.append(address5)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.reference(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['basic_name'][index0] = (address0, self._offset)
        return address0

    def _read_name(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['name'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '$':
            address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'$\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '?':
                address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'?\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '~':
                    address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'~\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '!':
                        address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                        self._offset = self._offset + 1
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'!\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '#':
                            address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'#\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '@':
                                address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'@\'')
                            if address0 is FAILURE:
                                self._offset = index1
                                address0 = self._read_basic_name()
                                if address0 is FAILURE:
                                    self._offset = index1
        self._cache['name'][index0] = (address0, self._offset)
        return address0

    def _read_special_entry(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['special_entry'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '^':
            address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'^\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '.':
                address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'.\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '=':
                    address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'=\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 5
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == 'clear':
                        address0 = self._actions.special_entry(self._input, self._offset, self._offset + 5, [])
                        self._offset = self._offset + 5
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'clear\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == ':':
                            address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\':\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '!':
                                address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'!\'')
                            if address0 is FAILURE:
                                self._offset = index1
        self._cache['special_entry'][index0] = (address0, self._offset)
        return address0

    def _read_new_bag(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['new_bag'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '{:':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'{:\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index3, elements1, address4 = 0, self._offset, [], True
                while address4 is not FAILURE:
                    index4, elements2 = self._offset, []
                    address5 = FAILURE
                    address5 = self._read__()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read_statement()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            address7 = FAILURE
                            address7 = self._read__()
                            if address7 is not FAILURE:
                                elements2.append(address7)
                                address8 = FAILURE
                                index5 = self._offset
                                chunk1, max1 = None, self._offset + 2
                                if max1 <= self._input_size:
                                    chunk1 = self._input[self._offset:max1]
                                if chunk1 == ':}':
                                    address8 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                    self._offset = self._offset + 2
                                else:
                                    address8 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\':}\'')
                                self._offset = index5
                                if address8 is FAILURE:
                                    address8 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                    self._offset = self._offset
                                else:
                                    address8 = FAILURE
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                    if elements2 is None:
                        address4 = FAILURE
                    else:
                        address4 = TreeNode9(self._input[index4:self._offset], index4, elements2)
                        self._offset = self._offset
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index3:self._offset], index3, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address9 = FAILURE
                    address9 = self._read__()
                    if address9 is not FAILURE:
                        elements0.append(address9)
                        address10 = FAILURE
                        address10 = self._read_statement()
                        if address10 is not FAILURE:
                            elements0.append(address10)
                            address11 = FAILURE
                            address11 = self._read__ws()
                            if address11 is not FAILURE:
                                elements0.append(address11)
                                address12 = FAILURE
                                chunk2, max2 = None, self._offset + 2
                                if max2 <= self._input_size:
                                    chunk2 = self._input[self._offset:max2]
                                if chunk2 == ':}':
                                    address12 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                    self._offset = self._offset + 2
                                else:
                                    address12 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\':}\'')
                                if address12 is not FAILURE:
                                    address13 = FAILURE
                                    address13 = self._read__()
                                    if address13 is not FAILURE:
                                        elements0.append(address13)
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.new_bag(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index6, elements3 = self._offset, []
            address14 = FAILURE
            chunk3, max3 = None, self._offset + 1
            if max3 <= self._input_size:
                chunk3 = self._input[self._offset:max3]
            if chunk3 == '{':
                address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address14 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'{\'')
            if address14 is not FAILURE:
                address15 = FAILURE
                address15 = self._read__()
                if address15 is not FAILURE:
                    elements3.append(address15)
                    address16 = FAILURE
                    chunk4, max4 = None, self._offset + 1
                    if max4 <= self._input_size:
                        chunk4 = self._input[self._offset:max4]
                    if chunk4 == ':':
                        address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address16 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\':\'')
                    if address16 is not FAILURE:
                        address17 = FAILURE
                        address17 = self._read__()
                        if address17 is not FAILURE:
                            elements3.append(address17)
                            address18 = FAILURE
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '}':
                                address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address18 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address18 is not FAILURE:
                                address19 = FAILURE
                                address19 = self._read__()
                                if address19 is not FAILURE:
                                    elements3.append(address19)
                                else:
                                    elements3 = None
                                    self._offset = index6
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                else:
                    elements3 = None
                    self._offset = index6
            else:
                elements3 = None
                self._offset = index6
            if elements3 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.new_bag(self._input, index6, self._offset, elements3)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index7, elements4 = self._offset, []
                address20 = FAILURE
                chunk6, max6 = None, self._offset + 2
                if max6 <= self._input_size:
                    chunk6 = self._input[self._offset:max6]
                if chunk6 == '{:':
                    address20 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address20 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'{:\'')
                if address20 is not FAILURE:
                    address21 = FAILURE
                    address21 = self._read__ws()
                    if address21 is not FAILURE:
                        elements4.append(address21)
                        address22 = FAILURE
                        chunk7, max7 = None, self._offset + 2
                        if max7 <= self._input_size:
                            chunk7 = self._input[self._offset:max7]
                        if chunk7 == ':}':
                            address22 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                            self._offset = self._offset + 2
                        else:
                            address22 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\':}\'')
                        if address22 is not FAILURE:
                            address23 = FAILURE
                            address23 = self._read__()
                            if address23 is not FAILURE:
                                elements4.append(address23)
                            else:
                                elements4 = None
                                self._offset = index7
                        else:
                            elements4 = None
                            self._offset = index7
                    else:
                        elements4 = None
                        self._offset = index7
                else:
                    elements4 = None
                    self._offset = index7
                if elements4 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.new_bag(self._input, index7, self._offset, elements4)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['new_bag'][index0] = (address0, self._offset)
        return address0

    def _read_roll_item(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['roll_item'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_expression()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 3
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '<->':
                    address3 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                    self._offset = self._offset + 3
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<->\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_expression()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.fill(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_expression()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['roll_item'][index0] = (address0, self._offset)
        return address0

    def _read_roll_def(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['roll_def'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '[:':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'[:\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index3, elements1, address4 = 0, self._offset, [], True
                while address4 is not FAILURE:
                    index4, elements2 = self._offset, []
                    address5 = FAILURE
                    address5 = self._read_roll_item()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            address7 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == ',':
                                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\',\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__ws()
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                    if elements2 is None:
                        address4 = FAILURE
                    else:
                        address4 = TreeNode14(self._input[index4:self._offset], index4, elements2)
                        self._offset = self._offset
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index3:self._offset], index3, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address9 = FAILURE
                    index5 = self._offset
                    address9 = self._read_roll_item()
                    if address9 is FAILURE:
                        address9 = TreeNode(self._input[index5:index5], index5, [])
                        self._offset = index5
                    if address9 is not FAILURE:
                        elements0.append(address9)
                        address10 = FAILURE
                        address10 = self._read__ws()
                        if address10 is not FAILURE:
                            elements0.append(address10)
                            address11 = FAILURE
                            chunk2, max2 = None, self._offset + 2
                            if max2 <= self._input_size:
                                chunk2 = self._input[self._offset:max2]
                            if chunk2 == ':]':
                                address11 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                self._offset = self._offset + 2
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\':]\'')
                            if address11 is not FAILURE:
                                address12 = FAILURE
                                address12 = self._read__()
                                if address12 is not FAILURE:
                                    elements0.append(address12)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.roll_def(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index6, elements3 = self._offset, []
            address13 = FAILURE
            chunk3, max3 = None, self._offset + 1
            if max3 <= self._input_size:
                chunk3 = self._input[self._offset:max3]
            if chunk3 == '[':
                address13 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address13 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'[\'')
            if address13 is not FAILURE:
                elements3.append(address13)
                address14 = FAILURE
                address14 = self._read__()
                if address14 is not FAILURE:
                    elements3.append(address14)
                    address15 = FAILURE
                    chunk4, max4 = None, self._offset + 1
                    if max4 <= self._input_size:
                        chunk4 = self._input[self._offset:max4]
                    if chunk4 == ':':
                        address15 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address15 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\':\'')
                    if address15 is not FAILURE:
                        elements3.append(address15)
                        address16 = FAILURE
                        address16 = self._read__()
                        if address16 is not FAILURE:
                            elements3.append(address16)
                            address17 = FAILURE
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == ']':
                                address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address17 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\']\'')
                            if address17 is not FAILURE:
                                elements3.append(address17)
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                else:
                    elements3 = None
                    self._offset = index6
            else:
                elements3 = None
                self._offset = index6
            if elements3 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.empty_roll(self._input, index6, self._offset, elements3)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
        self._cache['roll_def'][index0] = (address0, self._offset)
        return address0

    def _read_reduce(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['reduce'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '{':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'{\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                index3 = self._offset
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == ':':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\':\'')
                if address3 is FAILURE:
                    self._offset = index3
                    address3 = self._read_special_accessor()
                    if address3 is FAILURE:
                        self._offset = index3
                self._offset = index2
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read_expression()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__ws()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            chunk2, max2 = None, self._offset + 1
                            if max2 <= self._input_size:
                                chunk2 = self._input[self._offset:max2]
                            if chunk2 == '}':
                                address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address6 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address6 is not FAILURE:
                                address7 = FAILURE
                                address7 = self._read__()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.reduce(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['reduce'][index0] = (address0, self._offset)
        return address0

    def _read_two_sided_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['two_sided_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '*':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'*\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '%/':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'%/\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '/':
                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'/\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '%':
                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                        self._offset = self._offset + 1
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'%\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '+':
                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'+\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            index2, elements0 = self._offset, []
                            address1 = FAILURE
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '-':
                                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address1 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'-\'')
                            if address1 is not FAILURE:
                                elements0.append(address1)
                                address2 = FAILURE
                                index3 = self._offset
                                chunk6, max6 = None, self._offset + 1
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 is not None and Grammar.REGEX_50.search(chunk6):
                                    address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address2 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('[a-z_A-Z]')
                                self._offset = index3
                                if address2 is FAILURE:
                                    address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                    self._offset = self._offset
                                else:
                                    address2 = FAILURE
                                if address2 is not FAILURE:
                                    elements0.append(address2)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                            if elements0 is None:
                                address0 = FAILURE
                            else:
                                address0 = self._actions.two_sided_operator(self._input, index2, self._offset, elements0)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
                                chunk7, max7 = None, self._offset + 2
                                if max7 <= self._input_size:
                                    chunk7 = self._input[self._offset:max7]
                                if chunk7 == 'or':
                                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                    self._offset = self._offset + 2
                                else:
                                    address0 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'or\'')
                                if address0 is FAILURE:
                                    self._offset = index1
                                    chunk8, max8 = None, self._offset + 3
                                    if max8 <= self._input_size:
                                        chunk8 = self._input[self._offset:max8]
                                    if chunk8 == 'and':
                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 3, [])
                                        self._offset = self._offset + 3
                                    else:
                                        address0 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'and\'')
                                    if address0 is FAILURE:
                                        self._offset = index1
                                        chunk9, max9 = None, self._offset + 3
                                        if max9 <= self._input_size:
                                            chunk9 = self._input[self._offset:max9]
                                        if chunk9 == 'isa':
                                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 3, [])
                                            self._offset = self._offset + 3
                                        else:
                                            address0 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'isa\'')
                                        if address0 is FAILURE:
                                            self._offset = index1
                                            chunk10, max10 = None, self._offset + 1
                                            if max10 <= self._input_size:
                                                chunk10 = self._input[self._offset:max10]
                                            if chunk10 == '@':
                                                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                self._offset = self._offset + 1
                                            else:
                                                address0 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('\'@\'')
                                            if address0 is FAILURE:
                                                self._offset = index1
                                                chunk11, max11 = None, self._offset + 2
                                                if max11 <= self._input_size:
                                                    chunk11 = self._input[self._offset:max11]
                                                if chunk11 == '==':
                                                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                    self._offset = self._offset + 2
                                                else:
                                                    address0 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('\'==\'')
                                                if address0 is FAILURE:
                                                    self._offset = index1
                                                    chunk12, max12 = None, self._offset + 2
                                                    if max12 <= self._input_size:
                                                        chunk12 = self._input[self._offset:max12]
                                                    if chunk12 == '!=':
                                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                        self._offset = self._offset + 2
                                                    else:
                                                        address0 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('\'!=\'')
                                                    if address0 is FAILURE:
                                                        self._offset = index1
                                                        chunk13, max13 = None, self._offset + 2
                                                        if max13 <= self._input_size:
                                                            chunk13 = self._input[self._offset:max13]
                                                        if chunk13 == '<=':
                                                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                            self._offset = self._offset + 2
                                                        else:
                                                            address0 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('\'<=\'')
                                                        if address0 is FAILURE:
                                                            self._offset = index1
                                                            chunk14, max14 = None, self._offset + 2
                                                            if max14 <= self._input_size:
                                                                chunk14 = self._input[self._offset:max14]
                                                            if chunk14 == '>=':
                                                                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                                self._offset = self._offset + 2
                                                            else:
                                                                address0 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'>=\'')
                                                            if address0 is FAILURE:
                                                                self._offset = index1
                                                                chunk15, max15 = None, self._offset + 1
                                                                if max15 <= self._input_size:
                                                                    chunk15 = self._input[self._offset:max15]
                                                                if chunk15 == '<':
                                                                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                                    self._offset = self._offset + 1
                                                                else:
                                                                    address0 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('\'<\'')
                                                                if address0 is FAILURE:
                                                                    self._offset = index1
                                                                    chunk16, max16 = None, self._offset + 1
                                                                    if max16 <= self._input_size:
                                                                        chunk16 = self._input[self._offset:max16]
                                                                    if chunk16 == '>':
                                                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                                        self._offset = self._offset + 1
                                                                    else:
                                                                        address0 = FAILURE
                                                                        if self._offset > self._failure:
                                                                            self._failure = self._offset
                                                                            self._expected = []
                                                                        if self._offset == self._failure:
                                                                            self._expected.append('\'>\'')
                                                                    if address0 is FAILURE:
                                                                        self._offset = index1
                                                                        chunk17, max17 = None, self._offset + 1
                                                                        if max17 <= self._input_size:
                                                                            chunk17 = self._input[self._offset:max17]
                                                                        if chunk17 == '&':
                                                                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                                            self._offset = self._offset + 1
                                                                        else:
                                                                            address0 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('\'&\'')
                                                                        if address0 is FAILURE:
                                                                            self._offset = index1
        self._cache['two_sided_op'][index0] = (address0, self._offset)
        return address0

    def _read_one_sided_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['one_sided_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'has':
            address0 = self._actions.one_sided_operator(self._input, self._offset, self._offset + 3, [])
            self._offset = self._offset + 3
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'has\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '#':
                address0 = self._actions.overload_only_operator(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'#\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '0':
                    address0 = self._actions.overload_only_operator(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'0\'')
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '{':
                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'{\'')
                    if address1 is not FAILURE:
                        elements0.append(address1)
                        address2 = FAILURE
                        address2 = self._read__()
                        if address2 is not FAILURE:
                            elements0.append(address2)
                            address3 = FAILURE
                            chunk4, max4 = None, self._offset + 1
                            if max4 <= self._input_size:
                                chunk4 = self._input[self._offset:max4]
                            if chunk4 == '}':
                                address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address3 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address3 is not FAILURE:
                                elements0.append(address3)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.overload_only_operator(self._input, index2, self._offset, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index3, elements1 = self._offset, []
                        address4 = FAILURE
                        chunk5, max5 = None, self._offset + 3
                        if max5 <= self._input_size:
                            chunk5 = self._input[self._offset:max5]
                        if chunk5 == 'for':
                            address4 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                            self._offset = self._offset + 3
                        else:
                            address4 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'for\'')
                        if address4 is not FAILURE:
                            elements1.append(address4)
                            address5 = FAILURE
                            address5 = self._read__()
                            if address5 is not FAILURE:
                                elements1.append(address5)
                                address6 = FAILURE
                                chunk6, max6 = None, self._offset + 5
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 == 'every':
                                    address6 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                    self._offset = self._offset + 5
                                else:
                                    address6 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'every\'')
                                if address6 is not FAILURE:
                                    elements1.append(address6)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                        if elements1 is None:
                            address0 = FAILURE
                        else:
                            address0 = self._actions.overload_only_operator(self._input, index3, self._offset, elements1)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk7, max7 = None, self._offset + 1
                            if max7 <= self._input_size:
                                chunk7 = self._input[self._offset:max7]
                            if chunk7 == '?':
                                address0 = self._actions.overload_only_operator(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'?\'')
                            if address0 is FAILURE:
                                self._offset = index1
        self._cache['one_sided_op'][index0] = (address0, self._offset)
        return address0

    def _read_overload_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['overload_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '<[':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'<[\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_two_sided_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        chunk1, max1 = None, self._offset + 1
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == ']':
                            address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\']\'')
                        if address5 is not FAILURE:
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.left_op_overload(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address7 = FAILURE
            chunk2, max2 = None, self._offset + 1
            if max2 <= self._input_size:
                chunk2 = self._input[self._offset:max2]
            if chunk2 == '[':
                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address7 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'[\'')
            if address7 is not FAILURE:
                address8 = FAILURE
                address8 = self._read__()
                if address8 is not FAILURE:
                    elements1.append(address8)
                    address9 = FAILURE
                    address9 = self._read_two_sided_op()
                    if address9 is not FAILURE:
                        elements1.append(address9)
                        address10 = FAILURE
                        address10 = self._read__()
                        if address10 is not FAILURE:
                            elements1.append(address10)
                            address11 = FAILURE
                            chunk3, max3 = None, self._offset + 2
                            if max3 <= self._input_size:
                                chunk3 = self._input[self._offset:max3]
                            if chunk3 == ']>':
                                address11 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                self._offset = self._offset + 2
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\']>\'')
                            if address11 is not FAILURE:
                                address12 = FAILURE
                                address12 = self._read__()
                                if address12 is not FAILURE:
                                    elements1.append(address12)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.right_op_overload(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index4, elements2 = self._offset, []
                address13 = FAILURE
                chunk4, max4 = None, self._offset + 1
                if max4 <= self._input_size:
                    chunk4 = self._input[self._offset:max4]
                if chunk4 == '[':
                    address13 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address13 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'[\'')
                if address13 is not FAILURE:
                    address14 = FAILURE
                    address14 = self._read__()
                    if address14 is not FAILURE:
                        elements2.append(address14)
                        address15 = FAILURE
                        address15 = self._read_one_sided_op()
                        if address15 is not FAILURE:
                            elements2.append(address15)
                            address16 = FAILURE
                            address16 = self._read__()
                            if address16 is not FAILURE:
                                elements2.append(address16)
                                address17 = FAILURE
                                chunk5, max5 = None, self._offset + 1
                                if max5 <= self._input_size:
                                    chunk5 = self._input[self._offset:max5]
                                if chunk5 == ']':
                                    address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address17 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\']\'')
                                if address17 is not FAILURE:
                                    address18 = FAILURE
                                    address18 = self._read__()
                                    if address18 is not FAILURE:
                                        elements2.append(address18)
                                    else:
                                        elements2 = None
                                        self._offset = index4
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.one_sided_op_overload(self._input, index4, self._offset, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['overload_op'][index0] = (address0, self._offset)
        return address0

    def _read_special_accessor(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['special_accessor'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '#':
            address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'#\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '*':
                address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'*\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '+':
                    address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'+\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '=':
                        address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                        self._offset = self._offset + 1
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '^':
                            address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'^\'')
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['special_accessor'][index0] = (address0, self._offset)
        return address0

    def _read_accessor(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['accessor'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_basic_name()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode22(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address3 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '{':
                address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address3 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'{\'')
            if address3 is not FAILURE:
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements1.append(address4)
                    address5 = FAILURE
                    address5 = self._read_special_accessor()
                    if address5 is not FAILURE:
                        elements1.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements1.append(address6)
                            address7 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == '}':
                                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__()
                                if address8 is not FAILURE:
                                    elements1.append(address8)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode23(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index4, elements2 = self._offset, []
                address9 = FAILURE
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '<':
                    address9 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address9 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<\'')
                if address9 is not FAILURE:
                    address10 = FAILURE
                    index5 = self._offset
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '[':
                        address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address10 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'[\'')
                    self._offset = index5
                    if address10 is FAILURE:
                        address10 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address10 = FAILURE
                    if address10 is not FAILURE:
                        elements2.append(address10)
                        address11 = FAILURE
                        address11 = self._read__()
                        if address11 is not FAILURE:
                            elements2.append(address11)
                            address12 = FAILURE
                            address12 = self._read_special_entry()
                            if address12 is not FAILURE:
                                elements2.append(address12)
                                address13 = FAILURE
                                address13 = self._read__()
                                if address13 is not FAILURE:
                                    elements2.append(address13)
                                    address14 = FAILURE
                                    chunk4, max4 = None, self._offset + 1
                                    if max4 <= self._input_size:
                                        chunk4 = self._input[self._offset:max4]
                                    if chunk4 == '>':
                                        address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address14 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'>\'')
                                    if address14 is not FAILURE:
                                        address15 = FAILURE
                                        address15 = self._read__()
                                        if address15 is not FAILURE:
                                            elements2.append(address15)
                                        else:
                                            elements2 = None
                                            self._offset = index4
                                    else:
                                        elements2 = None
                                        self._offset = index4
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = TreeNode24(self._input[index4:self._offset], index4, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index6, elements3 = self._offset, []
                    address16 = FAILURE
                    chunk5, max5 = None, self._offset + 1
                    if max5 <= self._input_size:
                        chunk5 = self._input[self._offset:max5]
                    if chunk5 == '<':
                        address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address16 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'<\'')
                    if address16 is not FAILURE:
                        address17 = FAILURE
                        index7 = self._offset
                        chunk6, max6 = None, self._offset + 1
                        if max6 <= self._input_size:
                            chunk6 = self._input[self._offset:max6]
                        if chunk6 == '[':
                            address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address17 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'[\'')
                        self._offset = index7
                        if address17 is FAILURE:
                            address17 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address17 = FAILURE
                        if address17 is not FAILURE:
                            elements3.append(address17)
                            address18 = FAILURE
                            address18 = self._read__()
                            if address18 is not FAILURE:
                                elements3.append(address18)
                                address19 = FAILURE
                                address19 = self._read_expression()
                                if address19 is not FAILURE:
                                    elements3.append(address19)
                                    address20 = FAILURE
                                    address20 = self._read__()
                                    if address20 is not FAILURE:
                                        elements3.append(address20)
                                        address21 = FAILURE
                                        chunk7, max7 = None, self._offset + 1
                                        if max7 <= self._input_size:
                                            chunk7 = self._input[self._offset:max7]
                                        if chunk7 == '>':
                                            address21 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address21 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'>\'')
                                        if address21 is not FAILURE:
                                            address22 = FAILURE
                                            address22 = self._read__()
                                            if address22 is not FAILURE:
                                                elements3.append(address22)
                                            else:
                                                elements3 = None
                                                self._offset = index6
                                        else:
                                            elements3 = None
                                            self._offset = index6
                                    else:
                                        elements3 = None
                                        self._offset = index6
                                else:
                                    elements3 = None
                                    self._offset = index6
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                    if elements3 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.raw_accessor(self._input, index6, self._offset, elements3)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        address0 = self._read_overload_op()
                        if address0 is FAILURE:
                            self._offset = index1
                            index8, elements4 = self._offset, []
                            address23 = FAILURE
                            address23 = self._read_reduce()
                            if address23 is not FAILURE:
                                elements4.append(address23)
                                address24 = FAILURE
                                address24 = self._read__()
                                if address24 is not FAILURE:
                                    elements4.append(address24)
                                else:
                                    elements4 = None
                                    self._offset = index8
                            else:
                                elements4 = None
                                self._offset = index8
                            if elements4 is None:
                                address0 = FAILURE
                            else:
                                address0 = TreeNode26(self._input[index8:self._offset], index8, elements4)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
        self._cache['accessor'][index0] = (address0, self._offset)
        return address0

    def _read_accessing(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['accessing'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_reduce_expr()
        if address0 is FAILURE:
            self._offset = index1
            index2, elements0 = self._offset, []
            address1 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '<':
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'<\'')
            if address1 is not FAILURE:
                address2 = FAILURE
                index3 = self._offset
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == '[':
                    address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address2 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'[\'')
                self._offset = index3
                if address2 is FAILURE:
                    address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address2 = FAILURE
                if address2 is not FAILURE:
                    elements0.append(address2)
                    address3 = FAILURE
                    address3 = self._read__()
                    if address3 is not FAILURE:
                        elements0.append(address3)
                        address4 = FAILURE
                        address4 = self._read_special_entry()
                        if address4 is not FAILURE:
                            elements0.append(address4)
                            address5 = FAILURE
                            address5 = self._read__()
                            if address5 is not FAILURE:
                                elements0.append(address5)
                                address6 = FAILURE
                                chunk2, max2 = None, self._offset + 1
                                if max2 <= self._input_size:
                                    chunk2 = self._input[self._offset:max2]
                                if chunk2 == '>':
                                    address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address6 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'>\'')
                                if address6 is not FAILURE:
                                    address7 = FAILURE
                                    address7 = self._read__()
                                    if address7 is not FAILURE:
                                        elements0.append(address7)
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
            if elements0 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode27(self._input[index2:self._offset], index2, elements0)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_overload_op()
                if address0 is FAILURE:
                    self._offset = index1
                    address0 = self._read_name()
                    if address0 is FAILURE:
                        self._offset = index1
        self._cache['accessing'][index0] = (address0, self._offset)
        return address0

    def _read_access(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['access'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_accessing()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 1, self._offset, [], True
            while address3 is not FAILURE:
                index4, elements2 = self._offset, []
                address4 = FAILURE
                address4 = self._read__ws()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '.':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'.\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read_accessor()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address3 = FAILURE
                else:
                    address3 = TreeNode29(self._input[index4:self._offset], index4, elements2)
                    self._offset = self._offset
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.access(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index5, elements3 = self._offset, []
            address7 = FAILURE
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '<':
                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address7 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'<\'')
            if address7 is not FAILURE:
                address8 = FAILURE
                index6 = self._offset
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '[':
                    address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address8 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'[\'')
                self._offset = index6
                if address8 is FAILURE:
                    address8 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address8 = FAILURE
                if address8 is not FAILURE:
                    elements3.append(address8)
                    address9 = FAILURE
                    address9 = self._read__()
                    if address9 is not FAILURE:
                        elements3.append(address9)
                        address10 = FAILURE
                        address10 = self._read_special_entry()
                        if address10 is not FAILURE:
                            elements3.append(address10)
                            address11 = FAILURE
                            address11 = self._read__()
                            if address11 is not FAILURE:
                                elements3.append(address11)
                                address12 = FAILURE
                                chunk3, max3 = None, self._offset + 1
                                if max3 <= self._input_size:
                                    chunk3 = self._input[self._offset:max3]
                                if chunk3 == '>':
                                    address12 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address12 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'>\'')
                                if address12 is not FAILURE:
                                    address13 = FAILURE
                                    address13 = self._read__()
                                    if address13 is not FAILURE:
                                        elements3.append(address13)
                                    else:
                                        elements3 = None
                                        self._offset = index5
                                else:
                                    elements3 = None
                                    self._offset = index5
                            else:
                                elements3 = None
                                self._offset = index5
                        else:
                            elements3 = None
                            self._offset = index5
                    else:
                        elements3 = None
                        self._offset = index5
                else:
                    elements3 = None
                    self._offset = index5
            else:
                elements3 = None
                self._offset = index5
            if elements3 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode30(self._input[index5:self._offset], index5, elements3)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_name()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['access'][index0] = (address0, self._offset)
        return address0

    def _read_mult_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['mult_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '*':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'*\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '%/':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'%/\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '/':
                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'/\'')
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '%':
                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'%\'')
                    if address1 is not FAILURE:
                        elements0.append(address1)
                        address2 = FAILURE
                        index3 = self._offset
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '>':
                            address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address2 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'>\'')
                        self._offset = index3
                        if address2 is FAILURE:
                            address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address2 = FAILURE
                        if address2 is not FAILURE:
                            elements0.append(address2)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.two_sided_operator(self._input, index2, self._offset, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
        self._cache['mult_op'][index0] = (address0, self._offset)
        return address0

    def _read_add_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['add_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '+':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'+\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '-':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'-\'')
            if address0 is FAILURE:
                self._offset = index1
        self._cache['add_op'][index0] = (address0, self._offset)
        return address0

    def _read_anor_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['anor_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'or':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
            self._offset = self._offset + 2
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'or\'')
        if address0 is FAILURE:
            self._offset = index1
            index2, elements0 = self._offset, []
            address1 = FAILURE
            chunk1, max1 = None, self._offset + 3
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'and':
                address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                self._offset = self._offset + 3
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'and\'')
            if address1 is not FAILURE:
                elements0.append(address1)
                address2 = FAILURE
                index3 = self._offset
                index4, elements1 = self._offset, []
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements1.append(address3)
                    address4 = FAILURE
                    chunk2, max2 = None, self._offset + 6
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == 'always':
                        address4 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                        self._offset = self._offset + 6
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'always\'')
                    if address4 is not FAILURE:
                        elements1.append(address4)
                    else:
                        elements1 = None
                        self._offset = index4
                else:
                    elements1 = None
                    self._offset = index4
                if elements1 is None:
                    address2 = FAILURE
                else:
                    address2 = TreeNode31(self._input[index4:self._offset], index4, elements1)
                    self._offset = self._offset
                self._offset = index3
                if address2 is FAILURE:
                    address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address2 = FAILURE
                if address2 is not FAILURE:
                    elements0.append(address2)
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
            if elements0 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.two_sided_operator(self._input, index2, self._offset, elements0)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
        self._cache['anor_op'][index0] = (address0, self._offset)
        return address0

    def _read_comp_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['comp_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '==':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
            self._offset = self._offset + 2
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'==\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '!=':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'!=\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 2
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '<=':
                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                    self._offset = self._offset + 2
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<=\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 2
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '>=':
                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                        self._offset = self._offset + 2
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>=\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '<':
                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'<\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '>':
                                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'>\'')
                            if address0 is FAILURE:
                                self._offset = index1
                                index2, elements0 = self._offset, []
                                address1 = FAILURE
                                chunk6, max6 = None, self._offset + 3
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 == 'has':
                                    address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                    self._offset = self._offset + 3
                                else:
                                    address1 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'has\'')
                                if address1 is not FAILURE:
                                    elements0.append(address1)
                                    address2 = FAILURE
                                    index3 = self._offset
                                    index4, elements1 = self._offset, []
                                    address3 = FAILURE
                                    address3 = self._read__()
                                    if address3 is not FAILURE:
                                        elements1.append(address3)
                                        address4 = FAILURE
                                        chunk7, max7 = None, self._offset + 2
                                        if max7 <= self._input_size:
                                            chunk7 = self._input[self._offset:max7]
                                        if chunk7 == 'do':
                                            address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                            self._offset = self._offset + 2
                                        else:
                                            address4 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'do\'')
                                        if address4 is not FAILURE:
                                            elements1.append(address4)
                                        else:
                                            elements1 = None
                                            self._offset = index4
                                    else:
                                        elements1 = None
                                        self._offset = index4
                                    if elements1 is None:
                                        address2 = FAILURE
                                    else:
                                        address2 = TreeNode32(self._input[index4:self._offset], index4, elements1)
                                        self._offset = self._offset
                                    self._offset = index3
                                    if address2 is FAILURE:
                                        address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                        self._offset = self._offset
                                    else:
                                        address2 = FAILURE
                                    if address2 is not FAILURE:
                                        elements0.append(address2)
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                                if elements0 is None:
                                    address0 = FAILURE
                                else:
                                    address0 = self._actions.one_sided_operator(self._input, index2, self._offset, elements0)
                                    self._offset = self._offset
                                if address0 is FAILURE:
                                    self._offset = index1
                                    chunk8, max8 = None, self._offset + 3
                                    if max8 <= self._input_size:
                                        chunk8 = self._input[self._offset:max8]
                                    if chunk8 == 'isa':
                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 3, [])
                                        self._offset = self._offset + 3
                                    else:
                                        address0 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'isa\'')
                                    if address0 is FAILURE:
                                        self._offset = index1
        self._cache['comp_op'][index0] = (address0, self._offset)
        return address0

    def _read_assign_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['assign_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '+=':
            address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
            self._offset = self._offset + 2
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'+=\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '-=':
                address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'-=\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 2
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '*=':
                    address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                    self._offset = self._offset + 2
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'*=\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 2
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '/=':
                        address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                        self._offset = self._offset + 2
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'/=\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 2
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '%=':
                            address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                            self._offset = self._offset + 2
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'%=\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 3
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '%/=':
                                address0 = self._actions.text(self._input, self._offset, self._offset + 3, [])
                                self._offset = self._offset + 3
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'%/=\'')
                            if address0 is FAILURE:
                                self._offset = index1
                                chunk6, max6 = None, self._offset + 2
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 == '&=':
                                    address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                                    self._offset = self._offset + 2
                                else:
                                    address0 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'&=\'')
                                if address0 is FAILURE:
                                    self._offset = index1
                                    index2, elements0 = self._offset, []
                                    address1 = FAILURE
                                    chunk7, max7 = None, self._offset + 1
                                    if max7 <= self._input_size:
                                        chunk7 = self._input[self._offset:max7]
                                    if chunk7 == '=':
                                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address1 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'=\'')
                                    if address1 is not FAILURE:
                                        elements0.append(address1)
                                        address2 = FAILURE
                                        index3 = self._offset
                                        chunk8, max8 = None, self._offset + 1
                                        if max8 <= self._input_size:
                                            chunk8 = self._input[self._offset:max8]
                                        if chunk8 == '>':
                                            address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address2 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'>\'')
                                        self._offset = index3
                                        if address2 is FAILURE:
                                            address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                            self._offset = self._offset
                                        else:
                                            address2 = FAILURE
                                        if address2 is not FAILURE:
                                            elements0.append(address2)
                                        else:
                                            elements0 = None
                                            self._offset = index2
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                    if elements0 is None:
                                        address0 = FAILURE
                                    else:
                                        address0 = self._actions.text(self._input, index2, self._offset, elements0)
                                        self._offset = self._offset
                                    if address0 is FAILURE:
                                        self._offset = index1
        self._cache['assign_op'][index0] = (address0, self._offset)
        return address0

    def _read_expression(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['expression'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        address0 = self._read_use_if()
        self._cache['expression'][index0] = (address0, self._offset)
        return address0

    def _read_use_if(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['use_if'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'use':
            address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
            self._offset = self._offset + 3
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'use\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_expression()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        chunk1, max1 = None, self._offset + 2
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == 'if':
                            address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                            self._offset = self._offset + 2
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'if\'')
                        if address5 is not FAILURE:
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_anor()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                    address8 = FAILURE
                                    address8 = self._read__()
                                    if address8 is not FAILURE:
                                        elements0.append(address8)
                                        address9 = FAILURE
                                        chunk2, max2 = None, self._offset + 9
                                        if max2 <= self._input_size:
                                            chunk2 = self._input[self._offset:max2]
                                        if chunk2 == 'otherwise':
                                            address9 = TreeNode(self._input[self._offset:self._offset + 9], self._offset, [])
                                            self._offset = self._offset + 9
                                        else:
                                            address9 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'otherwise\'')
                                        if address9 is not FAILURE:
                                            address10 = FAILURE
                                            address10 = self._read__()
                                            if address10 is not FAILURE:
                                                elements0.append(address10)
                                                address11 = FAILURE
                                                address11 = self._read_expression()
                                                if address11 is not FAILURE:
                                                    elements0.append(address11)
                                                else:
                                                    elements0 = None
                                                    self._offset = index2
                                            else:
                                                elements0 = None
                                                self._offset = index2
                                        else:
                                            elements0 = None
                                            self._offset = index2
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.use_if(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address12 = FAILURE
            chunk3, max3 = None, self._offset + 3
            if max3 <= self._input_size:
                chunk3 = self._input[self._offset:max3]
            if chunk3 == 'not':
                address12 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                self._offset = self._offset + 3
            else:
                address12 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'not\'')
            if address12 is not FAILURE:
                address13 = FAILURE
                address13 = self._read__()
                if address13 is not FAILURE:
                    elements1.append(address13)
                    address14 = FAILURE
                    address14 = self._read_anor()
                    if address14 is not FAILURE:
                        elements1.append(address14)
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.negate(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_anor()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['use_if'][index0] = (address0, self._offset)
        return address0

    def _read_anor(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['anor'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_comparison()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_anor_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_anor()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_comparison()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['anor'][index0] = (address0, self._offset)
        return address0

    def _read_comparison(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['comparison'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_roll_math()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_comp_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_comparison()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_roll_math()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['comparison'][index0] = (address0, self._offset)
        return address0

    def _read_roll_math(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['roll_math'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_add_math()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '&':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'&\'')
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    index3 = self._offset
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == '=':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    self._offset = index3
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_roll_math()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_add_math()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['roll_math'][index0] = (address0, self._offset)
        return address0

    def _read_add_math(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['add_math'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_mult_math()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_add_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    index3 = self._offset
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '=':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    self._offset = index3
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_add_math()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_mult_math()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['add_math'][index0] = (address0, self._offset)
        return address0

    def _read_mult_math(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['mult_math'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_lambda_expr()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_mult_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    index3 = self._offset
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '=':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    self._offset = index3
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_mult_math()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_lambda_expr()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['mult_math'][index0] = (address0, self._offset)
        return address0

    def _read_lambda_expr(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['lambda_expr'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_lambda_def()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_modify()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['lambda_expr'][index0] = (address0, self._offset)
        return address0

    def _read_modify(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modify'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_first_modifier_call()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                address3 = self._read_modifier_call()
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modify(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_dice()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['modify'][index0] = (address0, self._offset)
        return address0

    def _read_dice(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['dice'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        index3 = self._offset
        index4 = self._offset
        address1 = self._read_name()
        if address1 is FAILURE:
            self._offset = index4
            address1 = self._read_string()
            if address1 is FAILURE:
                self._offset = index4
        self._offset = index3
        if address1 is FAILURE:
            address1 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read_reduce_expr()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 is not None and chunk0.lower() == 'd'.lower():
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('`d`')
                    if address4 is not FAILURE:
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index5 = self._offset
                            index6 = self._offset
                            address6 = self._read_name()
                            if address6 is FAILURE:
                                self._offset = index6
                                address6 = self._read_string()
                                if address6 is FAILURE:
                                    self._offset = index6
                            self._offset = index5
                            if address6 is FAILURE:
                                address6 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                self._offset = self._offset
                            else:
                                address6 = FAILURE
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_reduce_expr()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.dice(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_access()
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_reduce_expr()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['dice'][index0] = (address0, self._offset)
        return address0

    def _read_reduce_expr(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['reduce_expr'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_roll_def()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_new_bag()
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_reduce()
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '(':
                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'(\'')
                    if address1 is not FAILURE:
                        address2 = FAILURE
                        address2 = self._read__ws()
                        if address2 is not FAILURE:
                            elements0.append(address2)
                            address3 = FAILURE
                            address3 = self._read_expression()
                            if address3 is not FAILURE:
                                elements0.append(address3)
                                address4 = FAILURE
                                address4 = self._read__ws()
                                if address4 is not FAILURE:
                                    elements0.append(address4)
                                    address5 = FAILURE
                                    chunk1, max1 = None, self._offset + 1
                                    if max1 <= self._input_size:
                                        chunk1 = self._input[self._offset:max1]
                                    if chunk1 == ')':
                                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address5 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\')\'')
                                    if address5 is not FAILURE:
                                        address6 = FAILURE
                                        address6 = self._read__()
                                        if address6 is not FAILURE:
                                            elements0.append(address6)
                                        else:
                                            elements0 = None
                                            self._offset = index2
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = TreeNode42(self._input[index2:self._offset], index2, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        address0 = self._read_atom()
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['reduce_expr'][index0] = (address0, self._offset)
        return address0

    def _read_atom(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['atom'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_number()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_name()
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_string()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['atom'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_tail(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_tail'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_access()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                address3 = self._read_modifier_args()
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[index2:index2], index2, [])
                    self._offset = index2
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modifier_call(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_tail'][index0] = (address0, self._offset)
        return address0

    def _read_first_modifier_call(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['first_modifier_call'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_dice()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '-':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'-\'')
                if address3 is FAILURE:
                    self._offset = index2
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == ':':
                        address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address3 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\':\'')
                    if address3 is FAILURE:
                        self._offset = index2
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    chunk2, max2 = None, self._offset + 1
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == '>':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>\'')
                    if address4 is not FAILURE:
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_modifier_tail()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.first_modifier_call(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['first_modifier_call'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_call(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_call'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read__ws()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            chunk0, max0 = None, self._offset + 2
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '->':
                address2 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                self._offset = self._offset + 2
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'->\'')
            if address2 is not FAILURE:
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read_modifier_tail()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode45(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['modifier_call'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_args(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_args'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '(':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'(\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index2, elements1, address4 = 0, self._offset, [], True
                while address4 is not FAILURE:
                    index3, elements2 = self._offset, []
                    address5 = FAILURE
                    address5 = self._read_expression()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            address7 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == ',':
                                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\',\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__ws()
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                else:
                                    elements2 = None
                                    self._offset = index3
                            else:
                                elements2 = None
                                self._offset = index3
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                    if elements2 is None:
                        address4 = FAILURE
                    else:
                        address4 = TreeNode47(self._input[index3:self._offset], index3, elements2)
                        self._offset = self._offset
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index2:self._offset], index2, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address9 = FAILURE
                    index4 = self._offset
                    address9 = self._read_expression()
                    if address9 is FAILURE:
                        address9 = TreeNode(self._input[index4:index4], index4, [])
                        self._offset = index4
                    if address9 is not FAILURE:
                        elements0.append(address9)
                        address10 = FAILURE
                        address10 = self._read__()
                        if address10 is not FAILURE:
                            elements0.append(address10)
                            address11 = FAILURE
                            chunk2, max2 = None, self._offset + 1
                            if max2 <= self._input_size:
                                chunk2 = self._input[self._offset:max2]
                            if chunk2 == ')':
                                address11 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\')\'')
                            if address11 is not FAILURE:
                                address12 = FAILURE
                                address12 = self._read__()
                                if address12 is not FAILURE:
                                    elements0.append(address12)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.arg_list(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_args'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_params(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_params'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_basic_name()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ',':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\',\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read__ws()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode48(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address7 = FAILURE
            index4 = self._offset
            address7 = self._read_basic_name()
            if address7 is FAILURE:
                address7 = TreeNode(self._input[index4:index4], index4, [])
                self._offset = index4
            if address7 is not FAILURE:
                elements0.append(address7)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.param_list(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_params'][index0] = (address0, self._offset)
        return address0

    def _read_small_modifier_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['small_modifier_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_modifier_params()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == ':':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\':\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        index2 = self._offset
                        chunk1, max1 = None, self._offset + 1
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == '[':
                            address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'[\'')
                        self._offset = index2
                        if address5 is FAILURE:
                            address5 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address5 = FAILURE
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_expression()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.small_modifier_body(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['small_modifier_body'][index0] = (address0, self._offset)
        return address0

    def _read_normal_modifier_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['normal_modifier_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_modifier_params()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == ':':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\':\'')
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[index2:index2], index2, [])
                    self._offset = index2
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__ws()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        chunk1, max1 = None, self._offset + 1
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == '[':
                            address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'[\'')
                        if address5 is not FAILURE:
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                index3 = self._offset
                                address7 = self._read_block_body()
                                if address7 is FAILURE:
                                    address7 = TreeNode(self._input[index3:index3], index3, [])
                                    self._offset = index3
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                    address8 = FAILURE
                                    address8 = self._read__()
                                    if address8 is not FAILURE:
                                        elements0.append(address8)
                                        address9 = FAILURE
                                        chunk2, max2 = None, self._offset + 1
                                        if max2 <= self._input_size:
                                            chunk2 = self._input[self._offset:max2]
                                        if chunk2 == ']':
                                            address9 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address9 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\']\'')
                                        if address9 is not FAILURE:
                                            address10 = FAILURE
                                            address10 = self._read__()
                                            if address10 is not FAILURE:
                                                elements0.append(address10)
                                            else:
                                                elements0 = None
                                                self._offset = index1
                                        else:
                                            elements0 = None
                                            self._offset = index1
                                    else:
                                        elements0 = None
                                        self._offset = index1
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.normal_modifier_body(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['normal_modifier_body'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_def_target(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_def_target'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_access()
        if address0 is FAILURE:
            self._offset = index1
            index2, elements0 = self._offset, []
            address1 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '<':
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'<\'')
            if address1 is not FAILURE:
                address2 = FAILURE
                address2 = self._read__()
                if address2 is not FAILURE:
                    elements0.append(address2)
                    address3 = FAILURE
                    address3 = self._read_special_entry()
                    if address3 is not FAILURE:
                        elements0.append(address3)
                        address4 = FAILURE
                        address4 = self._read__()
                        if address4 is not FAILURE:
                            elements0.append(address4)
                            address5 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == '>':
                                address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address5 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'>\'')
                            if address5 is not FAILURE:
                                address6 = FAILURE
                                address6 = self._read__()
                                if address6 is not FAILURE:
                                    elements0.append(address6)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
            if elements0 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode51(self._input[index2:self._offset], index2, elements0)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '?':
                    address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'?\'')
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['modifier_def_target'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_def(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_def'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_modifier_def_target()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 2
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '<-':
                    address3 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<-\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    index2 = self._offset
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == '>':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>\'')
                    self._offset = index2
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__ws()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index3 = self._offset
                            address6 = self._read_small_modifier_body()
                            if address6 is FAILURE:
                                self._offset = index3
                                address6 = self._read_normal_modifier_body()
                                if address6 is FAILURE:
                                    self._offset = index3
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modifier_def(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_def'][index0] = (address0, self._offset)
        return address0

    def _read_lambda_def(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['lambda_def'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '!':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'!\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 2
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == '<-':
                    address3 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<-\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    index2 = self._offset
                    chunk2, max2 = None, self._offset + 1
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == '>':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>\'')
                    self._offset = index2
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__ws()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index3 = self._offset
                            address6 = self._read_small_modifier_body()
                            if address6 is FAILURE:
                                self._offset = index3
                                address6 = self._read_normal_modifier_body()
                                if address6 is FAILURE:
                                    self._offset = index3
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modifier_def(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['lambda_def'][index0] = (address0, self._offset)
        return address0

    def _read_then(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['then'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'then':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'then\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_stmt_or_expr()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode54(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['then'][index0] = (address0, self._offset)
        return address0

    def _read_if_then(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['if_then'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'if':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'if\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_expression()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_then()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.if_(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['if_then'][index0] = (address0, self._offset)
        return address0

    def _read_unless(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['unless'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 6
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'unless':
            address1 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
            self._offset = self._offset + 6
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'unless\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_expression()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_then()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.unless(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['unless'][index0] = (address0, self._offset)
        return address0

    def _read_otherwise(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['otherwise'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 9
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'otherwise':
            address1 = TreeNode(self._input[self._offset:self._offset + 9], self._offset, [])
            self._offset = self._offset + 9
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'otherwise\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_stmt_or_expr()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.otherwise(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['otherwise'][index0] = (address0, self._offset)
        return address0

    def _read_basic_load_list(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['basic_load_list'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_basic_name()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ',':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\',\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read__ws()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode58(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address7 = FAILURE
            index4 = self._offset
            address7 = self._read_basic_name()
            if address7 is FAILURE:
                address7 = TreeNode(self._input[index4:index4], index4, [])
                self._offset = index4
            if address7 is not FAILURE:
                elements0.append(address7)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['basic_load_list'][index0] = (address0, self._offset)
        return address0

    def _read_access_load_list(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['access_load_list'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_access()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ',':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\',\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read__ws()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode59(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address7 = FAILURE
            index4 = self._offset
            address7 = self._read_access()
            if address7 is FAILURE:
                address7 = TreeNode(self._input[index4:index4], index4, [])
                self._offset = index4
            if address7 is not FAILURE:
                elements0.append(address7)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['access_load_list'][index0] = (address0, self._offset)
        return address0

    def _read_loadable(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['loadable'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_new_bag()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_access_load_list()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['loadable'][index0] = (address0, self._offset)
        return address0

    def _read_load_into(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['load_into'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'into':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'into\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_access()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode60(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['load_into'][index0] = (address0, self._offset)
        return address0

    def _read_load_from(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['load_from'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'from':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'from\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_loadable()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode61(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['load_from'][index0] = (address0, self._offset)
        return address0

    def _read_load(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['load'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'load':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'load\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == '*':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'*\'')
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_load_from()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                index3 = self._offset
                                address7 = self._read_load_into()
                                if address7 is FAILURE:
                                    address7 = TreeNode(self._input[index3:index3], index3, [])
                                    self._offset = index3
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.load_from_into(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index4, elements1 = self._offset, []
            address8 = FAILURE
            chunk2, max2 = None, self._offset + 4
            if max2 <= self._input_size:
                chunk2 = self._input[self._offset:max2]
            if chunk2 == 'load':
                address8 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                self._offset = self._offset + 4
            else:
                address8 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'load\'')
            if address8 is not FAILURE:
                address9 = FAILURE
                address9 = self._read__()
                if address9 is not FAILURE:
                    elements1.append(address9)
                    address10 = FAILURE
                    address10 = self._read_loadable()
                    if address10 is not FAILURE:
                        elements1.append(address10)
                        address11 = FAILURE
                        address11 = self._read__()
                        if address11 is not FAILURE:
                            elements1.append(address11)
                            address12 = FAILURE
                            address12 = self._read_load_from()
                            if address12 is not FAILURE:
                                elements1.append(address12)
                                address13 = FAILURE
                                address13 = self._read__()
                                if address13 is not FAILURE:
                                    elements1.append(address13)
                                    address14 = FAILURE
                                    address14 = self._read_load_into()
                                    if address14 is not FAILURE:
                                        elements1.append(address14)
                                    else:
                                        elements1 = None
                                        self._offset = index4
                                else:
                                    elements1 = None
                                    self._offset = index4
                            else:
                                elements1 = None
                                self._offset = index4
                        else:
                            elements1 = None
                            self._offset = index4
                    else:
                        elements1 = None
                        self._offset = index4
                else:
                    elements1 = None
                    self._offset = index4
            else:
                elements1 = None
                self._offset = index4
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.load_from_into(self._input, index4, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index5, elements2 = self._offset, []
                address15 = FAILURE
                chunk3, max3 = None, self._offset + 4
                if max3 <= self._input_size:
                    chunk3 = self._input[self._offset:max3]
                if chunk3 == 'load':
                    address15 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                    self._offset = self._offset + 4
                else:
                    address15 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'load\'')
                if address15 is not FAILURE:
                    address16 = FAILURE
                    address16 = self._read__()
                    if address16 is not FAILURE:
                        elements2.append(address16)
                        address17 = FAILURE
                        address17 = self._read_loadable()
                        if address17 is not FAILURE:
                            elements2.append(address17)
                            address18 = FAILURE
                            address18 = self._read__()
                            if address18 is not FAILURE:
                                elements2.append(address18)
                                address19 = FAILURE
                                address19 = self._read_load_from()
                                if address19 is not FAILURE:
                                    elements2.append(address19)
                                else:
                                    elements2 = None
                                    self._offset = index5
                            else:
                                elements2 = None
                                self._offset = index5
                        else:
                            elements2 = None
                            self._offset = index5
                    else:
                        elements2 = None
                        self._offset = index5
                else:
                    elements2 = None
                    self._offset = index5
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.load_from(self._input, index5, self._offset, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index6, elements3 = self._offset, []
                    address20 = FAILURE
                    chunk4, max4 = None, self._offset + 4
                    if max4 <= self._input_size:
                        chunk4 = self._input[self._offset:max4]
                    if chunk4 == 'load':
                        address20 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                        self._offset = self._offset + 4
                    else:
                        address20 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'load\'')
                    if address20 is not FAILURE:
                        address21 = FAILURE
                        address21 = self._read__()
                        if address21 is not FAILURE:
                            elements3.append(address21)
                            address22 = FAILURE
                            address22 = self._read_loadable()
                            if address22 is not FAILURE:
                                elements3.append(address22)
                                address23 = FAILURE
                                address23 = self._read__()
                                if address23 is not FAILURE:
                                    elements3.append(address23)
                                    address24 = FAILURE
                                    address24 = self._read_load_into()
                                    if address24 is not FAILURE:
                                        elements3.append(address24)
                                    else:
                                        elements3 = None
                                        self._offset = index6
                                else:
                                    elements3 = None
                                    self._offset = index6
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                    if elements3 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.load_into(self._input, index6, self._offset, elements3)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index7, elements4 = self._offset, []
                        address25 = FAILURE
                        chunk5, max5 = None, self._offset + 4
                        if max5 <= self._input_size:
                            chunk5 = self._input[self._offset:max5]
                        if chunk5 == 'load':
                            address25 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                            self._offset = self._offset + 4
                        else:
                            address25 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'load\'')
                        if address25 is not FAILURE:
                            address26 = FAILURE
                            address26 = self._read__()
                            if address26 is not FAILURE:
                                elements4.append(address26)
                                address27 = FAILURE
                                address27 = self._read_loadable()
                                if address27 is not FAILURE:
                                    elements4.append(address27)
                                else:
                                    elements4 = None
                                    self._offset = index7
                            else:
                                elements4 = None
                                self._offset = index7
                        else:
                            elements4 = None
                            self._offset = index7
                        if elements4 is None:
                            address0 = FAILURE
                        else:
                            address0 = self._actions.load(self._input, index7, self._offset, elements4)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['load'][index0] = (address0, self._offset)
        return address0

    def _read_except_when(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['except_when'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 6
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'except':
            address1 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
            self._offset = self._offset + 6
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'except\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 4
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == 'when':
                    address3 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                    self._offset = self._offset + 4
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'when\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_expression()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_then()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.predicated_statement(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['except_when'][index0] = (address0, self._offset)
        return address0

    def _read_restart_pos(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['restart_pos'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 6
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'before':
            address1 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
            self._offset = self._offset + 6
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'before\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index3 = self._offset
                address3 = self._read_name()
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[index3:index3], index3, [])
                    self._offset = index3
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.restart(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index4, elements1 = self._offset, []
            address4 = FAILURE
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'at':
                address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                self._offset = self._offset + 2
            else:
                address4 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'at\'')
            if address4 is not FAILURE:
                elements1.append(address4)
                address5 = FAILURE
                address5 = self._read__()
                if address5 is not FAILURE:
                    elements1.append(address5)
                    address6 = FAILURE
                    index5 = self._offset
                    address6 = self._read_name()
                    if address6 is FAILURE:
                        address6 = TreeNode(self._input[index5:index5], index5, [])
                        self._offset = index5
                    if address6 is not FAILURE:
                        elements1.append(address6)
                    else:
                        elements1 = None
                        self._offset = index4
                else:
                    elements1 = None
                    self._offset = index4
            else:
                elements1 = None
                self._offset = index4
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.restart(self._input, index4, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index6, elements2 = self._offset, []
                address7 = FAILURE
                chunk2, max2 = None, self._offset + 5
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == 'after':
                    address7 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                    self._offset = self._offset + 5
                else:
                    address7 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'after\'')
                if address7 is not FAILURE:
                    elements2.append(address7)
                    address8 = FAILURE
                    address8 = self._read__()
                    if address8 is not FAILURE:
                        elements2.append(address8)
                        address9 = FAILURE
                        index7 = self._offset
                        address9 = self._read_name()
                        if address9 is FAILURE:
                            address9 = TreeNode(self._input[index7:index7], index7, [])
                            self._offset = index7
                        if address9 is not FAILURE:
                            elements2.append(address9)
                        else:
                            elements2 = None
                            self._offset = index6
                    else:
                        elements2 = None
                        self._offset = index6
                else:
                    elements2 = None
                    self._offset = index6
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.restart(self._input, index6, self._offset, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['restart_pos'][index0] = (address0, self._offset)
        return address0

    def _read_stmt_or_expr(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['stmt_or_expr'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_statement()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_expression()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['stmt_or_expr'][index0] = (address0, self._offset)
        return address0

    def _read_block_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['block_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_statement()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    index4 = self._offset
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ']':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\']\'')
                    self._offset = index4
                    if address5 is FAILURE:
                        address5 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address5 = FAILURE
                    if address5 is not FAILURE:
                        elements2.append(address5)
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode72(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address6 = FAILURE
            address6 = self._read__()
            if address6 is not FAILURE:
                elements0.append(address6)
                address7 = FAILURE
                address7 = self._read_statement()
                if address7 is not FAILURE:
                    elements0.append(address7)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode71(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['block_body'][index0] = (address0, self._offset)
        return address0

    def _read_loop_name(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['loop_name'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '@':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'@\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_basic_name()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.loop_name(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['loop_name'][index0] = (address0, self._offset)
        return address0

    def _read_loop_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['loop_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'do':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'do\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                address3 = FAILURE
                address3 = self._read_stmt_or_expr()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.loop_body(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['loop_body'][index0] = (address0, self._offset)
        return address0

    def _read_but_if_stmt(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['but_if_stmt'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_expression()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index3 = self._offset
                chunk0, max0 = None, self._offset + 3
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == 'but':
                    address3 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                    self._offset = self._offset + 3
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'but\'')
                self._offset = index3
                if address3 is not FAILURE:
                    address3 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode75(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_stmt_or_expr()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['but_if_stmt'][index0] = (address0, self._offset)
        return address0

    def _read_but_if(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['but_if'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'but':
            address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
            self._offset = self._offset + 3
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'but\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            index2 = self._offset
            chunk1, max1 = None, self._offset + 6
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'always':
                address2 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                self._offset = self._offset + 6
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'always\'')
            self._offset = index2
            if address2 is FAILURE:
                address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    chunk2, max2 = None, self._offset + 2
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == 'if':
                        address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                        self._offset = self._offset + 2
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'if\'')
                    if address4 is not FAILURE:
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index3 = self._offset
                            address6 = self._read_expression()
                            if address6 is FAILURE:
                                self._offset = index3
                                chunk3, max3 = None, self._offset + 1
                                if max3 <= self._input_size:
                                    chunk3 = self._input[self._offset:max3]
                                if chunk3 == '*':
                                    address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address6 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'*\'')
                                if address6 is FAILURE:
                                    self._offset = index3
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read__()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                    address8 = FAILURE
                                    chunk4, max4 = None, self._offset + 6
                                    if max4 <= self._input_size:
                                        chunk4 = self._input[self._offset:max4]
                                    if chunk4 == 'occurs':
                                        address8 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                        self._offset = self._offset + 6
                                    else:
                                        address8 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'occurs\'')
                                    if address8 is not FAILURE:
                                        address9 = FAILURE
                                        address9 = self._read__()
                                        if address9 is not FAILURE:
                                            elements0.append(address9)
                                            address10 = FAILURE
                                            address10 = self._read_then()
                                            if address10 is not FAILURE:
                                                elements0.append(address10)
                                            else:
                                                elements0 = None
                                                self._offset = index1
                                        else:
                                            elements0 = None
                                            self._offset = index1
                                    else:
                                        elements0 = None
                                        self._offset = index1
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.but_if(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['but_if'][index0] = (address0, self._offset)
        return address0

    def _read_always(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['always'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'but':
            address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
            self._offset = self._offset + 3
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'but\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 6
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == 'always':
                    address3 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                    self._offset = self._offset + 6
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'always\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__ws()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_stmt_or_expr()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.always(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['always'][index0] = (address0, self._offset)
        return address0

    def _read_attempt(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['attempt'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 7
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'attempt':
            address1 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
            self._offset = self._offset + 7
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'attempt\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_but_if_stmt()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__ws()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_always()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.attempt(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address6 = FAILURE
            chunk1, max1 = None, self._offset + 7
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'attempt':
                address6 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                self._offset = self._offset + 7
            else:
                address6 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'attempt\'')
            if address6 is not FAILURE:
                address7 = FAILURE
                address7 = self._read__ws()
                if address7 is not FAILURE:
                    elements1.append(address7)
                    address8 = FAILURE
                    address8 = self._read_but_if_stmt()
                    if address8 is not FAILURE:
                        elements1.append(address8)
                        address9 = FAILURE
                        address9 = self._read__ws()
                        if address9 is not FAILURE:
                            elements1.append(address9)
                            address10 = FAILURE
                            remaining0, index4, elements2, address11 = 1, self._offset, [], True
                            while address11 is not FAILURE:
                                address11 = self._read_but_if()
                                if address11 is not FAILURE:
                                    elements2.append(address11)
                                    remaining0 -= 1
                            if remaining0 <= 0:
                                address10 = TreeNode(self._input[index4:self._offset], index4, elements2)
                                self._offset = self._offset
                            else:
                                address10 = FAILURE
                            if address10 is not FAILURE:
                                elements1.append(address10)
                                address12 = FAILURE
                                index5 = self._offset
                                index6, elements3 = self._offset, []
                                address13 = FAILURE
                                address13 = self._read__ws()
                                if address13 is not FAILURE:
                                    elements3.append(address13)
                                    address14 = FAILURE
                                    address14 = self._read_always()
                                    if address14 is not FAILURE:
                                        elements3.append(address14)
                                    else:
                                        elements3 = None
                                        self._offset = index6
                                else:
                                    elements3 = None
                                    self._offset = index6
                                if elements3 is None:
                                    address12 = FAILURE
                                else:
                                    address12 = TreeNode80(self._input[index6:self._offset], index6, elements3)
                                    self._offset = self._offset
                                if address12 is FAILURE:
                                    address12 = TreeNode(self._input[index5:index5], index5, [])
                                    self._offset = index5
                                if address12 is not FAILURE:
                                    elements1.append(address12)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.attempt(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index7, elements4 = self._offset, []
                address15 = FAILURE
                chunk2, max2 = None, self._offset + 7
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == 'attempt':
                    address15 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                    self._offset = self._offset + 7
                else:
                    address15 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'attempt\'')
                if address15 is not FAILURE:
                    address16 = FAILURE
                    address16 = self._read__ws()
                    if address16 is not FAILURE:
                        elements4.append(address16)
                        address17 = FAILURE
                        address17 = self._read_but_if_stmt()
                        if address17 is not FAILURE:
                            elements4.append(address17)
                        else:
                            elements4 = None
                            self._offset = index7
                    else:
                        elements4 = None
                        self._offset = index7
                else:
                    elements4 = None
                    self._offset = index7
                if elements4 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.attempt(self._input, index7, self._offset, elements4)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['attempt'][index0] = (address0, self._offset)
        return address0

    def _read_statement(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['statement'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_eos()
        if address0 is FAILURE:
            self._offset = index1
            chunk0, max0 = None, self._offset + 5
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == 'leave':
                address0 = self._actions.leave(self._input, self._offset, self._offset + 5, [])
                self._offset = self._offset + 5
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'leave\'')
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_attempt()
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk1, max1 = None, self._offset + 4
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == 'oops':
                        address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                        self._offset = self._offset + 4
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'oops\'')
                    if address1 is not FAILURE:
                        address2 = FAILURE
                        address2 = self._read__()
                        if address2 is not FAILURE:
                            elements0.append(address2)
                            address3 = FAILURE
                            address3 = self._read_expression()
                            if address3 is not FAILURE:
                                elements0.append(address3)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.oops(self._input, index2, self._offset, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index3, elements1 = self._offset, []
                        address4 = FAILURE
                        chunk2, max2 = None, self._offset + 5
                        if max2 <= self._input_size:
                            chunk2 = self._input[self._offset:max2]
                        if chunk2 == 'clear':
                            address4 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                            self._offset = self._offset + 5
                        else:
                            address4 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'clear\'')
                        if address4 is not FAILURE:
                            address5 = FAILURE
                            address5 = self._read__()
                            if address5 is not FAILURE:
                                elements1.append(address5)
                                address6 = FAILURE
                                address6 = self._read_access()
                                if address6 is not FAILURE:
                                    elements1.append(address6)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                        if elements1 is None:
                            address0 = FAILURE
                        else:
                            address0 = self._actions.clear(self._input, index3, self._offset, elements1)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
                            index4, elements2 = self._offset, []
                            address7 = FAILURE
                            chunk3, max3 = None, self._offset + 7
                            if max3 <= self._input_size:
                                chunk3 = self._input[self._offset:max3]
                            if chunk3 == 'restart':
                                address7 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                self._offset = self._offset + 7
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'restart\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__()
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                    address9 = FAILURE
                                    address9 = self._read_restart_pos()
                                    if address9 is not FAILURE:
                                        elements2.append(address9)
                                    else:
                                        elements2 = None
                                        self._offset = index4
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                            if elements2 is None:
                                address0 = FAILURE
                            else:
                                address0 = TreeNode84(self._input[index4:self._offset], index4, elements2)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
                                index5, elements3 = self._offset, []
                                address10 = FAILURE
                                chunk4, max4 = None, self._offset + 1
                                if max4 <= self._input_size:
                                    chunk4 = self._input[self._offset:max4]
                                if chunk4 == '[':
                                    address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address10 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'[\'')
                                if address10 is not FAILURE:
                                    address11 = FAILURE
                                    index6 = self._offset
                                    chunk5, max5 = None, self._offset + 1
                                    if max5 <= self._input_size:
                                        chunk5 = self._input[self._offset:max5]
                                    if chunk5 == ':':
                                        address11 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address11 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\':\'')
                                    self._offset = index6
                                    if address11 is FAILURE:
                                        address11 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                        self._offset = self._offset
                                    else:
                                        address11 = FAILURE
                                    if address11 is not FAILURE:
                                        elements3.append(address11)
                                        address12 = FAILURE
                                        address12 = self._read__ws()
                                        if address12 is not FAILURE:
                                            elements3.append(address12)
                                            address13 = FAILURE
                                            address13 = self._read_block_body()
                                            if address13 is not FAILURE:
                                                elements3.append(address13)
                                                address14 = FAILURE
                                                address14 = self._read__ws()
                                                if address14 is not FAILURE:
                                                    elements3.append(address14)
                                                    address15 = FAILURE
                                                    chunk6, max6 = None, self._offset + 1
                                                    if max6 <= self._input_size:
                                                        chunk6 = self._input[self._offset:max6]
                                                    if chunk6 == ']':
                                                        address15 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                        self._offset = self._offset + 1
                                                    else:
                                                        address15 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('\']\'')
                                                    if address15 is not FAILURE:
                                                        address16 = FAILURE
                                                        address16 = self._read__()
                                                        if address16 is not FAILURE:
                                                            elements3.append(address16)
                                                        else:
                                                            elements3 = None
                                                            self._offset = index5
                                                    else:
                                                        elements3 = None
                                                        self._offset = index5
                                                else:
                                                    elements3 = None
                                                    self._offset = index5
                                            else:
                                                elements3 = None
                                                self._offset = index5
                                        else:
                                            elements3 = None
                                            self._offset = index5
                                    else:
                                        elements3 = None
                                        self._offset = index5
                                else:
                                    elements3 = None
                                    self._offset = index5
                                if elements3 is None:
                                    address0 = FAILURE
                                else:
                                    address0 = self._actions.block(self._input, index5, self._offset, elements3)
                                    self._offset = self._offset
                                if address0 is FAILURE:
                                    self._offset = index1
                                    index7, elements4 = self._offset, []
                                    address17 = FAILURE
                                    chunk7, max7 = None, self._offset + 1
                                    if max7 <= self._input_size:
                                        chunk7 = self._input[self._offset:max7]
                                    if chunk7 == '[':
                                        address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address17 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'[\'')
                                    if address17 is not FAILURE:
                                        address18 = FAILURE
                                        index8 = self._offset
                                        chunk8, max8 = None, self._offset + 1
                                        if max8 <= self._input_size:
                                            chunk8 = self._input[self._offset:max8]
                                        if chunk8 == ':':
                                            address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address18 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\':\'')
                                        self._offset = index8
                                        if address18 is FAILURE:
                                            address18 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                            self._offset = self._offset
                                        else:
                                            address18 = FAILURE
                                        if address18 is not FAILURE:
                                            elements4.append(address18)
                                            address19 = FAILURE
                                            address19 = self._read__ws()
                                            if address19 is not FAILURE:
                                                elements4.append(address19)
                                                address20 = FAILURE
                                                chunk9, max9 = None, self._offset + 1
                                                if max9 <= self._input_size:
                                                    chunk9 = self._input[self._offset:max9]
                                                if chunk9 == ']':
                                                    address20 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                    self._offset = self._offset + 1
                                                else:
                                                    address20 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('\']\'')
                                                if address20 is not FAILURE:
                                                    address21 = FAILURE
                                                    address21 = self._read__()
                                                    if address21 is not FAILURE:
                                                        elements4.append(address21)
                                                    else:
                                                        elements4 = None
                                                        self._offset = index7
                                                else:
                                                    elements4 = None
                                                    self._offset = index7
                                            else:
                                                elements4 = None
                                                self._offset = index7
                                        else:
                                            elements4 = None
                                            self._offset = index7
                                    else:
                                        elements4 = None
                                        self._offset = index7
                                    if elements4 is None:
                                        address0 = FAILURE
                                    else:
                                        address0 = self._actions.block(self._input, index7, self._offset, elements4)
                                        self._offset = self._offset
                                    if address0 is FAILURE:
                                        self._offset = index1
                                        index9, elements5 = self._offset, []
                                        address22 = FAILURE
                                        chunk10, max10 = None, self._offset + 2
                                        if max10 <= self._input_size:
                                            chunk10 = self._input[self._offset:max10]
                                        if chunk10 == '={':
                                            address22 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                            self._offset = self._offset + 2
                                        else:
                                            address22 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'={\'')
                                        if address22 is not FAILURE:
                                            address23 = FAILURE
                                            index10 = self._offset
                                            chunk11, max11 = None, self._offset + 1
                                            if max11 <= self._input_size:
                                                chunk11 = self._input[self._offset:max11]
                                            if chunk11 == ':':
                                                address23 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                self._offset = self._offset + 1
                                            else:
                                                address23 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('\':\'')
                                            self._offset = index10
                                            if address23 is FAILURE:
                                                address23 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                self._offset = self._offset
                                            else:
                                                address23 = FAILURE
                                            if address23 is not FAILURE:
                                                elements5.append(address23)
                                                address24 = FAILURE
                                                address24 = self._read__()
                                                if address24 is not FAILURE:
                                                    elements5.append(address24)
                                                    address25 = FAILURE
                                                    address25 = self._read_access()
                                                    if address25 is not FAILURE:
                                                        elements5.append(address25)
                                                        address26 = FAILURE
                                                        address26 = self._read__()
                                                        if address26 is not FAILURE:
                                                            elements5.append(address26)
                                                            address27 = FAILURE
                                                            chunk12, max12 = None, self._offset + 1
                                                            if max12 <= self._input_size:
                                                                chunk12 = self._input[self._offset:max12]
                                                            if chunk12 == '}':
                                                                address27 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                self._offset = self._offset + 1
                                                            else:
                                                                address27 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'}\'')
                                                            if address27 is not FAILURE:
                                                                address28 = FAILURE
                                                                address28 = self._read__()
                                                                if address28 is not FAILURE:
                                                                    elements5.append(address28)
                                                                else:
                                                                    elements5 = None
                                                                    self._offset = index9
                                                            else:
                                                                elements5 = None
                                                                self._offset = index9
                                                        else:
                                                            elements5 = None
                                                            self._offset = index9
                                                    else:
                                                        elements5 = None
                                                        self._offset = index9
                                                else:
                                                    elements5 = None
                                                    self._offset = index9
                                            else:
                                                elements5 = None
                                                self._offset = index9
                                        else:
                                            elements5 = None
                                            self._offset = index9
                                        if elements5 is None:
                                            address0 = FAILURE
                                        else:
                                            address0 = self._actions.reduce_and_assign(self._input, index9, self._offset, elements5)
                                            self._offset = self._offset
                                        if address0 is FAILURE:
                                            self._offset = index1
                                            address0 = self._read_load()
                                            if address0 is FAILURE:
                                                self._offset = index1
                                                address0 = self._read_modifier_def()
                                                if address0 is FAILURE:
                                                    self._offset = index1
                                                    index11, elements6 = self._offset, []
                                                    address29 = FAILURE
                                                    address29 = self._read_if_then()
                                                    if address29 is not FAILURE:
                                                        elements6.append(address29)
                                                        address30 = FAILURE
                                                        remaining0, index12, elements7, address31 = 0, self._offset, [], True
                                                        while address31 is not FAILURE:
                                                            index13, elements8 = self._offset, []
                                                            address32 = FAILURE
                                                            address32 = self._read__ws()
                                                            if address32 is not FAILURE:
                                                                elements8.append(address32)
                                                                address33 = FAILURE
                                                                address33 = self._read_unless()
                                                                if address33 is not FAILURE:
                                                                    elements8.append(address33)
                                                                else:
                                                                    elements8 = None
                                                                    self._offset = index13
                                                            else:
                                                                elements8 = None
                                                                self._offset = index13
                                                            if elements8 is None:
                                                                address31 = FAILURE
                                                            else:
                                                                address31 = TreeNode89(self._input[index13:self._offset], index13, elements8)
                                                                self._offset = self._offset
                                                            if address31 is not FAILURE:
                                                                elements7.append(address31)
                                                                remaining0 -= 1
                                                        if remaining0 <= 0:
                                                            address30 = TreeNode(self._input[index12:self._offset], index12, elements7)
                                                            self._offset = self._offset
                                                        else:
                                                            address30 = FAILURE
                                                        if address30 is not FAILURE:
                                                            elements6.append(address30)
                                                            address34 = FAILURE
                                                            index14 = self._offset
                                                            index15, elements9 = self._offset, []
                                                            address35 = FAILURE
                                                            address35 = self._read__ws()
                                                            if address35 is not FAILURE:
                                                                elements9.append(address35)
                                                                address36 = FAILURE
                                                                address36 = self._read_otherwise()
                                                                if address36 is not FAILURE:
                                                                    elements9.append(address36)
                                                                else:
                                                                    elements9 = None
                                                                    self._offset = index15
                                                            else:
                                                                elements9 = None
                                                                self._offset = index15
                                                            if elements9 is None:
                                                                address34 = FAILURE
                                                            else:
                                                                address34 = TreeNode90(self._input[index15:self._offset], index15, elements9)
                                                                self._offset = self._offset
                                                            if address34 is FAILURE:
                                                                address34 = TreeNode(self._input[index14:index14], index14, [])
                                                                self._offset = index14
                                                            if address34 is not FAILURE:
                                                                elements6.append(address34)
                                                            else:
                                                                elements6 = None
                                                                self._offset = index11
                                                        else:
                                                            elements6 = None
                                                            self._offset = index11
                                                    else:
                                                        elements6 = None
                                                        self._offset = index11
                                                    if elements6 is None:
                                                        address0 = FAILURE
                                                    else:
                                                        address0 = self._actions.if_stmt(self._input, index11, self._offset, elements6)
                                                        self._offset = self._offset
                                                    if address0 is FAILURE:
                                                        self._offset = index1
                                                        index16, elements10 = self._offset, []
                                                        address37 = FAILURE
                                                        chunk13, max13 = None, self._offset + 3
                                                        if max13 <= self._input_size:
                                                            chunk13 = self._input[self._offset:max13]
                                                        if chunk13 == 'for':
                                                            address37 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                            self._offset = self._offset + 3
                                                        else:
                                                            address37 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('\'for\'')
                                                        if address37 is not FAILURE:
                                                            address38 = FAILURE
                                                            address38 = self._read__()
                                                            if address38 is not FAILURE:
                                                                elements10.append(address38)
                                                                address39 = FAILURE
                                                                chunk14, max14 = None, self._offset + 5
                                                                if max14 <= self._input_size:
                                                                    chunk14 = self._input[self._offset:max14]
                                                                if chunk14 == 'every':
                                                                    address39 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                                                    self._offset = self._offset + 5
                                                                else:
                                                                    address39 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('\'every\'')
                                                                if address39 is not FAILURE:
                                                                    address40 = FAILURE
                                                                    address40 = self._read__()
                                                                    if address40 is not FAILURE:
                                                                        elements10.append(address40)
                                                                        address41 = FAILURE
                                                                        index17 = self._offset
                                                                        address41 = self._read_loop_name()
                                                                        if address41 is FAILURE:
                                                                            address41 = TreeNode(self._input[index17:index17], index17, [])
                                                                            self._offset = index17
                                                                        if address41 is not FAILURE:
                                                                            elements10.append(address41)
                                                                            address42 = FAILURE
                                                                            address42 = self._read__()
                                                                            if address42 is not FAILURE:
                                                                                elements10.append(address42)
                                                                                address43 = FAILURE
                                                                                address43 = self._read_basic_name()
                                                                                if address43 is not FAILURE:
                                                                                    elements10.append(address43)
                                                                                    address44 = FAILURE
                                                                                    address44 = self._read__()
                                                                                    if address44 is not FAILURE:
                                                                                        elements10.append(address44)
                                                                                        address45 = FAILURE
                                                                                        chunk15, max15 = None, self._offset + 4
                                                                                        if max15 <= self._input_size:
                                                                                            chunk15 = self._input[self._offset:max15]
                                                                                        if chunk15 == 'that':
                                                                                            address45 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                            self._offset = self._offset + 4
                                                                                        else:
                                                                                            address45 = FAILURE
                                                                                            if self._offset > self._failure:
                                                                                                self._failure = self._offset
                                                                                                self._expected = []
                                                                                            if self._offset == self._failure:
                                                                                                self._expected.append('\'that\'')
                                                                                        if address45 is not FAILURE:
                                                                                            address46 = FAILURE
                                                                                            address46 = self._read__()
                                                                                            if address46 is not FAILURE:
                                                                                                elements10.append(address46)
                                                                                                address47 = FAILURE
                                                                                                address47 = self._read_expression()
                                                                                                if address47 is not FAILURE:
                                                                                                    elements10.append(address47)
                                                                                                    address48 = FAILURE
                                                                                                    address48 = self._read__()
                                                                                                    if address48 is not FAILURE:
                                                                                                        elements10.append(address48)
                                                                                                        address49 = FAILURE
                                                                                                        chunk16, max16 = None, self._offset + 3
                                                                                                        if max16 <= self._input_size:
                                                                                                            chunk16 = self._input[self._offset:max16]
                                                                                                        if chunk16 == 'has':
                                                                                                            address49 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                            self._offset = self._offset + 3
                                                                                                        else:
                                                                                                            address49 = FAILURE
                                                                                                            if self._offset > self._failure:
                                                                                                                self._failure = self._offset
                                                                                                                self._expected = []
                                                                                                            if self._offset == self._failure:
                                                                                                                self._expected.append('\'has\'')
                                                                                                        if address49 is not FAILURE:
                                                                                                            address50 = FAILURE
                                                                                                            address50 = self._read__()
                                                                                                            if address50 is not FAILURE:
                                                                                                                elements10.append(address50)
                                                                                                                address51 = FAILURE
                                                                                                                address51 = self._read_loop_body()
                                                                                                                if address51 is not FAILURE:
                                                                                                                    elements10.append(address51)
                                                                                                                else:
                                                                                                                    elements10 = None
                                                                                                                    self._offset = index16
                                                                                                            else:
                                                                                                                elements10 = None
                                                                                                                self._offset = index16
                                                                                                        else:
                                                                                                            elements10 = None
                                                                                                            self._offset = index16
                                                                                                    else:
                                                                                                        elements10 = None
                                                                                                        self._offset = index16
                                                                                                else:
                                                                                                    elements10 = None
                                                                                                    self._offset = index16
                                                                                            else:
                                                                                                elements10 = None
                                                                                                self._offset = index16
                                                                                        else:
                                                                                            elements10 = None
                                                                                            self._offset = index16
                                                                                    else:
                                                                                        elements10 = None
                                                                                        self._offset = index16
                                                                                else:
                                                                                    elements10 = None
                                                                                    self._offset = index16
                                                                            else:
                                                                                elements10 = None
                                                                                self._offset = index16
                                                                        else:
                                                                            elements10 = None
                                                                            self._offset = index16
                                                                    else:
                                                                        elements10 = None
                                                                        self._offset = index16
                                                                else:
                                                                    elements10 = None
                                                                    self._offset = index16
                                                            else:
                                                                elements10 = None
                                                                self._offset = index16
                                                        else:
                                                            elements10 = None
                                                            self._offset = index16
                                                        if elements10 is None:
                                                            address0 = FAILURE
                                                        else:
                                                            address0 = self._actions.for_every(self._input, index16, self._offset, elements10)
                                                            self._offset = self._offset
                                                        if address0 is FAILURE:
                                                            self._offset = index1
                                                            index18, elements11 = self._offset, []
                                                            address52 = FAILURE
                                                            chunk17, max17 = None, self._offset + 5
                                                            if max17 <= self._input_size:
                                                                chunk17 = self._input[self._offset:max17]
                                                            if chunk17 == 'until':
                                                                address52 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                                                self._offset = self._offset + 5
                                                            else:
                                                                address52 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'until\'')
                                                            if address52 is not FAILURE:
                                                                address53 = FAILURE
                                                                address53 = self._read__()
                                                                if address53 is not FAILURE:
                                                                    elements11.append(address53)
                                                                    address54 = FAILURE
                                                                    index19 = self._offset
                                                                    address54 = self._read_loop_name()
                                                                    if address54 is FAILURE:
                                                                        address54 = TreeNode(self._input[index19:index19], index19, [])
                                                                        self._offset = index19
                                                                    if address54 is not FAILURE:
                                                                        elements11.append(address54)
                                                                        address55 = FAILURE
                                                                        address55 = self._read__()
                                                                        if address55 is not FAILURE:
                                                                            elements11.append(address55)
                                                                            address56 = FAILURE
                                                                            address56 = self._read_expression()
                                                                            if address56 is not FAILURE:
                                                                                elements11.append(address56)
                                                                                address57 = FAILURE
                                                                                address57 = self._read__()
                                                                                if address57 is not FAILURE:
                                                                                    elements11.append(address57)
                                                                                    address58 = FAILURE
                                                                                    address58 = self._read_loop_body()
                                                                                    if address58 is not FAILURE:
                                                                                        elements11.append(address58)
                                                                                        address59 = FAILURE
                                                                                        address59 = self._read__ws()
                                                                                        if address59 is not FAILURE:
                                                                                            elements11.append(address59)
                                                                                            address60 = FAILURE
                                                                                            remaining1, index20, elements12, address61 = 0, self._offset, [], True
                                                                                            while address61 is not FAILURE:
                                                                                                index21, elements13 = self._offset, []
                                                                                                address62 = FAILURE
                                                                                                address62 = self._read_except_when()
                                                                                                if address62 is not FAILURE:
                                                                                                    elements13.append(address62)
                                                                                                    address63 = FAILURE
                                                                                                    address63 = self._read__ws()
                                                                                                    if address63 is not FAILURE:
                                                                                                        elements13.append(address63)
                                                                                                    else:
                                                                                                        elements13 = None
                                                                                                        self._offset = index21
                                                                                                else:
                                                                                                    elements13 = None
                                                                                                    self._offset = index21
                                                                                                if elements13 is None:
                                                                                                    address61 = FAILURE
                                                                                                else:
                                                                                                    address61 = TreeNode93(self._input[index21:self._offset], index21, elements13)
                                                                                                    self._offset = self._offset
                                                                                                if address61 is not FAILURE:
                                                                                                    elements12.append(address61)
                                                                                                    remaining1 -= 1
                                                                                            if remaining1 <= 0:
                                                                                                address60 = TreeNode(self._input[index20:self._offset], index20, elements12)
                                                                                                self._offset = self._offset
                                                                                            else:
                                                                                                address60 = FAILURE
                                                                                            if address60 is not FAILURE:
                                                                                                elements11.append(address60)
                                                                                                address64 = FAILURE
                                                                                                index22 = self._offset
                                                                                                address64 = self._read_otherwise()
                                                                                                if address64 is FAILURE:
                                                                                                    address64 = TreeNode(self._input[index22:index22], index22, [])
                                                                                                    self._offset = index22
                                                                                                if address64 is not FAILURE:
                                                                                                    elements11.append(address64)
                                                                                                else:
                                                                                                    elements11 = None
                                                                                                    self._offset = index18
                                                                                            else:
                                                                                                elements11 = None
                                                                                                self._offset = index18
                                                                                        else:
                                                                                            elements11 = None
                                                                                            self._offset = index18
                                                                                    else:
                                                                                        elements11 = None
                                                                                        self._offset = index18
                                                                                else:
                                                                                    elements11 = None
                                                                                    self._offset = index18
                                                                            else:
                                                                                elements11 = None
                                                                                self._offset = index18
                                                                        else:
                                                                            elements11 = None
                                                                            self._offset = index18
                                                                    else:
                                                                        elements11 = None
                                                                        self._offset = index18
                                                                else:
                                                                    elements11 = None
                                                                    self._offset = index18
                                                            else:
                                                                elements11 = None
                                                                self._offset = index18
                                                            if elements11 is None:
                                                                address0 = FAILURE
                                                            else:
                                                                address0 = self._actions.until_do(self._input, index18, self._offset, elements11)
                                                                self._offset = self._offset
                                                            if address0 is FAILURE:
                                                                self._offset = index1
                                                                index23, elements14 = self._offset, []
                                                                address65 = FAILURE
                                                                address65 = self._read_access()
                                                                if address65 is not FAILURE:
                                                                    elements14.append(address65)
                                                                    address66 = FAILURE
                                                                    address66 = self._read__()
                                                                    if address66 is not FAILURE:
                                                                        elements14.append(address66)
                                                                        address67 = FAILURE
                                                                        chunk18, max18 = None, self._offset + 2
                                                                        if max18 <= self._input_size:
                                                                            chunk18 = self._input[self._offset:max18]
                                                                        if chunk18 == '=>':
                                                                            address67 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                            self._offset = self._offset + 2
                                                                        else:
                                                                            address67 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('\'=>\'')
                                                                        if address67 is not FAILURE:
                                                                            address68 = FAILURE
                                                                            address68 = self._read__()
                                                                            if address68 is not FAILURE:
                                                                                elements14.append(address68)
                                                                                address69 = FAILURE
                                                                                address69 = self._read_modifier_tail()
                                                                                if address69 is not FAILURE:
                                                                                    elements14.append(address69)
                                                                                    address70 = FAILURE
                                                                                    remaining2, index24, elements15, address71 = 0, self._offset, [], True
                                                                                    while address71 is not FAILURE:
                                                                                        address71 = self._read_modifier_call()
                                                                                        if address71 is not FAILURE:
                                                                                            elements15.append(address71)
                                                                                            remaining2 -= 1
                                                                                    if remaining2 <= 0:
                                                                                        address70 = TreeNode(self._input[index24:self._offset], index24, elements15)
                                                                                        self._offset = self._offset
                                                                                    else:
                                                                                        address70 = FAILURE
                                                                                    if address70 is not FAILURE:
                                                                                        elements14.append(address70)
                                                                                    else:
                                                                                        elements14 = None
                                                                                        self._offset = index23
                                                                                else:
                                                                                    elements14 = None
                                                                                    self._offset = index23
                                                                            else:
                                                                                elements14 = None
                                                                                self._offset = index23
                                                                        else:
                                                                            elements14 = None
                                                                            self._offset = index23
                                                                    else:
                                                                        elements14 = None
                                                                        self._offset = index23
                                                                else:
                                                                    elements14 = None
                                                                    self._offset = index23
                                                                if elements14 is None:
                                                                    address0 = FAILURE
                                                                else:
                                                                    address0 = self._actions.modify_and_assign(self._input, index23, self._offset, elements14)
                                                                    self._offset = self._offset
                                                                if address0 is FAILURE:
                                                                    self._offset = index1
                                                                    index25, elements16 = self._offset, []
                                                                    address72 = FAILURE
                                                                    address72 = self._read_access()
                                                                    if address72 is not FAILURE:
                                                                        elements16.append(address72)
                                                                        address73 = FAILURE
                                                                        address73 = self._read__()
                                                                        if address73 is not FAILURE:
                                                                            elements16.append(address73)
                                                                            address74 = FAILURE
                                                                            address74 = self._read_assign_op()
                                                                            if address74 is not FAILURE:
                                                                                elements16.append(address74)
                                                                                address75 = FAILURE
                                                                                address75 = self._read__ws()
                                                                                if address75 is not FAILURE:
                                                                                    elements16.append(address75)
                                                                                    address76 = FAILURE
                                                                                    address76 = self._read_expression()
                                                                                    if address76 is not FAILURE:
                                                                                        elements16.append(address76)
                                                                                    else:
                                                                                        elements16 = None
                                                                                        self._offset = index25
                                                                                else:
                                                                                    elements16 = None
                                                                                    self._offset = index25
                                                                            else:
                                                                                elements16 = None
                                                                                self._offset = index25
                                                                        else:
                                                                            elements16 = None
                                                                            self._offset = index25
                                                                    else:
                                                                        elements16 = None
                                                                        self._offset = index25
                                                                    if elements16 is None:
                                                                        address0 = FAILURE
                                                                    else:
                                                                        address0 = self._actions.assignment(self._input, index25, self._offset, elements16)
                                                                        self._offset = self._offset
                                                                    if address0 is FAILURE:
                                                                        self._offset = index1
                                                                        index26, elements17 = self._offset, []
                                                                        address77 = FAILURE
                                                                        address77 = self._read_expression()
                                                                        if address77 is not FAILURE:
                                                                            elements17.append(address77)
                                                                            address78 = FAILURE
                                                                            address78 = self._read__()
                                                                            if address78 is not FAILURE:
                                                                                elements17.append(address78)
                                                                                address79 = FAILURE
                                                                                address79 = self._read_eos()
                                                                                if address79 is not FAILURE:
                                                                                    elements17.append(address79)
                                                                                else:
                                                                                    elements17 = None
                                                                                    self._offset = index26
                                                                            else:
                                                                                elements17 = None
                                                                                self._offset = index26
                                                                        else:
                                                                            elements17 = None
                                                                            self._offset = index26
                                                                        if elements17 is None:
                                                                            address0 = FAILURE
                                                                        else:
                                                                            address0 = TreeNode96(self._input[index26:self._offset], index26, elements17)
                                                                            self._offset = self._offset
                                                                        if address0 is FAILURE:
                                                                            self._offset = index1
        self._cache['statement'][index0] = (address0, self._offset)
        return address0


class Parser(Grammar):
    def __init__(self, input, actions, types):
        self._input = input
        self._input_size = len(input)
        self._actions = actions
        self._types = types
        self._offset = 0
        self._cache = defaultdict(dict)
        self._failure = 0
        self._expected = []

    def parse(self):
        tree = self._read_start()
        if tree is not FAILURE and self._offset == self._input_size:
            return tree
        if not self._expected:
            self._failure = self._offset
            self._expected.append('<EOF>')
        raise ParseError(format_error(self._input, self._failure, self._expected))


def format_error(input, offset, expected):
    lines, line_no, position = input.split('\n'), 0, 0
    while position <= offset:
        position += len(lines[line_no]) + 1
        line_no += 1
    message, line = 'Line ' + str(line_no) + ': expected ' + ', '.join(expected) + '\n', lines[line_no - 1]
    message += line + '\n'
    position -= len(line) + 1
    message += ' ' * (offset - position)
    return message + '^'

def parse(input, actions=None, types=None):
    parser = Parser(input, actions, types)
    return parser.parse()

# This file was generated from grammar.peg
# See http://canopy.jcoglan.com/ for documentation.

from collections import defaultdict
import re


class TreeNode(object):
    def __init__(self, text, offset, elements):
        self.text = text
        self.offset = offset
        self.elements = elements

    def __iter__(self):
        for el in self.elements:
            yield el


class TreeNode1(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode1, self).__init__(text, offset, elements)
        self._ws = elements[2]


class TreeNode2(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode2, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.statement = elements[1]


class TreeNode3(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode3, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode4(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode4, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode5(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode5, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode6(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode6, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode7(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode7, self).__init__(text, offset, elements)
        self.keyword = elements[0]


class TreeNode8(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode8, self).__init__(text, offset, elements)
        self._ws = elements[4]
        self._ = elements[5]
        self.statement = elements[3]


class TreeNode9(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode9, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.statement = elements[1]


class TreeNode10(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode10, self).__init__(text, offset, elements)
        self._ = elements[2]


class TreeNode11(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode11, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self._ = elements[1]


class TreeNode12(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode12, self).__init__(text, offset, elements)
        self.expression = elements[3]
        self._ = elements[2]


class TreeNode13(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode13, self).__init__(text, offset, elements)
        self._ws = elements[3]
        self._ = elements[4]


class TreeNode14(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode14, self).__init__(text, offset, elements)
        self.roll_item = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode15(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode15, self).__init__(text, offset, elements)
        self._ = elements[3]


class TreeNode16(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode16, self).__init__(text, offset, elements)
        self._ws = elements[3]
        self.expression = elements[2]
        self._ = elements[4]


class TreeNode17(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode17, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode18(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode18, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode19(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode19, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.two_sided_op = elements[1]


class TreeNode20(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode20, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.two_sided_op = elements[1]


class TreeNode21(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode21, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.one_sided_op = elements[1]


class TreeNode22(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode22, self).__init__(text, offset, elements)
        self.basic_name = elements[0]
        self._ = elements[1]


class TreeNode23(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode23, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.special_accessor = elements[1]


class TreeNode24(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode24, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.special_entry = elements[2]


class TreeNode25(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode25, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.expression = elements[2]


class TreeNode26(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode26, self).__init__(text, offset, elements)
        self.reduce = elements[0]
        self._ = elements[1]


class TreeNode27(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode27, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.special_entry = elements[2]


class TreeNode28(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode28, self).__init__(text, offset, elements)
        self.accessing = elements[0]


class TreeNode29(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode29, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.accessor = elements[1]


class TreeNode30(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode30, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.special_entry = elements[2]


class TreeNode31(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode31, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode32(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode32, self).__init__(text, offset, elements)
        self._ = elements[0]


class TreeNode33(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode33, self).__init__(text, offset, elements)
        self._ = elements[6]
        self.expression = elements[7]
        self.anor = elements[4]


class TreeNode34(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode34, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.anor = elements[1]


class TreeNode35(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode35, self).__init__(text, offset, elements)
        self.comparison = elements[0]
        self._ = elements[3]
        self.anor_op = elements[2]
        self.anor = elements[4]


class TreeNode36(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode36, self).__init__(text, offset, elements)
        self.roll_math = elements[0]
        self._ = elements[3]
        self.comp_op = elements[2]
        self.comparison = elements[4]


class TreeNode37(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode37, self).__init__(text, offset, elements)
        self.add_math = elements[0]
        self._ = elements[4]
        self.roll_math = elements[5]


class TreeNode38(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode38, self).__init__(text, offset, elements)
        self.mult_math = elements[0]
        self._ = elements[4]
        self.add_op = elements[2]
        self.add_math = elements[5]


class TreeNode39(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode39, self).__init__(text, offset, elements)
        self.lambda_expr = elements[0]
        self._ = elements[4]
        self.mult_op = elements[2]
        self.mult_math = elements[5]


class TreeNode40(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode40, self).__init__(text, offset, elements)
        self.first_modifier_call = elements[0]


class TreeNode41(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode41, self).__init__(text, offset, elements)
        self.reduce_expr = elements[5]
        self._ = elements[3]


class TreeNode42(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode42, self).__init__(text, offset, elements)
        self._ws = elements[2]
        self.expression = elements[1]
        self._ = elements[3]


class TreeNode43(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode43, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[1]


class TreeNode44(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode44, self).__init__(text, offset, elements)
        self.dice = elements[0]
        self._ = elements[3]
        self.modifier_tail = elements[4]


class TreeNode45(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode45, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self._ = elements[1]
        self.modifier_tail = elements[2]


class TreeNode46(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode46, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self._ = elements[4]


class TreeNode47(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode47, self).__init__(text, offset, elements)
        self.expression = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode48(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode48, self).__init__(text, offset, elements)
        self.basic_name = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode49(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode49, self).__init__(text, offset, elements)
        self.modifier_params = elements[0]
        self._ = elements[4]
        self.expression = elements[5]


class TreeNode50(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode50, self).__init__(text, offset, elements)
        self.modifier_params = elements[0]
        self._ = elements[6]
        self._ws = elements[2]


class TreeNode51(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode51, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.special_entry = elements[1]


class TreeNode52(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode52, self).__init__(text, offset, elements)
        self.modifier_def_target = elements[0]
        self._ = elements[1]
        self._ws = elements[3]


class TreeNode53(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode53, self).__init__(text, offset, elements)
        self._ = elements[1]
        self._ws = elements[3]


class TreeNode54(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode54, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.stmt_or_expr = elements[1]


class TreeNode55(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode55, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.expression = elements[1]
        self.then = elements[3]


class TreeNode56(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode56, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.expression = elements[1]
        self.then = elements[3]


class TreeNode57(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode57, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.stmt_or_expr = elements[1]


class TreeNode58(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode58, self).__init__(text, offset, elements)
        self.basic_name = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode59(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode59, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[1]
        self._ws = elements[2]


class TreeNode60(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode60, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.access = elements[1]


class TreeNode61(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode61, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.loadable = elements[1]


class TreeNode62(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode62, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.load_from = elements[3]


class TreeNode63(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode63, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.loadable = elements[1]
        self.load_from = elements[3]
        self.load_into = elements[5]


class TreeNode64(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode64, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.loadable = elements[1]
        self.load_from = elements[3]


class TreeNode65(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode65, self).__init__(text, offset, elements)
        self._ = elements[2]
        self.loadable = elements[1]
        self.load_into = elements[3]


class TreeNode66(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode66, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.loadable = elements[1]


class TreeNode67(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode67, self).__init__(text, offset, elements)
        self._ = elements[3]
        self.expression = elements[2]
        self.then = elements[4]


class TreeNode68(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode68, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode69(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode69, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode70(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode70, self).__init__(text, offset, elements)
        self._ = elements[1]


class TreeNode71(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode71, self).__init__(text, offset, elements)
        self._ = elements[1]
        self.statement = elements[2]


class TreeNode72(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode72, self).__init__(text, offset, elements)
        self.statement = elements[0]
        self._ = elements[1]


class TreeNode73(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode73, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.basic_name = elements[1]


class TreeNode74(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode74, self).__init__(text, offset, elements)
        self.stmt_or_expr = elements[0]


class TreeNode75(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode75, self).__init__(text, offset, elements)
        self.expression = elements[0]
        self._ = elements[1]


class TreeNode76(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode76, self).__init__(text, offset, elements)
        self._ = elements[5]
        self.then = elements[6]


class TreeNode77(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode77, self).__init__(text, offset, elements)
        self._ = elements[0]
        self._ws = elements[1]
        self.stmt_or_expr = elements[2]


class TreeNode78(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode78, self).__init__(text, offset, elements)
        self._ws = elements[2]
        self.but_if_stmt = elements[1]
        self.always = elements[3]


class TreeNode79(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode79, self).__init__(text, offset, elements)
        self._ws = elements[2]
        self.but_if_stmt = elements[1]


class TreeNode80(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode80, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.always = elements[1]


class TreeNode81(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode81, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.but_if_stmt = elements[1]


class TreeNode82(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode82, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.expression = elements[1]


class TreeNode83(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode83, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.access = elements[1]


class TreeNode84(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode84, self).__init__(text, offset, elements)
        self._ = elements[0]
        self.restart_pos = elements[1]


class TreeNode85(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode85, self).__init__(text, offset, elements)
        self._ws = elements[3]
        self.block_body = elements[2]
        self._ = elements[4]


class TreeNode86(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode86, self).__init__(text, offset, elements)
        self._ws = elements[1]
        self._ = elements[2]


class TreeNode87(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode87, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.access = elements[2]


class TreeNode88(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode88, self).__init__(text, offset, elements)
        self.if_then = elements[0]


class TreeNode89(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode89, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.unless = elements[1]


class TreeNode90(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode90, self).__init__(text, offset, elements)
        self._ws = elements[0]
        self.otherwise = elements[1]


class TreeNode91(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode91, self).__init__(text, offset, elements)
        self._ = elements[9]
        self.basic_name = elements[4]
        self.expression = elements[7]
        self.loop_body = elements[10]


class TreeNode92(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode92, self).__init__(text, offset, elements)
        self._ = elements[4]
        self.expression = elements[3]
        self.loop_body = elements[5]
        self._ws = elements[6]


class TreeNode93(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode93, self).__init__(text, offset, elements)
        self.except_when = elements[0]
        self._ws = elements[1]


class TreeNode94(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode94, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[2]
        self.modifier_tail = elements[3]


class TreeNode95(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode95, self).__init__(text, offset, elements)
        self.access = elements[0]
        self._ = elements[1]
        self.assign_op = elements[2]
        self._ws = elements[3]
        self.expression = elements[4]


class TreeNode96(TreeNode):
    def __init__(self, text, offset, elements):
        super(TreeNode96, self).__init__(text, offset, elements)
        self.expression = elements[0]
        self._ = elements[1]
        self.eos = elements[2]


class ParseError(SyntaxError):
    pass


FAILURE = object()


class Grammar(object):
    REGEX_1 = re.compile('^[^\\n\\r\\f]')
    REGEX_2 = re.compile('^[^\\n\\r\\f]')
    REGEX_3 = re.compile('^[ \\t]')
    REGEX_4 = re.compile('^[\\n\\r\\f]')
    REGEX_5 = re.compile('^[0-9a-zA-Z_]')
    REGEX_6 = re.compile('^[0-9a-zA-Z_]')
    REGEX_7 = re.compile('^[0-9a-zA-Z_]')
    REGEX_8 = re.compile('^[0-9a-zA-Z_]')
    REGEX_9 = re.compile('^[0-9a-zA-Z_]')
    REGEX_10 = re.compile('^[0-9a-zA-Z_]')
    REGEX_11 = re.compile('^[0-9a-zA-Z_]')
    REGEX_12 = re.compile('^[0-9a-zA-Z_]')
    REGEX_13 = re.compile('^[0-9a-zA-Z_]')
    REGEX_14 = re.compile('^[0-9a-zA-Z_]')
    REGEX_15 = re.compile('^[0-9a-zA-Z_]')
    REGEX_16 = re.compile('^[0-9a-zA-Z_]')
    REGEX_17 = re.compile('^[0-9a-zA-Z_]')
    REGEX_18 = re.compile('^[0-9a-zA-Z_]')
    REGEX_19 = re.compile('^[0-9a-zA-Z_]')
    REGEX_20 = re.compile('^[0-9a-zA-Z_]')
    REGEX_21 = re.compile('^[0-9a-zA-Z_]')
    REGEX_22 = re.compile('^[0-9a-zA-Z_]')
    REGEX_23 = re.compile('^[0-9a-zA-Z_]')
    REGEX_24 = re.compile('^[0-9a-zA-Z_]')
    REGEX_25 = re.compile('^[0-9a-zA-Z_]')
    REGEX_26 = re.compile('^[0-9a-zA-Z_]')
    REGEX_27 = re.compile('^[0-9a-zA-Z_]')
    REGEX_28 = re.compile('^[0-9a-zA-Z_]')
    REGEX_29 = re.compile('^[0-9a-zA-Z_]')
    REGEX_30 = re.compile('^[0-9a-zA-Z_]')
    REGEX_31 = re.compile('^[0-9a-zA-Z_]')
    REGEX_32 = re.compile('^[0-9a-zA-Z_]')
    REGEX_33 = re.compile('^[0-9a-zA-Z_]')
    REGEX_34 = re.compile('^[0-9a-zA-Z_]')
    REGEX_35 = re.compile('^[0-9a-zA-Z_]')
    REGEX_36 = re.compile('^[0-9a-zA-Z_]')
    REGEX_37 = re.compile('^[0-9a-zA-Z_]')
    REGEX_38 = re.compile('^[0-9a-zA-Z_]')
    REGEX_39 = re.compile('^[0-9a-zA-Z_]')
    REGEX_40 = re.compile('^[0-9a-zA-Z_]')
    REGEX_41 = re.compile('^[\\n\\r\\f \\t]')
    REGEX_42 = re.compile('^[\\n\\r\\f]')
    REGEX_43 = re.compile('^[0-9]')
    REGEX_44 = re.compile('^[0-9]')
    REGEX_45 = re.compile('^[0-9]')
    REGEX_46 = re.compile('^[\\\\runftvb\']')
    REGEX_47 = re.compile('^[^\']')
    REGEX_48 = re.compile('^[a-zA-Z_]')
    REGEX_49 = re.compile('^[a-zA-Z_0-9]')
    REGEX_50 = re.compile('^[a-z_A-Z]')

    def _read_start(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['start'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        address1 = self._read_shebang()
        if address1 is FAILURE:
            address1 = TreeNode(self._input[index2:index2], index2, [])
            self._offset = index2
        if address1 is not FAILURE:
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                index4, elements2 = self._offset, []
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    address5 = self._read_statement()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address3 = FAILURE
                else:
                    address3 = TreeNode2(self._input[index4:self._offset], index4, elements2)
                    self._offset = self._offset
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address7 = FAILURE
                index5 = self._offset
                address7 = self._read_stmt_or_expr()
                if address7 is FAILURE:
                    address7 = TreeNode(self._input[index5:index5], index5, [])
                    self._offset = index5
                if address7 is not FAILURE:
                    elements0.append(address7)
                    address8 = FAILURE
                    address8 = self._read__ws()
                    if address8 is not FAILURE:
                        elements0.append(address8)
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.statements(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['start'][index0] = (address0, self._offset)
        return address0

    def _read_shebang(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['shebang'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '#!':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'#!\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index2, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_1.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[^\\n\\r\\f]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index2:self._offset], index2, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['shebang'][index0] = (address0, self._offset)
        return address0

    def _read_comment(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['comment'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '//':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'//\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index2, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_2.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[^\\n\\r\\f]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index2:self._offset], index2, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['comment'][index0] = (address0, self._offset)
        return address0

    def _read__(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['_'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        remaining0, index1, elements0, address1 = 0, self._offset, [], True
        while address1 is not FAILURE:
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 is not None and Grammar.REGEX_3.search(chunk0):
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[ \\t]')
            if address1 is not FAILURE:
                elements0.append(address1)
                remaining0 -= 1
        if remaining0 <= 0:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        else:
            address0 = FAILURE
        self._cache['_'][index0] = (address0, self._offset)
        return address0

    def _read_eol(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['eol'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        remaining0, index2, elements0, address1 = 1, self._offset, [], True
        while address1 is not FAILURE:
            address1 = self._read_comment()
            if address1 is not FAILURE:
                elements0.append(address1)
                remaining0 -= 1
        if remaining0 <= 0:
            address0 = TreeNode(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        else:
            address0 = FAILURE
        if address0 is FAILURE:
            self._offset = index1
            remaining1, index3, elements1, address2 = 1, self._offset, [], True
            while address2 is not FAILURE:
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 is not None and Grammar.REGEX_4.search(chunk0):
                    address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address2 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[\\n\\r\\f]')
                if address2 is not FAILURE:
                    elements1.append(address2)
                    remaining1 -= 1
            if remaining1 <= 0:
                address0 = self._actions.ignore(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            else:
                address0 = FAILURE
            if address0 is FAILURE:
                self._offset = index1
        self._cache['eol'][index0] = (address0, self._offset)
        return address0

    def _read_keyword(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['keyword'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 5
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'leave':
            address1 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
            self._offset = self._offset + 5
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'leave\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            index3 = self._offset
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 is not None and Grammar.REGEX_5.search(chunk1):
                address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[0-9a-zA-Z_]')
            self._offset = index3
            if address2 is FAILURE:
                address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index4, elements1 = self._offset, []
            address3 = FAILURE
            chunk2, max2 = None, self._offset + 5
            if max2 <= self._input_size:
                chunk2 = self._input[self._offset:max2]
            if chunk2 == 'until':
                address3 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                self._offset = self._offset + 5
            else:
                address3 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'until\'')
            if address3 is not FAILURE:
                elements1.append(address3)
                address4 = FAILURE
                index5 = self._offset
                chunk3, max3 = None, self._offset + 1
                if max3 <= self._input_size:
                    chunk3 = self._input[self._offset:max3]
                if chunk3 is not None and Grammar.REGEX_6.search(chunk3):
                    address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address4 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[0-9a-zA-Z_]')
                self._offset = index5
                if address4 is FAILURE:
                    address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address4 = FAILURE
                if address4 is not FAILURE:
                    elements1.append(address4)
                else:
                    elements1 = None
                    self._offset = index4
            else:
                elements1 = None
                self._offset = index4
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode(self._input[index4:self._offset], index4, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index6, elements2 = self._offset, []
                address5 = FAILURE
                chunk4, max4 = None, self._offset + 2
                if max4 <= self._input_size:
                    chunk4 = self._input[self._offset:max4]
                if chunk4 == 'do':
                    address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address5 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'do\'')
                if address5 is not FAILURE:
                    elements2.append(address5)
                    address6 = FAILURE
                    index7 = self._offset
                    chunk5, max5 = None, self._offset + 1
                    if max5 <= self._input_size:
                        chunk5 = self._input[self._offset:max5]
                    if chunk5 is not None and Grammar.REGEX_7.search(chunk5):
                        address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address6 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[0-9a-zA-Z_]')
                    self._offset = index7
                    if address6 is FAILURE:
                        address6 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address6 = FAILURE
                    if address6 is not FAILURE:
                        elements2.append(address6)
                    else:
                        elements2 = None
                        self._offset = index6
                else:
                    elements2 = None
                    self._offset = index6
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = TreeNode(self._input[index6:self._offset], index6, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index8, elements3 = self._offset, []
                    address7 = FAILURE
                    chunk6, max6 = None, self._offset + 6
                    if max6 <= self._input_size:
                        chunk6 = self._input[self._offset:max6]
                    if chunk6 == 'except':
                        address7 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                        self._offset = self._offset + 6
                    else:
                        address7 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'except\'')
                    if address7 is not FAILURE:
                        elements3.append(address7)
                        address8 = FAILURE
                        index9 = self._offset
                        chunk7, max7 = None, self._offset + 1
                        if max7 <= self._input_size:
                            chunk7 = self._input[self._offset:max7]
                        if chunk7 is not None and Grammar.REGEX_8.search(chunk7):
                            address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address8 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('[0-9a-zA-Z_]')
                        self._offset = index9
                        if address8 is FAILURE:
                            address8 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address8 = FAILURE
                        if address8 is not FAILURE:
                            elements3.append(address8)
                        else:
                            elements3 = None
                            self._offset = index8
                    else:
                        elements3 = None
                        self._offset = index8
                    if elements3 is None:
                        address0 = FAILURE
                    else:
                        address0 = TreeNode(self._input[index8:self._offset], index8, elements3)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index10, elements4 = self._offset, []
                        address9 = FAILURE
                        chunk8, max8 = None, self._offset + 3
                        if max8 <= self._input_size:
                            chunk8 = self._input[self._offset:max8]
                        if chunk8 == 'for':
                            address9 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                            self._offset = self._offset + 3
                        else:
                            address9 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'for\'')
                        if address9 is not FAILURE:
                            elements4.append(address9)
                            address10 = FAILURE
                            index11 = self._offset
                            chunk9, max9 = None, self._offset + 1
                            if max9 <= self._input_size:
                                chunk9 = self._input[self._offset:max9]
                            if chunk9 is not None and Grammar.REGEX_9.search(chunk9):
                                address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address10 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('[0-9a-zA-Z_]')
                            self._offset = index11
                            if address10 is FAILURE:
                                address10 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                self._offset = self._offset
                            else:
                                address10 = FAILURE
                            if address10 is not FAILURE:
                                elements4.append(address10)
                            else:
                                elements4 = None
                                self._offset = index10
                        else:
                            elements4 = None
                            self._offset = index10
                        if elements4 is None:
                            address0 = FAILURE
                        else:
                            address0 = TreeNode(self._input[index10:self._offset], index10, elements4)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
                            index12, elements5 = self._offset, []
                            address11 = FAILURE
                            chunk10, max10 = None, self._offset + 5
                            if max10 <= self._input_size:
                                chunk10 = self._input[self._offset:max10]
                            if chunk10 == 'every':
                                address11 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                self._offset = self._offset + 5
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'every\'')
                            if address11 is not FAILURE:
                                elements5.append(address11)
                                address12 = FAILURE
                                index13 = self._offset
                                chunk11, max11 = None, self._offset + 1
                                if max11 <= self._input_size:
                                    chunk11 = self._input[self._offset:max11]
                                if chunk11 is not None and Grammar.REGEX_10.search(chunk11):
                                    address12 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address12 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('[0-9a-zA-Z_]')
                                self._offset = index13
                                if address12 is FAILURE:
                                    address12 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                    self._offset = self._offset
                                else:
                                    address12 = FAILURE
                                if address12 is not FAILURE:
                                    elements5.append(address12)
                                else:
                                    elements5 = None
                                    self._offset = index12
                            else:
                                elements5 = None
                                self._offset = index12
                            if elements5 is None:
                                address0 = FAILURE
                            else:
                                address0 = TreeNode(self._input[index12:self._offset], index12, elements5)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
                                index14, elements6 = self._offset, []
                                address13 = FAILURE
                                chunk12, max12 = None, self._offset + 4
                                if max12 <= self._input_size:
                                    chunk12 = self._input[self._offset:max12]
                                if chunk12 == 'that':
                                    address13 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                    self._offset = self._offset + 4
                                else:
                                    address13 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'that\'')
                                if address13 is not FAILURE:
                                    elements6.append(address13)
                                    address14 = FAILURE
                                    index15 = self._offset
                                    chunk13, max13 = None, self._offset + 1
                                    if max13 <= self._input_size:
                                        chunk13 = self._input[self._offset:max13]
                                    if chunk13 is not None and Grammar.REGEX_11.search(chunk13):
                                        address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address14 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('[0-9a-zA-Z_]')
                                    self._offset = index15
                                    if address14 is FAILURE:
                                        address14 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                        self._offset = self._offset
                                    else:
                                        address14 = FAILURE
                                    if address14 is not FAILURE:
                                        elements6.append(address14)
                                    else:
                                        elements6 = None
                                        self._offset = index14
                                else:
                                    elements6 = None
                                    self._offset = index14
                                if elements6 is None:
                                    address0 = FAILURE
                                else:
                                    address0 = TreeNode(self._input[index14:self._offset], index14, elements6)
                                    self._offset = self._offset
                                if address0 is FAILURE:
                                    self._offset = index1
                                    index16, elements7 = self._offset, []
                                    address15 = FAILURE
                                    chunk14, max14 = None, self._offset + 2
                                    if max14 <= self._input_size:
                                        chunk14 = self._input[self._offset:max14]
                                    if chunk14 == 'at':
                                        address15 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                        self._offset = self._offset + 2
                                    else:
                                        address15 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'at\'')
                                    if address15 is not FAILURE:
                                        elements7.append(address15)
                                        address16 = FAILURE
                                        index17 = self._offset
                                        chunk15, max15 = None, self._offset + 1
                                        if max15 <= self._input_size:
                                            chunk15 = self._input[self._offset:max15]
                                        if chunk15 is not None and Grammar.REGEX_12.search(chunk15):
                                            address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address16 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('[0-9a-zA-Z_]')
                                        self._offset = index17
                                        if address16 is FAILURE:
                                            address16 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                            self._offset = self._offset
                                        else:
                                            address16 = FAILURE
                                        if address16 is not FAILURE:
                                            elements7.append(address16)
                                        else:
                                            elements7 = None
                                            self._offset = index16
                                    else:
                                        elements7 = None
                                        self._offset = index16
                                    if elements7 is None:
                                        address0 = FAILURE
                                    else:
                                        address0 = TreeNode(self._input[index16:self._offset], index16, elements7)
                                        self._offset = self._offset
                                    if address0 is FAILURE:
                                        self._offset = index1
                                        index18, elements8 = self._offset, []
                                        address17 = FAILURE
                                        chunk16, max16 = None, self._offset + 5
                                        if max16 <= self._input_size:
                                            chunk16 = self._input[self._offset:max16]
                                        if chunk16 == 'after':
                                            address17 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                            self._offset = self._offset + 5
                                        else:
                                            address17 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'after\'')
                                        if address17 is not FAILURE:
                                            elements8.append(address17)
                                            address18 = FAILURE
                                            index19 = self._offset
                                            chunk17, max17 = None, self._offset + 1
                                            if max17 <= self._input_size:
                                                chunk17 = self._input[self._offset:max17]
                                            if chunk17 is not None and Grammar.REGEX_13.search(chunk17):
                                                address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                self._offset = self._offset + 1
                                            else:
                                                address18 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('[0-9a-zA-Z_]')
                                            self._offset = index19
                                            if address18 is FAILURE:
                                                address18 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                self._offset = self._offset
                                            else:
                                                address18 = FAILURE
                                            if address18 is not FAILURE:
                                                elements8.append(address18)
                                            else:
                                                elements8 = None
                                                self._offset = index18
                                        else:
                                            elements8 = None
                                            self._offset = index18
                                        if elements8 is None:
                                            address0 = FAILURE
                                        else:
                                            address0 = TreeNode(self._input[index18:self._offset], index18, elements8)
                                            self._offset = self._offset
                                        if address0 is FAILURE:
                                            self._offset = index1
                                            index20, elements9 = self._offset, []
                                            address19 = FAILURE
                                            chunk18, max18 = None, self._offset + 7
                                            if max18 <= self._input_size:
                                                chunk18 = self._input[self._offset:max18]
                                            if chunk18 == 'restart':
                                                address19 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                                self._offset = self._offset + 7
                                            else:
                                                address19 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('\'restart\'')
                                            if address19 is not FAILURE:
                                                elements9.append(address19)
                                                address20 = FAILURE
                                                index21 = self._offset
                                                chunk19, max19 = None, self._offset + 1
                                                if max19 <= self._input_size:
                                                    chunk19 = self._input[self._offset:max19]
                                                if chunk19 is not None and Grammar.REGEX_14.search(chunk19):
                                                    address20 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                    self._offset = self._offset + 1
                                                else:
                                                    address20 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('[0-9a-zA-Z_]')
                                                self._offset = index21
                                                if address20 is FAILURE:
                                                    address20 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                    self._offset = self._offset
                                                else:
                                                    address20 = FAILURE
                                                if address20 is not FAILURE:
                                                    elements9.append(address20)
                                                else:
                                                    elements9 = None
                                                    self._offset = index20
                                            else:
                                                elements9 = None
                                                self._offset = index20
                                            if elements9 is None:
                                                address0 = FAILURE
                                            else:
                                                address0 = TreeNode(self._input[index20:self._offset], index20, elements9)
                                                self._offset = self._offset
                                            if address0 is FAILURE:
                                                self._offset = index1
                                                index22, elements10 = self._offset, []
                                                address21 = FAILURE
                                                chunk20, max20 = None, self._offset + 6
                                                if max20 <= self._input_size:
                                                    chunk20 = self._input[self._offset:max20]
                                                if chunk20 == 'before':
                                                    address21 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                    self._offset = self._offset + 6
                                                else:
                                                    address21 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('\'before\'')
                                                if address21 is not FAILURE:
                                                    elements10.append(address21)
                                                    address22 = FAILURE
                                                    index23 = self._offset
                                                    chunk21, max21 = None, self._offset + 1
                                                    if max21 <= self._input_size:
                                                        chunk21 = self._input[self._offset:max21]
                                                    if chunk21 is not None and Grammar.REGEX_15.search(chunk21):
                                                        address22 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                        self._offset = self._offset + 1
                                                    else:
                                                        address22 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('[0-9a-zA-Z_]')
                                                    self._offset = index23
                                                    if address22 is FAILURE:
                                                        address22 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                        self._offset = self._offset
                                                    else:
                                                        address22 = FAILURE
                                                    if address22 is not FAILURE:
                                                        elements10.append(address22)
                                                    else:
                                                        elements10 = None
                                                        self._offset = index22
                                                else:
                                                    elements10 = None
                                                    self._offset = index22
                                                if elements10 is None:
                                                    address0 = FAILURE
                                                else:
                                                    address0 = TreeNode(self._input[index22:self._offset], index22, elements10)
                                                    self._offset = self._offset
                                                if address0 is FAILURE:
                                                    self._offset = index1
                                                    index24, elements11 = self._offset, []
                                                    address23 = FAILURE
                                                    chunk22, max22 = None, self._offset + 4
                                                    if max22 <= self._input_size:
                                                        chunk22 = self._input[self._offset:max22]
                                                    if chunk22 == 'when':
                                                        address23 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                        self._offset = self._offset + 4
                                                    else:
                                                        address23 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('\'when\'')
                                                    if address23 is not FAILURE:
                                                        elements11.append(address23)
                                                        address24 = FAILURE
                                                        index25 = self._offset
                                                        chunk23, max23 = None, self._offset + 1
                                                        if max23 <= self._input_size:
                                                            chunk23 = self._input[self._offset:max23]
                                                        if chunk23 is not None and Grammar.REGEX_16.search(chunk23):
                                                            address24 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                            self._offset = self._offset + 1
                                                        else:
                                                            address24 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('[0-9a-zA-Z_]')
                                                        self._offset = index25
                                                        if address24 is FAILURE:
                                                            address24 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                            self._offset = self._offset
                                                        else:
                                                            address24 = FAILURE
                                                        if address24 is not FAILURE:
                                                            elements11.append(address24)
                                                        else:
                                                            elements11 = None
                                                            self._offset = index24
                                                    else:
                                                        elements11 = None
                                                        self._offset = index24
                                                    if elements11 is None:
                                                        address0 = FAILURE
                                                    else:
                                                        address0 = TreeNode(self._input[index24:self._offset], index24, elements11)
                                                        self._offset = self._offset
                                                    if address0 is FAILURE:
                                                        self._offset = index1
                                                        index26, elements12 = self._offset, []
                                                        address25 = FAILURE
                                                        chunk24, max24 = None, self._offset + 7
                                                        if max24 <= self._input_size:
                                                            chunk24 = self._input[self._offset:max24]
                                                        if chunk24 == 'attempt':
                                                            address25 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                                            self._offset = self._offset + 7
                                                        else:
                                                            address25 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('\'attempt\'')
                                                        if address25 is not FAILURE:
                                                            elements12.append(address25)
                                                            address26 = FAILURE
                                                            index27 = self._offset
                                                            chunk25, max25 = None, self._offset + 1
                                                            if max25 <= self._input_size:
                                                                chunk25 = self._input[self._offset:max25]
                                                            if chunk25 is not None and Grammar.REGEX_17.search(chunk25):
                                                                address26 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                self._offset = self._offset + 1
                                                            else:
                                                                address26 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                            self._offset = index27
                                                            if address26 is FAILURE:
                                                                address26 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                self._offset = self._offset
                                                            else:
                                                                address26 = FAILURE
                                                            if address26 is not FAILURE:
                                                                elements12.append(address26)
                                                            else:
                                                                elements12 = None
                                                                self._offset = index26
                                                        else:
                                                            elements12 = None
                                                            self._offset = index26
                                                        if elements12 is None:
                                                            address0 = FAILURE
                                                        else:
                                                            address0 = TreeNode(self._input[index26:self._offset], index26, elements12)
                                                            self._offset = self._offset
                                                        if address0 is FAILURE:
                                                            self._offset = index1
                                                            index28, elements13 = self._offset, []
                                                            address27 = FAILURE
                                                            chunk26, max26 = None, self._offset + 3
                                                            if max26 <= self._input_size:
                                                                chunk26 = self._input[self._offset:max26]
                                                            if chunk26 == 'but':
                                                                address27 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                self._offset = self._offset + 3
                                                            else:
                                                                address27 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'but\'')
                                                            if address27 is not FAILURE:
                                                                elements13.append(address27)
                                                                address28 = FAILURE
                                                                index29 = self._offset
                                                                chunk27, max27 = None, self._offset + 1
                                                                if max27 <= self._input_size:
                                                                    chunk27 = self._input[self._offset:max27]
                                                                if chunk27 is not None and Grammar.REGEX_18.search(chunk27):
                                                                    address28 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                    self._offset = self._offset + 1
                                                                else:
                                                                    address28 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                self._offset = index29
                                                                if address28 is FAILURE:
                                                                    address28 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                    self._offset = self._offset
                                                                else:
                                                                    address28 = FAILURE
                                                                if address28 is not FAILURE:
                                                                    elements13.append(address28)
                                                                else:
                                                                    elements13 = None
                                                                    self._offset = index28
                                                            else:
                                                                elements13 = None
                                                                self._offset = index28
                                                            if elements13 is None:
                                                                address0 = FAILURE
                                                            else:
                                                                address0 = TreeNode(self._input[index28:self._offset], index28, elements13)
                                                                self._offset = self._offset
                                                            if address0 is FAILURE:
                                                                self._offset = index1
                                                                index30, elements14 = self._offset, []
                                                                address29 = FAILURE
                                                                chunk28, max28 = None, self._offset + 6
                                                                if max28 <= self._input_size:
                                                                    chunk28 = self._input[self._offset:max28]
                                                                if chunk28 == 'always':
                                                                    address29 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                                    self._offset = self._offset + 6
                                                                else:
                                                                    address29 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('\'always\'')
                                                                if address29 is not FAILURE:
                                                                    elements14.append(address29)
                                                                    address30 = FAILURE
                                                                    index31 = self._offset
                                                                    chunk29, max29 = None, self._offset + 1
                                                                    if max29 <= self._input_size:
                                                                        chunk29 = self._input[self._offset:max29]
                                                                    if chunk29 is not None and Grammar.REGEX_19.search(chunk29):
                                                                        address30 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                        self._offset = self._offset + 1
                                                                    else:
                                                                        address30 = FAILURE
                                                                        if self._offset > self._failure:
                                                                            self._failure = self._offset
                                                                            self._expected = []
                                                                        if self._offset == self._failure:
                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                    self._offset = index31
                                                                    if address30 is FAILURE:
                                                                        address30 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                        self._offset = self._offset
                                                                    else:
                                                                        address30 = FAILURE
                                                                    if address30 is not FAILURE:
                                                                        elements14.append(address30)
                                                                    else:
                                                                        elements14 = None
                                                                        self._offset = index30
                                                                else:
                                                                    elements14 = None
                                                                    self._offset = index30
                                                                if elements14 is None:
                                                                    address0 = FAILURE
                                                                else:
                                                                    address0 = TreeNode(self._input[index30:self._offset], index30, elements14)
                                                                    self._offset = self._offset
                                                                if address0 is FAILURE:
                                                                    self._offset = index1
                                                                    index32, elements15 = self._offset, []
                                                                    address31 = FAILURE
                                                                    chunk30, max30 = None, self._offset + 6
                                                                    if max30 <= self._input_size:
                                                                        chunk30 = self._input[self._offset:max30]
                                                                    if chunk30 == 'occurs':
                                                                        address31 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                                        self._offset = self._offset + 6
                                                                    else:
                                                                        address31 = FAILURE
                                                                        if self._offset > self._failure:
                                                                            self._failure = self._offset
                                                                            self._expected = []
                                                                        if self._offset == self._failure:
                                                                            self._expected.append('\'occurs\'')
                                                                    if address31 is not FAILURE:
                                                                        elements15.append(address31)
                                                                        address32 = FAILURE
                                                                        index33 = self._offset
                                                                        chunk31, max31 = None, self._offset + 1
                                                                        if max31 <= self._input_size:
                                                                            chunk31 = self._input[self._offset:max31]
                                                                        if chunk31 is not None and Grammar.REGEX_20.search(chunk31):
                                                                            address32 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                            self._offset = self._offset + 1
                                                                        else:
                                                                            address32 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                        self._offset = index33
                                                                        if address32 is FAILURE:
                                                                            address32 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                            self._offset = self._offset
                                                                        else:
                                                                            address32 = FAILURE
                                                                        if address32 is not FAILURE:
                                                                            elements15.append(address32)
                                                                        else:
                                                                            elements15 = None
                                                                            self._offset = index32
                                                                    else:
                                                                        elements15 = None
                                                                        self._offset = index32
                                                                    if elements15 is None:
                                                                        address0 = FAILURE
                                                                    else:
                                                                        address0 = TreeNode(self._input[index32:self._offset], index32, elements15)
                                                                        self._offset = self._offset
                                                                    if address0 is FAILURE:
                                                                        self._offset = index1
                                                                        index34, elements16 = self._offset, []
                                                                        address33 = FAILURE
                                                                        chunk32, max32 = None, self._offset + 4
                                                                        if max32 <= self._input_size:
                                                                            chunk32 = self._input[self._offset:max32]
                                                                        if chunk32 == 'oops':
                                                                            address33 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                            self._offset = self._offset + 4
                                                                        else:
                                                                            address33 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('\'oops\'')
                                                                        if address33 is not FAILURE:
                                                                            elements16.append(address33)
                                                                            address34 = FAILURE
                                                                            index35 = self._offset
                                                                            chunk33, max33 = None, self._offset + 1
                                                                            if max33 <= self._input_size:
                                                                                chunk33 = self._input[self._offset:max33]
                                                                            if chunk33 is not None and Grammar.REGEX_21.search(chunk33):
                                                                                address34 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                self._offset = self._offset + 1
                                                                            else:
                                                                                address34 = FAILURE
                                                                                if self._offset > self._failure:
                                                                                    self._failure = self._offset
                                                                                    self._expected = []
                                                                                if self._offset == self._failure:
                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                            self._offset = index35
                                                                            if address34 is FAILURE:
                                                                                address34 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                self._offset = self._offset
                                                                            else:
                                                                                address34 = FAILURE
                                                                            if address34 is not FAILURE:
                                                                                elements16.append(address34)
                                                                            else:
                                                                                elements16 = None
                                                                                self._offset = index34
                                                                        else:
                                                                            elements16 = None
                                                                            self._offset = index34
                                                                        if elements16 is None:
                                                                            address0 = FAILURE
                                                                        else:
                                                                            address0 = TreeNode(self._input[index34:self._offset], index34, elements16)
                                                                            self._offset = self._offset
                                                                        if address0 is FAILURE:
                                                                            self._offset = index1
                                                                            index36, elements17 = self._offset, []
                                                                            address35 = FAILURE
                                                                            chunk34, max34 = None, self._offset + 4
                                                                            if max34 <= self._input_size:
                                                                                chunk34 = self._input[self._offset:max34]
                                                                            if chunk34 == 'load':
                                                                                address35 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                self._offset = self._offset + 4
                                                                            else:
                                                                                address35 = FAILURE
                                                                                if self._offset > self._failure:
                                                                                    self._failure = self._offset
                                                                                    self._expected = []
                                                                                if self._offset == self._failure:
                                                                                    self._expected.append('\'load\'')
                                                                            if address35 is not FAILURE:
                                                                                elements17.append(address35)
                                                                                address36 = FAILURE
                                                                                index37 = self._offset
                                                                                chunk35, max35 = None, self._offset + 1
                                                                                if max35 <= self._input_size:
                                                                                    chunk35 = self._input[self._offset:max35]
                                                                                if chunk35 is not None and Grammar.REGEX_22.search(chunk35):
                                                                                    address36 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                    self._offset = self._offset + 1
                                                                                else:
                                                                                    address36 = FAILURE
                                                                                    if self._offset > self._failure:
                                                                                        self._failure = self._offset
                                                                                        self._expected = []
                                                                                    if self._offset == self._failure:
                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                self._offset = index37
                                                                                if address36 is FAILURE:
                                                                                    address36 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                    self._offset = self._offset
                                                                                else:
                                                                                    address36 = FAILURE
                                                                                if address36 is not FAILURE:
                                                                                    elements17.append(address36)
                                                                                else:
                                                                                    elements17 = None
                                                                                    self._offset = index36
                                                                            else:
                                                                                elements17 = None
                                                                                self._offset = index36
                                                                            if elements17 is None:
                                                                                address0 = FAILURE
                                                                            else:
                                                                                address0 = TreeNode(self._input[index36:self._offset], index36, elements17)
                                                                                self._offset = self._offset
                                                                            if address0 is FAILURE:
                                                                                self._offset = index1
                                                                                index38, elements18 = self._offset, []
                                                                                address37 = FAILURE
                                                                                chunk36, max36 = None, self._offset + 4
                                                                                if max36 <= self._input_size:
                                                                                    chunk36 = self._input[self._offset:max36]
                                                                                if chunk36 == 'from':
                                                                                    address37 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                    self._offset = self._offset + 4
                                                                                else:
                                                                                    address37 = FAILURE
                                                                                    if self._offset > self._failure:
                                                                                        self._failure = self._offset
                                                                                        self._expected = []
                                                                                    if self._offset == self._failure:
                                                                                        self._expected.append('\'from\'')
                                                                                if address37 is not FAILURE:
                                                                                    elements18.append(address37)
                                                                                    address38 = FAILURE
                                                                                    index39 = self._offset
                                                                                    chunk37, max37 = None, self._offset + 1
                                                                                    if max37 <= self._input_size:
                                                                                        chunk37 = self._input[self._offset:max37]
                                                                                    if chunk37 is not None and Grammar.REGEX_23.search(chunk37):
                                                                                        address38 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                        self._offset = self._offset + 1
                                                                                    else:
                                                                                        address38 = FAILURE
                                                                                        if self._offset > self._failure:
                                                                                            self._failure = self._offset
                                                                                            self._expected = []
                                                                                        if self._offset == self._failure:
                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                    self._offset = index39
                                                                                    if address38 is FAILURE:
                                                                                        address38 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                        self._offset = self._offset
                                                                                    else:
                                                                                        address38 = FAILURE
                                                                                    if address38 is not FAILURE:
                                                                                        elements18.append(address38)
                                                                                    else:
                                                                                        elements18 = None
                                                                                        self._offset = index38
                                                                                else:
                                                                                    elements18 = None
                                                                                    self._offset = index38
                                                                                if elements18 is None:
                                                                                    address0 = FAILURE
                                                                                else:
                                                                                    address0 = TreeNode(self._input[index38:self._offset], index38, elements18)
                                                                                    self._offset = self._offset
                                                                                if address0 is FAILURE:
                                                                                    self._offset = index1
                                                                                    index40, elements19 = self._offset, []
                                                                                    address39 = FAILURE
                                                                                    chunk38, max38 = None, self._offset + 4
                                                                                    if max38 <= self._input_size:
                                                                                        chunk38 = self._input[self._offset:max38]
                                                                                    if chunk38 == 'into':
                                                                                        address39 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                        self._offset = self._offset + 4
                                                                                    else:
                                                                                        address39 = FAILURE
                                                                                        if self._offset > self._failure:
                                                                                            self._failure = self._offset
                                                                                            self._expected = []
                                                                                        if self._offset == self._failure:
                                                                                            self._expected.append('\'into\'')
                                                                                    if address39 is not FAILURE:
                                                                                        elements19.append(address39)
                                                                                        address40 = FAILURE
                                                                                        index41 = self._offset
                                                                                        chunk39, max39 = None, self._offset + 1
                                                                                        if max39 <= self._input_size:
                                                                                            chunk39 = self._input[self._offset:max39]
                                                                                        if chunk39 is not None and Grammar.REGEX_24.search(chunk39):
                                                                                            address40 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                            self._offset = self._offset + 1
                                                                                        else:
                                                                                            address40 = FAILURE
                                                                                            if self._offset > self._failure:
                                                                                                self._failure = self._offset
                                                                                                self._expected = []
                                                                                            if self._offset == self._failure:
                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                        self._offset = index41
                                                                                        if address40 is FAILURE:
                                                                                            address40 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                            self._offset = self._offset
                                                                                        else:
                                                                                            address40 = FAILURE
                                                                                        if address40 is not FAILURE:
                                                                                            elements19.append(address40)
                                                                                        else:
                                                                                            elements19 = None
                                                                                            self._offset = index40
                                                                                    else:
                                                                                        elements19 = None
                                                                                        self._offset = index40
                                                                                    if elements19 is None:
                                                                                        address0 = FAILURE
                                                                                    else:
                                                                                        address0 = TreeNode(self._input[index40:self._offset], index40, elements19)
                                                                                        self._offset = self._offset
                                                                                    if address0 is FAILURE:
                                                                                        self._offset = index1
                                                                                        index42, elements20 = self._offset, []
                                                                                        address41 = FAILURE
                                                                                        chunk40, max40 = None, self._offset + 3
                                                                                        if max40 <= self._input_size:
                                                                                            chunk40 = self._input[self._offset:max40]
                                                                                        if chunk40 == 'use':
                                                                                            address41 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                            self._offset = self._offset + 3
                                                                                        else:
                                                                                            address41 = FAILURE
                                                                                            if self._offset > self._failure:
                                                                                                self._failure = self._offset
                                                                                                self._expected = []
                                                                                            if self._offset == self._failure:
                                                                                                self._expected.append('\'use\'')
                                                                                        if address41 is not FAILURE:
                                                                                            elements20.append(address41)
                                                                                            address42 = FAILURE
                                                                                            index43 = self._offset
                                                                                            chunk41, max41 = None, self._offset + 1
                                                                                            if max41 <= self._input_size:
                                                                                                chunk41 = self._input[self._offset:max41]
                                                                                            if chunk41 is not None and Grammar.REGEX_25.search(chunk41):
                                                                                                address42 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                self._offset = self._offset + 1
                                                                                            else:
                                                                                                address42 = FAILURE
                                                                                                if self._offset > self._failure:
                                                                                                    self._failure = self._offset
                                                                                                    self._expected = []
                                                                                                if self._offset == self._failure:
                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                            self._offset = index43
                                                                                            if address42 is FAILURE:
                                                                                                address42 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                self._offset = self._offset
                                                                                            else:
                                                                                                address42 = FAILURE
                                                                                            if address42 is not FAILURE:
                                                                                                elements20.append(address42)
                                                                                            else:
                                                                                                elements20 = None
                                                                                                self._offset = index42
                                                                                        else:
                                                                                            elements20 = None
                                                                                            self._offset = index42
                                                                                        if elements20 is None:
                                                                                            address0 = FAILURE
                                                                                        else:
                                                                                            address0 = TreeNode(self._input[index42:self._offset], index42, elements20)
                                                                                            self._offset = self._offset
                                                                                        if address0 is FAILURE:
                                                                                            self._offset = index1
                                                                                            index44, elements21 = self._offset, []
                                                                                            address43 = FAILURE
                                                                                            chunk42, max42 = None, self._offset + 2
                                                                                            if max42 <= self._input_size:
                                                                                                chunk42 = self._input[self._offset:max42]
                                                                                            if chunk42 == 'if':
                                                                                                address43 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                                                self._offset = self._offset + 2
                                                                                            else:
                                                                                                address43 = FAILURE
                                                                                                if self._offset > self._failure:
                                                                                                    self._failure = self._offset
                                                                                                    self._expected = []
                                                                                                if self._offset == self._failure:
                                                                                                    self._expected.append('\'if\'')
                                                                                            if address43 is not FAILURE:
                                                                                                elements21.append(address43)
                                                                                                address44 = FAILURE
                                                                                                index45 = self._offset
                                                                                                chunk43, max43 = None, self._offset + 1
                                                                                                if max43 <= self._input_size:
                                                                                                    chunk43 = self._input[self._offset:max43]
                                                                                                if chunk43 is not None and Grammar.REGEX_26.search(chunk43):
                                                                                                    address44 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                    self._offset = self._offset + 1
                                                                                                else:
                                                                                                    address44 = FAILURE
                                                                                                    if self._offset > self._failure:
                                                                                                        self._failure = self._offset
                                                                                                        self._expected = []
                                                                                                    if self._offset == self._failure:
                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                self._offset = index45
                                                                                                if address44 is FAILURE:
                                                                                                    address44 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                    self._offset = self._offset
                                                                                                else:
                                                                                                    address44 = FAILURE
                                                                                                if address44 is not FAILURE:
                                                                                                    elements21.append(address44)
                                                                                                else:
                                                                                                    elements21 = None
                                                                                                    self._offset = index44
                                                                                            else:
                                                                                                elements21 = None
                                                                                                self._offset = index44
                                                                                            if elements21 is None:
                                                                                                address0 = FAILURE
                                                                                            else:
                                                                                                address0 = TreeNode(self._input[index44:self._offset], index44, elements21)
                                                                                                self._offset = self._offset
                                                                                            if address0 is FAILURE:
                                                                                                self._offset = index1
                                                                                                index46, elements22 = self._offset, []
                                                                                                address45 = FAILURE
                                                                                                chunk44, max44 = None, self._offset + 4
                                                                                                if max44 <= self._input_size:
                                                                                                    chunk44 = self._input[self._offset:max44]
                                                                                                if chunk44 == 'then':
                                                                                                    address45 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                                    self._offset = self._offset + 4
                                                                                                else:
                                                                                                    address45 = FAILURE
                                                                                                    if self._offset > self._failure:
                                                                                                        self._failure = self._offset
                                                                                                        self._expected = []
                                                                                                    if self._offset == self._failure:
                                                                                                        self._expected.append('\'then\'')
                                                                                                if address45 is not FAILURE:
                                                                                                    elements22.append(address45)
                                                                                                    address46 = FAILURE
                                                                                                    index47 = self._offset
                                                                                                    chunk45, max45 = None, self._offset + 1
                                                                                                    if max45 <= self._input_size:
                                                                                                        chunk45 = self._input[self._offset:max45]
                                                                                                    if chunk45 is not None and Grammar.REGEX_27.search(chunk45):
                                                                                                        address46 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                        self._offset = self._offset + 1
                                                                                                    else:
                                                                                                        address46 = FAILURE
                                                                                                        if self._offset > self._failure:
                                                                                                            self._failure = self._offset
                                                                                                            self._expected = []
                                                                                                        if self._offset == self._failure:
                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                    self._offset = index47
                                                                                                    if address46 is FAILURE:
                                                                                                        address46 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                        self._offset = self._offset
                                                                                                    else:
                                                                                                        address46 = FAILURE
                                                                                                    if address46 is not FAILURE:
                                                                                                        elements22.append(address46)
                                                                                                    else:
                                                                                                        elements22 = None
                                                                                                        self._offset = index46
                                                                                                else:
                                                                                                    elements22 = None
                                                                                                    self._offset = index46
                                                                                                if elements22 is None:
                                                                                                    address0 = FAILURE
                                                                                                else:
                                                                                                    address0 = TreeNode(self._input[index46:self._offset], index46, elements22)
                                                                                                    self._offset = self._offset
                                                                                                if address0 is FAILURE:
                                                                                                    self._offset = index1
                                                                                                    index48, elements23 = self._offset, []
                                                                                                    address47 = FAILURE
                                                                                                    chunk46, max46 = None, self._offset + 3
                                                                                                    if max46 <= self._input_size:
                                                                                                        chunk46 = self._input[self._offset:max46]
                                                                                                    if chunk46 == 'and':
                                                                                                        address47 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                        self._offset = self._offset + 3
                                                                                                    else:
                                                                                                        address47 = FAILURE
                                                                                                        if self._offset > self._failure:
                                                                                                            self._failure = self._offset
                                                                                                            self._expected = []
                                                                                                        if self._offset == self._failure:
                                                                                                            self._expected.append('\'and\'')
                                                                                                    if address47 is not FAILURE:
                                                                                                        elements23.append(address47)
                                                                                                        address48 = FAILURE
                                                                                                        index49 = self._offset
                                                                                                        chunk47, max47 = None, self._offset + 1
                                                                                                        if max47 <= self._input_size:
                                                                                                            chunk47 = self._input[self._offset:max47]
                                                                                                        if chunk47 is not None and Grammar.REGEX_28.search(chunk47):
                                                                                                            address48 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                            self._offset = self._offset + 1
                                                                                                        else:
                                                                                                            address48 = FAILURE
                                                                                                            if self._offset > self._failure:
                                                                                                                self._failure = self._offset
                                                                                                                self._expected = []
                                                                                                            if self._offset == self._failure:
                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                        self._offset = index49
                                                                                                        if address48 is FAILURE:
                                                                                                            address48 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                            self._offset = self._offset
                                                                                                        else:
                                                                                                            address48 = FAILURE
                                                                                                        if address48 is not FAILURE:
                                                                                                            elements23.append(address48)
                                                                                                        else:
                                                                                                            elements23 = None
                                                                                                            self._offset = index48
                                                                                                    else:
                                                                                                        elements23 = None
                                                                                                        self._offset = index48
                                                                                                    if elements23 is None:
                                                                                                        address0 = FAILURE
                                                                                                    else:
                                                                                                        address0 = TreeNode(self._input[index48:self._offset], index48, elements23)
                                                                                                        self._offset = self._offset
                                                                                                    if address0 is FAILURE:
                                                                                                        self._offset = index1
                                                                                                        index50, elements24 = self._offset, []
                                                                                                        address49 = FAILURE
                                                                                                        chunk48, max48 = None, self._offset + 2
                                                                                                        if max48 <= self._input_size:
                                                                                                            chunk48 = self._input[self._offset:max48]
                                                                                                        if chunk48 == 'or':
                                                                                                            address49 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                                                            self._offset = self._offset + 2
                                                                                                        else:
                                                                                                            address49 = FAILURE
                                                                                                            if self._offset > self._failure:
                                                                                                                self._failure = self._offset
                                                                                                                self._expected = []
                                                                                                            if self._offset == self._failure:
                                                                                                                self._expected.append('\'or\'')
                                                                                                        if address49 is not FAILURE:
                                                                                                            elements24.append(address49)
                                                                                                            address50 = FAILURE
                                                                                                            index51 = self._offset
                                                                                                            chunk49, max49 = None, self._offset + 1
                                                                                                            if max49 <= self._input_size:
                                                                                                                chunk49 = self._input[self._offset:max49]
                                                                                                            if chunk49 is not None and Grammar.REGEX_29.search(chunk49):
                                                                                                                address50 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                self._offset = self._offset + 1
                                                                                                            else:
                                                                                                                address50 = FAILURE
                                                                                                                if self._offset > self._failure:
                                                                                                                    self._failure = self._offset
                                                                                                                    self._expected = []
                                                                                                                if self._offset == self._failure:
                                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                                            self._offset = index51
                                                                                                            if address50 is FAILURE:
                                                                                                                address50 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                self._offset = self._offset
                                                                                                            else:
                                                                                                                address50 = FAILURE
                                                                                                            if address50 is not FAILURE:
                                                                                                                elements24.append(address50)
                                                                                                            else:
                                                                                                                elements24 = None
                                                                                                                self._offset = index50
                                                                                                        else:
                                                                                                            elements24 = None
                                                                                                            self._offset = index50
                                                                                                        if elements24 is None:
                                                                                                            address0 = FAILURE
                                                                                                        else:
                                                                                                            address0 = TreeNode(self._input[index50:self._offset], index50, elements24)
                                                                                                            self._offset = self._offset
                                                                                                        if address0 is FAILURE:
                                                                                                            self._offset = index1
                                                                                                            index52, elements25 = self._offset, []
                                                                                                            address51 = FAILURE
                                                                                                            chunk50, max50 = None, self._offset + 3
                                                                                                            if max50 <= self._input_size:
                                                                                                                chunk50 = self._input[self._offset:max50]
                                                                                                            if chunk50 == 'not':
                                                                                                                address51 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                self._offset = self._offset + 3
                                                                                                            else:
                                                                                                                address51 = FAILURE
                                                                                                                if self._offset > self._failure:
                                                                                                                    self._failure = self._offset
                                                                                                                    self._expected = []
                                                                                                                if self._offset == self._failure:
                                                                                                                    self._expected.append('\'not\'')
                                                                                                            if address51 is not FAILURE:
                                                                                                                elements25.append(address51)
                                                                                                                address52 = FAILURE
                                                                                                                index53 = self._offset
                                                                                                                chunk51, max51 = None, self._offset + 1
                                                                                                                if max51 <= self._input_size:
                                                                                                                    chunk51 = self._input[self._offset:max51]
                                                                                                                if chunk51 is not None and Grammar.REGEX_30.search(chunk51):
                                                                                                                    address52 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                    self._offset = self._offset + 1
                                                                                                                else:
                                                                                                                    address52 = FAILURE
                                                                                                                    if self._offset > self._failure:
                                                                                                                        self._failure = self._offset
                                                                                                                        self._expected = []
                                                                                                                    if self._offset == self._failure:
                                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                                self._offset = index53
                                                                                                                if address52 is FAILURE:
                                                                                                                    address52 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                    self._offset = self._offset
                                                                                                                else:
                                                                                                                    address52 = FAILURE
                                                                                                                if address52 is not FAILURE:
                                                                                                                    elements25.append(address52)
                                                                                                                else:
                                                                                                                    elements25 = None
                                                                                                                    self._offset = index52
                                                                                                            else:
                                                                                                                elements25 = None
                                                                                                                self._offset = index52
                                                                                                            if elements25 is None:
                                                                                                                address0 = FAILURE
                                                                                                            else:
                                                                                                                address0 = TreeNode(self._input[index52:self._offset], index52, elements25)
                                                                                                                self._offset = self._offset
                                                                                                            if address0 is FAILURE:
                                                                                                                self._offset = index1
                                                                                                                index54, elements26 = self._offset, []
                                                                                                                address53 = FAILURE
                                                                                                                chunk52, max52 = None, self._offset + 3
                                                                                                                if max52 <= self._input_size:
                                                                                                                    chunk52 = self._input[self._offset:max52]
                                                                                                                if chunk52 == 'has':
                                                                                                                    address53 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                    self._offset = self._offset + 3
                                                                                                                else:
                                                                                                                    address53 = FAILURE
                                                                                                                    if self._offset > self._failure:
                                                                                                                        self._failure = self._offset
                                                                                                                        self._expected = []
                                                                                                                    if self._offset == self._failure:
                                                                                                                        self._expected.append('\'has\'')
                                                                                                                if address53 is not FAILURE:
                                                                                                                    elements26.append(address53)
                                                                                                                    address54 = FAILURE
                                                                                                                    index55 = self._offset
                                                                                                                    chunk53, max53 = None, self._offset + 1
                                                                                                                    if max53 <= self._input_size:
                                                                                                                        chunk53 = self._input[self._offset:max53]
                                                                                                                    if chunk53 is not None and Grammar.REGEX_31.search(chunk53):
                                                                                                                        address54 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                        self._offset = self._offset + 1
                                                                                                                    else:
                                                                                                                        address54 = FAILURE
                                                                                                                        if self._offset > self._failure:
                                                                                                                            self._failure = self._offset
                                                                                                                            self._expected = []
                                                                                                                        if self._offset == self._failure:
                                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                                    self._offset = index55
                                                                                                                    if address54 is FAILURE:
                                                                                                                        address54 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                        self._offset = self._offset
                                                                                                                    else:
                                                                                                                        address54 = FAILURE
                                                                                                                    if address54 is not FAILURE:
                                                                                                                        elements26.append(address54)
                                                                                                                    else:
                                                                                                                        elements26 = None
                                                                                                                        self._offset = index54
                                                                                                                else:
                                                                                                                    elements26 = None
                                                                                                                    self._offset = index54
                                                                                                                if elements26 is None:
                                                                                                                    address0 = FAILURE
                                                                                                                else:
                                                                                                                    address0 = TreeNode(self._input[index54:self._offset], index54, elements26)
                                                                                                                    self._offset = self._offset
                                                                                                                if address0 is FAILURE:
                                                                                                                    self._offset = index1
                                                                                                                    index56, elements27 = self._offset, []
                                                                                                                    address55 = FAILURE
                                                                                                                    chunk54, max54 = None, self._offset + 9
                                                                                                                    if max54 <= self._input_size:
                                                                                                                        chunk54 = self._input[self._offset:max54]
                                                                                                                    if chunk54 == 'otherwise':
                                                                                                                        address55 = TreeNode(self._input[self._offset:self._offset + 9], self._offset, [])
                                                                                                                        self._offset = self._offset + 9
                                                                                                                    else:
                                                                                                                        address55 = FAILURE
                                                                                                                        if self._offset > self._failure:
                                                                                                                            self._failure = self._offset
                                                                                                                            self._expected = []
                                                                                                                        if self._offset == self._failure:
                                                                                                                            self._expected.append('\'otherwise\'')
                                                                                                                    if address55 is not FAILURE:
                                                                                                                        elements27.append(address55)
                                                                                                                        address56 = FAILURE
                                                                                                                        index57 = self._offset
                                                                                                                        chunk55, max55 = None, self._offset + 1
                                                                                                                        if max55 <= self._input_size:
                                                                                                                            chunk55 = self._input[self._offset:max55]
                                                                                                                        if chunk55 is not None and Grammar.REGEX_32.search(chunk55):
                                                                                                                            address56 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                            self._offset = self._offset + 1
                                                                                                                        else:
                                                                                                                            address56 = FAILURE
                                                                                                                            if self._offset > self._failure:
                                                                                                                                self._failure = self._offset
                                                                                                                                self._expected = []
                                                                                                                            if self._offset == self._failure:
                                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                                        self._offset = index57
                                                                                                                        if address56 is FAILURE:
                                                                                                                            address56 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                            self._offset = self._offset
                                                                                                                        else:
                                                                                                                            address56 = FAILURE
                                                                                                                        if address56 is not FAILURE:
                                                                                                                            elements27.append(address56)
                                                                                                                        else:
                                                                                                                            elements27 = None
                                                                                                                            self._offset = index56
                                                                                                                    else:
                                                                                                                        elements27 = None
                                                                                                                        self._offset = index56
                                                                                                                    if elements27 is None:
                                                                                                                        address0 = FAILURE
                                                                                                                    else:
                                                                                                                        address0 = TreeNode(self._input[index56:self._offset], index56, elements27)
                                                                                                                        self._offset = self._offset
                                                                                                                    if address0 is FAILURE:
                                                                                                                        self._offset = index1
                                                                                                                        index58, elements28 = self._offset, []
                                                                                                                        address57 = FAILURE
                                                                                                                        chunk56, max56 = None, self._offset + 6
                                                                                                                        if max56 <= self._input_size:
                                                                                                                            chunk56 = self._input[self._offset:max56]
                                                                                                                        if chunk56 == 'unless':
                                                                                                                            address57 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                                                                                                            self._offset = self._offset + 6
                                                                                                                        else:
                                                                                                                            address57 = FAILURE
                                                                                                                            if self._offset > self._failure:
                                                                                                                                self._failure = self._offset
                                                                                                                                self._expected = []
                                                                                                                            if self._offset == self._failure:
                                                                                                                                self._expected.append('\'unless\'')
                                                                                                                        if address57 is not FAILURE:
                                                                                                                            elements28.append(address57)
                                                                                                                            address58 = FAILURE
                                                                                                                            index59 = self._offset
                                                                                                                            chunk57, max57 = None, self._offset + 1
                                                                                                                            if max57 <= self._input_size:
                                                                                                                                chunk57 = self._input[self._offset:max57]
                                                                                                                            if chunk57 is not None and Grammar.REGEX_33.search(chunk57):
                                                                                                                                address58 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                self._offset = self._offset + 1
                                                                                                                            else:
                                                                                                                                address58 = FAILURE
                                                                                                                                if self._offset > self._failure:
                                                                                                                                    self._failure = self._offset
                                                                                                                                    self._expected = []
                                                                                                                                if self._offset == self._failure:
                                                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                                                            self._offset = index59
                                                                                                                            if address58 is FAILURE:
                                                                                                                                address58 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                self._offset = self._offset
                                                                                                                            else:
                                                                                                                                address58 = FAILURE
                                                                                                                            if address58 is not FAILURE:
                                                                                                                                elements28.append(address58)
                                                                                                                            else:
                                                                                                                                elements28 = None
                                                                                                                                self._offset = index58
                                                                                                                        else:
                                                                                                                            elements28 = None
                                                                                                                            self._offset = index58
                                                                                                                        if elements28 is None:
                                                                                                                            address0 = FAILURE
                                                                                                                        else:
                                                                                                                            address0 = TreeNode(self._input[index58:self._offset], index58, elements28)
                                                                                                                            self._offset = self._offset
                                                                                                                        if address0 is FAILURE:
                                                                                                                            self._offset = index1
                                                                                                                            index60, elements29 = self._offset, []
                                                                                                                            address59 = FAILURE
                                                                                                                            chunk58, max58 = None, self._offset + 3
                                                                                                                            if max58 <= self._input_size:
                                                                                                                                chunk58 = self._input[self._offset:max58]
                                                                                                                            if chunk58 == 'and':
                                                                                                                                address59 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                self._offset = self._offset + 3
                                                                                                                            else:
                                                                                                                                address59 = FAILURE
                                                                                                                                if self._offset > self._failure:
                                                                                                                                    self._failure = self._offset
                                                                                                                                    self._expected = []
                                                                                                                                if self._offset == self._failure:
                                                                                                                                    self._expected.append('\'and\'')
                                                                                                                            if address59 is not FAILURE:
                                                                                                                                elements29.append(address59)
                                                                                                                                address60 = FAILURE
                                                                                                                                index61 = self._offset
                                                                                                                                chunk59, max59 = None, self._offset + 1
                                                                                                                                if max59 <= self._input_size:
                                                                                                                                    chunk59 = self._input[self._offset:max59]
                                                                                                                                if chunk59 is not None and Grammar.REGEX_34.search(chunk59):
                                                                                                                                    address60 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                    self._offset = self._offset + 1
                                                                                                                                else:
                                                                                                                                    address60 = FAILURE
                                                                                                                                    if self._offset > self._failure:
                                                                                                                                        self._failure = self._offset
                                                                                                                                        self._expected = []
                                                                                                                                    if self._offset == self._failure:
                                                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                self._offset = index61
                                                                                                                                if address60 is FAILURE:
                                                                                                                                    address60 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                    self._offset = self._offset
                                                                                                                                else:
                                                                                                                                    address60 = FAILURE
                                                                                                                                if address60 is not FAILURE:
                                                                                                                                    elements29.append(address60)
                                                                                                                                else:
                                                                                                                                    elements29 = None
                                                                                                                                    self._offset = index60
                                                                                                                            else:
                                                                                                                                elements29 = None
                                                                                                                                self._offset = index60
                                                                                                                            if elements29 is None:
                                                                                                                                address0 = FAILURE
                                                                                                                            else:
                                                                                                                                address0 = TreeNode(self._input[index60:self._offset], index60, elements29)
                                                                                                                                self._offset = self._offset
                                                                                                                            if address0 is FAILURE:
                                                                                                                                self._offset = index1
                                                                                                                                index62, elements30 = self._offset, []
                                                                                                                                address61 = FAILURE
                                                                                                                                chunk60, max60 = None, self._offset + 3
                                                                                                                                if max60 <= self._input_size:
                                                                                                                                    chunk60 = self._input[self._offset:max60]
                                                                                                                                if chunk60 == 'has':
                                                                                                                                    address61 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                    self._offset = self._offset + 3
                                                                                                                                else:
                                                                                                                                    address61 = FAILURE
                                                                                                                                    if self._offset > self._failure:
                                                                                                                                        self._failure = self._offset
                                                                                                                                        self._expected = []
                                                                                                                                    if self._offset == self._failure:
                                                                                                                                        self._expected.append('\'has\'')
                                                                                                                                if address61 is not FAILURE:
                                                                                                                                    elements30.append(address61)
                                                                                                                                    address62 = FAILURE
                                                                                                                                    index63 = self._offset
                                                                                                                                    chunk61, max61 = None, self._offset + 1
                                                                                                                                    if max61 <= self._input_size:
                                                                                                                                        chunk61 = self._input[self._offset:max61]
                                                                                                                                    if chunk61 is not None and Grammar.REGEX_35.search(chunk61):
                                                                                                                                        address62 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                        self._offset = self._offset + 1
                                                                                                                                    else:
                                                                                                                                        address62 = FAILURE
                                                                                                                                        if self._offset > self._failure:
                                                                                                                                            self._failure = self._offset
                                                                                                                                            self._expected = []
                                                                                                                                        if self._offset == self._failure:
                                                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                    self._offset = index63
                                                                                                                                    if address62 is FAILURE:
                                                                                                                                        address62 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                        self._offset = self._offset
                                                                                                                                    else:
                                                                                                                                        address62 = FAILURE
                                                                                                                                    if address62 is not FAILURE:
                                                                                                                                        elements30.append(address62)
                                                                                                                                    else:
                                                                                                                                        elements30 = None
                                                                                                                                        self._offset = index62
                                                                                                                                else:
                                                                                                                                    elements30 = None
                                                                                                                                    self._offset = index62
                                                                                                                                if elements30 is None:
                                                                                                                                    address0 = FAILURE
                                                                                                                                else:
                                                                                                                                    address0 = TreeNode(self._input[index62:self._offset], index62, elements30)
                                                                                                                                    self._offset = self._offset
                                                                                                                                if address0 is FAILURE:
                                                                                                                                    self._offset = index1
                                                                                                                                    index64, elements31 = self._offset, []
                                                                                                                                    address63 = FAILURE
                                                                                                                                    chunk62, max62 = None, self._offset + 3
                                                                                                                                    if max62 <= self._input_size:
                                                                                                                                        chunk62 = self._input[self._offset:max62]
                                                                                                                                    if chunk62 == 'not':
                                                                                                                                        address63 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                        self._offset = self._offset + 3
                                                                                                                                    else:
                                                                                                                                        address63 = FAILURE
                                                                                                                                        if self._offset > self._failure:
                                                                                                                                            self._failure = self._offset
                                                                                                                                            self._expected = []
                                                                                                                                        if self._offset == self._failure:
                                                                                                                                            self._expected.append('\'not\'')
                                                                                                                                    if address63 is not FAILURE:
                                                                                                                                        elements31.append(address63)
                                                                                                                                        address64 = FAILURE
                                                                                                                                        index65 = self._offset
                                                                                                                                        chunk63, max63 = None, self._offset + 1
                                                                                                                                        if max63 <= self._input_size:
                                                                                                                                            chunk63 = self._input[self._offset:max63]
                                                                                                                                        if chunk63 is not None and Grammar.REGEX_36.search(chunk63):
                                                                                                                                            address64 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                            self._offset = self._offset + 1
                                                                                                                                        else:
                                                                                                                                            address64 = FAILURE
                                                                                                                                            if self._offset > self._failure:
                                                                                                                                                self._failure = self._offset
                                                                                                                                                self._expected = []
                                                                                                                                            if self._offset == self._failure:
                                                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                        self._offset = index65
                                                                                                                                        if address64 is FAILURE:
                                                                                                                                            address64 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                            self._offset = self._offset
                                                                                                                                        else:
                                                                                                                                            address64 = FAILURE
                                                                                                                                        if address64 is not FAILURE:
                                                                                                                                            elements31.append(address64)
                                                                                                                                        else:
                                                                                                                                            elements31 = None
                                                                                                                                            self._offset = index64
                                                                                                                                    else:
                                                                                                                                        elements31 = None
                                                                                                                                        self._offset = index64
                                                                                                                                    if elements31 is None:
                                                                                                                                        address0 = FAILURE
                                                                                                                                    else:
                                                                                                                                        address0 = TreeNode(self._input[index64:self._offset], index64, elements31)
                                                                                                                                        self._offset = self._offset
                                                                                                                                    if address0 is FAILURE:
                                                                                                                                        self._offset = index1
                                                                                                                                        index66, elements32 = self._offset, []
                                                                                                                                        address65 = FAILURE
                                                                                                                                        chunk64, max64 = None, self._offset + 2
                                                                                                                                        if max64 <= self._input_size:
                                                                                                                                            chunk64 = self._input[self._offset:max64]
                                                                                                                                        if chunk64 == 'or':
                                                                                                                                            address65 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                                                                                            self._offset = self._offset + 2
                                                                                                                                        else:
                                                                                                                                            address65 = FAILURE
                                                                                                                                            if self._offset > self._failure:
                                                                                                                                                self._failure = self._offset
                                                                                                                                                self._expected = []
                                                                                                                                            if self._offset == self._failure:
                                                                                                                                                self._expected.append('\'or\'')
                                                                                                                                        if address65 is not FAILURE:
                                                                                                                                            elements32.append(address65)
                                                                                                                                            address66 = FAILURE
                                                                                                                                            index67 = self._offset
                                                                                                                                            chunk65, max65 = None, self._offset + 1
                                                                                                                                            if max65 <= self._input_size:
                                                                                                                                                chunk65 = self._input[self._offset:max65]
                                                                                                                                            if chunk65 is not None and Grammar.REGEX_37.search(chunk65):
                                                                                                                                                address66 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                self._offset = self._offset + 1
                                                                                                                                            else:
                                                                                                                                                address66 = FAILURE
                                                                                                                                                if self._offset > self._failure:
                                                                                                                                                    self._failure = self._offset
                                                                                                                                                    self._expected = []
                                                                                                                                                if self._offset == self._failure:
                                                                                                                                                    self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                            self._offset = index67
                                                                                                                                            if address66 is FAILURE:
                                                                                                                                                address66 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                self._offset = self._offset
                                                                                                                                            else:
                                                                                                                                                address66 = FAILURE
                                                                                                                                            if address66 is not FAILURE:
                                                                                                                                                elements32.append(address66)
                                                                                                                                            else:
                                                                                                                                                elements32 = None
                                                                                                                                                self._offset = index66
                                                                                                                                        else:
                                                                                                                                            elements32 = None
                                                                                                                                            self._offset = index66
                                                                                                                                        if elements32 is None:
                                                                                                                                            address0 = FAILURE
                                                                                                                                        else:
                                                                                                                                            address0 = TreeNode(self._input[index66:self._offset], index66, elements32)
                                                                                                                                            self._offset = self._offset
                                                                                                                                        if address0 is FAILURE:
                                                                                                                                            self._offset = index1
                                                                                                                                            index68, elements33 = self._offset, []
                                                                                                                                            address67 = FAILURE
                                                                                                                                            chunk66, max66 = None, self._offset + 3
                                                                                                                                            if max66 <= self._input_size:
                                                                                                                                                chunk66 = self._input[self._offset:max66]
                                                                                                                                            if chunk66 == 'isa':
                                                                                                                                                address67 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                                                                self._offset = self._offset + 3
                                                                                                                                            else:
                                                                                                                                                address67 = FAILURE
                                                                                                                                                if self._offset > self._failure:
                                                                                                                                                    self._failure = self._offset
                                                                                                                                                    self._expected = []
                                                                                                                                                if self._offset == self._failure:
                                                                                                                                                    self._expected.append('\'isa\'')
                                                                                                                                            if address67 is not FAILURE:
                                                                                                                                                elements33.append(address67)
                                                                                                                                                address68 = FAILURE
                                                                                                                                                index69 = self._offset
                                                                                                                                                chunk67, max67 = None, self._offset + 1
                                                                                                                                                if max67 <= self._input_size:
                                                                                                                                                    chunk67 = self._input[self._offset:max67]
                                                                                                                                                if chunk67 is not None and Grammar.REGEX_38.search(chunk67):
                                                                                                                                                    address68 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                    self._offset = self._offset + 1
                                                                                                                                                else:
                                                                                                                                                    address68 = FAILURE
                                                                                                                                                    if self._offset > self._failure:
                                                                                                                                                        self._failure = self._offset
                                                                                                                                                        self._expected = []
                                                                                                                                                    if self._offset == self._failure:
                                                                                                                                                        self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                                self._offset = index69
                                                                                                                                                if address68 is FAILURE:
                                                                                                                                                    address68 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                    self._offset = self._offset
                                                                                                                                                else:
                                                                                                                                                    address68 = FAILURE
                                                                                                                                                if address68 is not FAILURE:
                                                                                                                                                    elements33.append(address68)
                                                                                                                                                else:
                                                                                                                                                    elements33 = None
                                                                                                                                                    self._offset = index68
                                                                                                                                            else:
                                                                                                                                                elements33 = None
                                                                                                                                                self._offset = index68
                                                                                                                                            if elements33 is None:
                                                                                                                                                address0 = FAILURE
                                                                                                                                            else:
                                                                                                                                                address0 = TreeNode(self._input[index68:self._offset], index68, elements33)
                                                                                                                                                self._offset = self._offset
                                                                                                                                            if address0 is FAILURE:
                                                                                                                                                self._offset = index1
                                                                                                                                                index70, elements34 = self._offset, []
                                                                                                                                                address69 = FAILURE
                                                                                                                                                chunk68, max68 = None, self._offset + 5
                                                                                                                                                if max68 <= self._input_size:
                                                                                                                                                    chunk68 = self._input[self._offset:max68]
                                                                                                                                                if chunk68 == 'clear':
                                                                                                                                                    address69 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                                                                                                                                    self._offset = self._offset + 5
                                                                                                                                                else:
                                                                                                                                                    address69 = FAILURE
                                                                                                                                                    if self._offset > self._failure:
                                                                                                                                                        self._failure = self._offset
                                                                                                                                                        self._expected = []
                                                                                                                                                    if self._offset == self._failure:
                                                                                                                                                        self._expected.append('\'clear\'')
                                                                                                                                                if address69 is not FAILURE:
                                                                                                                                                    elements34.append(address69)
                                                                                                                                                    address70 = FAILURE
                                                                                                                                                    index71 = self._offset
                                                                                                                                                    chunk69, max69 = None, self._offset + 1
                                                                                                                                                    if max69 <= self._input_size:
                                                                                                                                                        chunk69 = self._input[self._offset:max69]
                                                                                                                                                    if chunk69 is not None and Grammar.REGEX_39.search(chunk69):
                                                                                                                                                        address70 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                        self._offset = self._offset + 1
                                                                                                                                                    else:
                                                                                                                                                        address70 = FAILURE
                                                                                                                                                        if self._offset > self._failure:
                                                                                                                                                            self._failure = self._offset
                                                                                                                                                            self._expected = []
                                                                                                                                                        if self._offset == self._failure:
                                                                                                                                                            self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                                    self._offset = index71
                                                                                                                                                    if address70 is FAILURE:
                                                                                                                                                        address70 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                        self._offset = self._offset
                                                                                                                                                    else:
                                                                                                                                                        address70 = FAILURE
                                                                                                                                                    if address70 is not FAILURE:
                                                                                                                                                        elements34.append(address70)
                                                                                                                                                    else:
                                                                                                                                                        elements34 = None
                                                                                                                                                        self._offset = index70
                                                                                                                                                else:
                                                                                                                                                    elements34 = None
                                                                                                                                                    self._offset = index70
                                                                                                                                                if elements34 is None:
                                                                                                                                                    address0 = FAILURE
                                                                                                                                                else:
                                                                                                                                                    address0 = TreeNode(self._input[index70:self._offset], index70, elements34)
                                                                                                                                                    self._offset = self._offset
                                                                                                                                                if address0 is FAILURE:
                                                                                                                                                    self._offset = index1
                                                                                                                                                    index72, elements35 = self._offset, []
                                                                                                                                                    address71 = FAILURE
                                                                                                                                                    chunk70, max70 = None, self._offset + 7
                                                                                                                                                    if max70 <= self._input_size:
                                                                                                                                                        chunk70 = self._input[self._offset:max70]
                                                                                                                                                    if chunk70 == 'restart':
                                                                                                                                                        address71 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                                                                                                                                        self._offset = self._offset + 7
                                                                                                                                                    else:
                                                                                                                                                        address71 = FAILURE
                                                                                                                                                        if self._offset > self._failure:
                                                                                                                                                            self._failure = self._offset
                                                                                                                                                            self._expected = []
                                                                                                                                                        if self._offset == self._failure:
                                                                                                                                                            self._expected.append('\'restart\'')
                                                                                                                                                    if address71 is not FAILURE:
                                                                                                                                                        elements35.append(address71)
                                                                                                                                                        address72 = FAILURE
                                                                                                                                                        index73 = self._offset
                                                                                                                                                        chunk71, max71 = None, self._offset + 1
                                                                                                                                                        if max71 <= self._input_size:
                                                                                                                                                            chunk71 = self._input[self._offset:max71]
                                                                                                                                                        if chunk71 is not None and Grammar.REGEX_40.search(chunk71):
                                                                                                                                                            address72 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                                                                                                            self._offset = self._offset + 1
                                                                                                                                                        else:
                                                                                                                                                            address72 = FAILURE
                                                                                                                                                            if self._offset > self._failure:
                                                                                                                                                                self._failure = self._offset
                                                                                                                                                                self._expected = []
                                                                                                                                                            if self._offset == self._failure:
                                                                                                                                                                self._expected.append('[0-9a-zA-Z_]')
                                                                                                                                                        self._offset = index73
                                                                                                                                                        if address72 is FAILURE:
                                                                                                                                                            address72 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                                                                                                                            self._offset = self._offset
                                                                                                                                                        else:
                                                                                                                                                            address72 = FAILURE
                                                                                                                                                        if address72 is not FAILURE:
                                                                                                                                                            elements35.append(address72)
                                                                                                                                                        else:
                                                                                                                                                            elements35 = None
                                                                                                                                                            self._offset = index72
                                                                                                                                                    else:
                                                                                                                                                        elements35 = None
                                                                                                                                                        self._offset = index72
                                                                                                                                                    if elements35 is None:
                                                                                                                                                        address0 = FAILURE
                                                                                                                                                    else:
                                                                                                                                                        address0 = TreeNode(self._input[index72:self._offset], index72, elements35)
                                                                                                                                                        self._offset = self._offset
                                                                                                                                                    if address0 is FAILURE:
                                                                                                                                                        self._offset = index1
        self._cache['keyword'][index0] = (address0, self._offset)
        return address0

    def _read_eos(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['eos'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_eol()
        if address0 is FAILURE:
            self._offset = index1
            remaining0, index2, elements0, address1 = 1, self._offset, [], True
            while address1 is not FAILURE:
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '|':
                    address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address1 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'|\'')
                if address1 is not FAILURE:
                    elements0.append(address1)
                    remaining0 -= 1
            if remaining0 <= 0:
                address0 = self._actions.ignore(self._input, index2, self._offset, elements0)
                self._offset = self._offset
            else:
                address0 = FAILURE
            if address0 is FAILURE:
                self._offset = index1
                index3, elements1 = self._offset, []
                address2 = FAILURE
                address2 = self._read__()
                if address2 is not FAILURE:
                    elements1.append(address2)
                    address3 = FAILURE
                    index4 = self._offset
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == ']':
                        address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address3 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\']\'')
                    self._offset = index4
                    if address3 is not FAILURE:
                        address3 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address3 = FAILURE
                    if address3 is not FAILURE:
                        elements1.append(address3)
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
                if elements1 is None:
                    address0 = FAILURE
                else:
                    address0 = TreeNode3(self._input[index3:self._offset], index3, elements1)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index5, elements2 = self._offset, []
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements2.append(address4)
                        address5 = FAILURE
                        index6 = self._offset
                        chunk2, max2 = None, self._offset + 2
                        if max2 <= self._input_size:
                            chunk2 = self._input[self._offset:max2]
                        if chunk2 == ':}':
                            address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                            self._offset = self._offset + 2
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\':}\'')
                        self._offset = index6
                        if address5 is not FAILURE:
                            address5 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address5 = FAILURE
                        if address5 is not FAILURE:
                            elements2.append(address5)
                        else:
                            elements2 = None
                            self._offset = index5
                    else:
                        elements2 = None
                        self._offset = index5
                    if elements2 is None:
                        address0 = FAILURE
                    else:
                        address0 = TreeNode4(self._input[index5:self._offset], index5, elements2)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index7, elements3 = self._offset, []
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements3.append(address6)
                            address7 = FAILURE
                            index8 = self._offset
                            chunk3, max3 = None, self._offset + 3
                            if max3 <= self._input_size:
                                chunk3 = self._input[self._offset:max3]
                            if chunk3 == 'but':
                                address7 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                self._offset = self._offset + 3
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'but\'')
                            self._offset = index8
                            if address7 is not FAILURE:
                                address7 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                self._offset = self._offset
                            else:
                                address7 = FAILURE
                            if address7 is not FAILURE:
                                elements3.append(address7)
                            else:
                                elements3 = None
                                self._offset = index7
                        else:
                            elements3 = None
                            self._offset = index7
                        if elements3 is None:
                            address0 = FAILURE
                        else:
                            address0 = TreeNode5(self._input[index7:self._offset], index7, elements3)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['eos'][index0] = (address0, self._offset)
        return address0

    def _read__ws(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['_ws'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        remaining0, index1, elements0, address1 = 0, self._offset, [], True
        while address1 is not FAILURE:
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 is not None and Grammar.REGEX_41.search(chunk0):
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[\\n\\r\\f \\t]')
            if address1 is not FAILURE:
                elements0.append(address1)
                remaining0 -= 1
        if remaining0 <= 0:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        else:
            address0 = FAILURE
        self._cache['_ws'][index0] = (address0, self._offset)
        return address0

    def _read_line_joining(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['line_joining'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '%>':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'%>\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index2, elements1, address4 = 1, self._offset, [], True
                while address4 is not FAILURE:
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 is not None and Grammar.REGEX_42.search(chunk1):
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[\\n\\r\\f]')
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index2:self._offset], index2, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.ignore(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['line_joining'][index0] = (address0, self._offset)
        return address0

    def _read_float(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['float'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '-':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'-\'')
        if address1 is FAILURE:
            address1 = TreeNode(self._input[index2:index2], index2, [])
            self._offset = index2
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_43.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[0-9]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address4 = FAILURE
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '.':
                    address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address4 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'.\'')
                if address4 is not FAILURE:
                    elements0.append(address4)
                    address5 = FAILURE
                    remaining1, index4, elements2, address6 = 1, self._offset, [], True
                    while address6 is not FAILURE:
                        chunk3, max3 = None, self._offset + 1
                        if max3 <= self._input_size:
                            chunk3 = self._input[self._offset:max3]
                        if chunk3 is not None and Grammar.REGEX_44.search(chunk3):
                            address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address6 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('[0-9]')
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            remaining1 -= 1
                    if remaining1 <= 0:
                        address5 = TreeNode(self._input[index4:self._offset], index4, elements2)
                        self._offset = self._offset
                    else:
                        address5 = FAILURE
                    if address5 is not FAILURE:
                        elements0.append(address5)
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.float_(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['float'][index0] = (address0, self._offset)
        return address0

    def _read_int(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['int'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '-':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'-\'')
        if address1 is FAILURE:
            address1 = TreeNode(self._input[index2:index2], index2, [])
            self._offset = index2
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 1, self._offset, [], True
            while address3 is not FAILURE:
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 is not None and Grammar.REGEX_45.search(chunk1):
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('[0-9]')
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.int_(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['int'][index0] = (address0, self._offset)
        return address0

    def _read_number(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['number'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_float()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_int()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['number'][index0] = (address0, self._offset)
        return address0

    def _read_string_escape(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['string_escape'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '\\':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('"\\\\"')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 is not None and Grammar.REGEX_46.search(chunk1):
                address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[\\\\runftvb\']')
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['string_escape'][index0] = (address0, self._offset)
        return address0

    def _read_string(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['string'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '\'':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('"\'"')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index2, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                index3 = self._offset
                address3 = self._read_string_escape()
                if address3 is FAILURE:
                    self._offset = index3
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 is not None and Grammar.REGEX_47.search(chunk1):
                        address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address3 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[^\']')
                    if address3 is FAILURE:
                        self._offset = index3
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index2:self._offset], index2, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address4 = FAILURE
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '\'':
                    address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address4 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('"\'"')
                if address4 is not FAILURE:
                    elements0.append(address4)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.string(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['string'][index0] = (address0, self._offset)
        return address0

    def _read_basic_name(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['basic_name'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        index2 = self._offset
        index3, elements1 = self._offset, []
        address2 = FAILURE
        address2 = self._read_keyword()
        if address2 is not FAILURE:
            elements1.append(address2)
            address3 = FAILURE
            index4 = self._offset
            address3 = self._read__()
            if address3 is FAILURE:
                self._offset = index4
                address3 = self._read_eos()
                if address3 is FAILURE:
                    self._offset = index4
            if address3 is not FAILURE:
                elements1.append(address3)
            else:
                elements1 = None
                self._offset = index3
        else:
            elements1 = None
            self._offset = index3
        if elements1 is None:
            address1 = FAILURE
        else:
            address1 = TreeNode7(self._input[index3:self._offset], index3, elements1)
            self._offset = self._offset
        self._offset = index2
        if address1 is FAILURE:
            address1 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address4 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 is not None and Grammar.REGEX_48.search(chunk0):
                address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address4 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('[a-zA-Z_]')
            if address4 is not FAILURE:
                elements0.append(address4)
                address5 = FAILURE
                remaining0, index5, elements2, address6 = 0, self._offset, [], True
                while address6 is not FAILURE:
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 is not None and Grammar.REGEX_49.search(chunk1):
                        address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address6 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('[a-zA-Z_0-9]')
                    if address6 is not FAILURE:
                        elements2.append(address6)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address5 = TreeNode(self._input[index5:self._offset], index5, elements2)
                    self._offset = self._offset
                else:
                    address5 = FAILURE
                if address5 is not FAILURE:
                    elements0.append(address5)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.reference(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['basic_name'][index0] = (address0, self._offset)
        return address0

    def _read_name(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['name'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '$':
            address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'$\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '?':
                address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'?\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '~':
                    address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'~\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '!':
                        address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                        self._offset = self._offset + 1
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'!\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '#':
                            address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'#\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '@':
                                address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'@\'')
                            if address0 is FAILURE:
                                self._offset = index1
                                address0 = self._read_basic_name()
                                if address0 is FAILURE:
                                    self._offset = index1
        self._cache['name'][index0] = (address0, self._offset)
        return address0

    def _read_special_entry(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['special_entry'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '^':
            address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'^\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '.':
                address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'.\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '=':
                    address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'=\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 5
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == 'clear':
                        address0 = self._actions.special_entry(self._input, self._offset, self._offset + 5, [])
                        self._offset = self._offset + 5
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'clear\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == ':':
                            address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\':\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '!':
                                address0 = self._actions.special_entry(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'!\'')
                            if address0 is FAILURE:
                                self._offset = index1
        self._cache['special_entry'][index0] = (address0, self._offset)
        return address0

    def _read_new_bag(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['new_bag'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '{:':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'{:\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index3, elements1, address4 = 0, self._offset, [], True
                while address4 is not FAILURE:
                    index4, elements2 = self._offset, []
                    address5 = FAILURE
                    address5 = self._read__()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read_statement()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            address7 = FAILURE
                            address7 = self._read__()
                            if address7 is not FAILURE:
                                elements2.append(address7)
                                address8 = FAILURE
                                index5 = self._offset
                                chunk1, max1 = None, self._offset + 2
                                if max1 <= self._input_size:
                                    chunk1 = self._input[self._offset:max1]
                                if chunk1 == ':}':
                                    address8 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                    self._offset = self._offset + 2
                                else:
                                    address8 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\':}\'')
                                self._offset = index5
                                if address8 is FAILURE:
                                    address8 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                    self._offset = self._offset
                                else:
                                    address8 = FAILURE
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                    if elements2 is None:
                        address4 = FAILURE
                    else:
                        address4 = TreeNode9(self._input[index4:self._offset], index4, elements2)
                        self._offset = self._offset
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index3:self._offset], index3, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address9 = FAILURE
                    address9 = self._read__()
                    if address9 is not FAILURE:
                        elements0.append(address9)
                        address10 = FAILURE
                        address10 = self._read_statement()
                        if address10 is not FAILURE:
                            elements0.append(address10)
                            address11 = FAILURE
                            address11 = self._read__ws()
                            if address11 is not FAILURE:
                                elements0.append(address11)
                                address12 = FAILURE
                                chunk2, max2 = None, self._offset + 2
                                if max2 <= self._input_size:
                                    chunk2 = self._input[self._offset:max2]
                                if chunk2 == ':}':
                                    address12 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                    self._offset = self._offset + 2
                                else:
                                    address12 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\':}\'')
                                if address12 is not FAILURE:
                                    address13 = FAILURE
                                    address13 = self._read__()
                                    if address13 is not FAILURE:
                                        elements0.append(address13)
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.new_bag(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index6, elements3 = self._offset, []
            address14 = FAILURE
            chunk3, max3 = None, self._offset + 1
            if max3 <= self._input_size:
                chunk3 = self._input[self._offset:max3]
            if chunk3 == '{':
                address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address14 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'{\'')
            if address14 is not FAILURE:
                address15 = FAILURE
                address15 = self._read__()
                if address15 is not FAILURE:
                    elements3.append(address15)
                    address16 = FAILURE
                    chunk4, max4 = None, self._offset + 1
                    if max4 <= self._input_size:
                        chunk4 = self._input[self._offset:max4]
                    if chunk4 == ':':
                        address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address16 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\':\'')
                    if address16 is not FAILURE:
                        address17 = FAILURE
                        address17 = self._read__()
                        if address17 is not FAILURE:
                            elements3.append(address17)
                            address18 = FAILURE
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '}':
                                address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address18 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address18 is not FAILURE:
                                address19 = FAILURE
                                address19 = self._read__()
                                if address19 is not FAILURE:
                                    elements3.append(address19)
                                else:
                                    elements3 = None
                                    self._offset = index6
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                else:
                    elements3 = None
                    self._offset = index6
            else:
                elements3 = None
                self._offset = index6
            if elements3 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.new_bag(self._input, index6, self._offset, elements3)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index7, elements4 = self._offset, []
                address20 = FAILURE
                chunk6, max6 = None, self._offset + 2
                if max6 <= self._input_size:
                    chunk6 = self._input[self._offset:max6]
                if chunk6 == '{:':
                    address20 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address20 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'{:\'')
                if address20 is not FAILURE:
                    address21 = FAILURE
                    address21 = self._read__ws()
                    if address21 is not FAILURE:
                        elements4.append(address21)
                        address22 = FAILURE
                        chunk7, max7 = None, self._offset + 2
                        if max7 <= self._input_size:
                            chunk7 = self._input[self._offset:max7]
                        if chunk7 == ':}':
                            address22 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                            self._offset = self._offset + 2
                        else:
                            address22 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\':}\'')
                        if address22 is not FAILURE:
                            address23 = FAILURE
                            address23 = self._read__()
                            if address23 is not FAILURE:
                                elements4.append(address23)
                            else:
                                elements4 = None
                                self._offset = index7
                        else:
                            elements4 = None
                            self._offset = index7
                    else:
                        elements4 = None
                        self._offset = index7
                else:
                    elements4 = None
                    self._offset = index7
                if elements4 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.new_bag(self._input, index7, self._offset, elements4)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['new_bag'][index0] = (address0, self._offset)
        return address0

    def _read_roll_item(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['roll_item'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_expression()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 3
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '<->':
                    address3 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                    self._offset = self._offset + 3
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<->\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_expression()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.fill(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_expression()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['roll_item'][index0] = (address0, self._offset)
        return address0

    def _read_roll_def(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['roll_def'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '[:':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'[:\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index3, elements1, address4 = 0, self._offset, [], True
                while address4 is not FAILURE:
                    index4, elements2 = self._offset, []
                    address5 = FAILURE
                    address5 = self._read_roll_item()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            address7 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == ',':
                                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\',\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__ws()
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                    if elements2 is None:
                        address4 = FAILURE
                    else:
                        address4 = TreeNode14(self._input[index4:self._offset], index4, elements2)
                        self._offset = self._offset
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index3:self._offset], index3, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address9 = FAILURE
                    index5 = self._offset
                    address9 = self._read_roll_item()
                    if address9 is FAILURE:
                        address9 = TreeNode(self._input[index5:index5], index5, [])
                        self._offset = index5
                    if address9 is not FAILURE:
                        elements0.append(address9)
                        address10 = FAILURE
                        address10 = self._read__ws()
                        if address10 is not FAILURE:
                            elements0.append(address10)
                            address11 = FAILURE
                            chunk2, max2 = None, self._offset + 2
                            if max2 <= self._input_size:
                                chunk2 = self._input[self._offset:max2]
                            if chunk2 == ':]':
                                address11 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                self._offset = self._offset + 2
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\':]\'')
                            if address11 is not FAILURE:
                                address12 = FAILURE
                                address12 = self._read__()
                                if address12 is not FAILURE:
                                    elements0.append(address12)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.roll_def(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index6, elements3 = self._offset, []
            address13 = FAILURE
            chunk3, max3 = None, self._offset + 1
            if max3 <= self._input_size:
                chunk3 = self._input[self._offset:max3]
            if chunk3 == '[':
                address13 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address13 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'[\'')
            if address13 is not FAILURE:
                elements3.append(address13)
                address14 = FAILURE
                address14 = self._read__()
                if address14 is not FAILURE:
                    elements3.append(address14)
                    address15 = FAILURE
                    chunk4, max4 = None, self._offset + 1
                    if max4 <= self._input_size:
                        chunk4 = self._input[self._offset:max4]
                    if chunk4 == ':':
                        address15 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address15 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\':\'')
                    if address15 is not FAILURE:
                        elements3.append(address15)
                        address16 = FAILURE
                        address16 = self._read__()
                        if address16 is not FAILURE:
                            elements3.append(address16)
                            address17 = FAILURE
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == ']':
                                address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address17 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\']\'')
                            if address17 is not FAILURE:
                                elements3.append(address17)
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                else:
                    elements3 = None
                    self._offset = index6
            else:
                elements3 = None
                self._offset = index6
            if elements3 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.empty_roll(self._input, index6, self._offset, elements3)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
        self._cache['roll_def'][index0] = (address0, self._offset)
        return address0

    def _read_reduce(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['reduce'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '{':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'{\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                index3 = self._offset
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == ':':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\':\'')
                if address3 is FAILURE:
                    self._offset = index3
                    address3 = self._read_special_accessor()
                    if address3 is FAILURE:
                        self._offset = index3
                self._offset = index2
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read_expression()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__ws()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            chunk2, max2 = None, self._offset + 1
                            if max2 <= self._input_size:
                                chunk2 = self._input[self._offset:max2]
                            if chunk2 == '}':
                                address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address6 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address6 is not FAILURE:
                                address7 = FAILURE
                                address7 = self._read__()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.reduce(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['reduce'][index0] = (address0, self._offset)
        return address0

    def _read_two_sided_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['two_sided_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '*':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'*\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '%/':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'%/\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '/':
                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'/\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '%':
                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                        self._offset = self._offset + 1
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'%\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '+':
                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'+\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            index2, elements0 = self._offset, []
                            address1 = FAILURE
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '-':
                                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address1 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'-\'')
                            if address1 is not FAILURE:
                                elements0.append(address1)
                                address2 = FAILURE
                                index3 = self._offset
                                chunk6, max6 = None, self._offset + 1
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 is not None and Grammar.REGEX_50.search(chunk6):
                                    address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address2 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('[a-z_A-Z]')
                                self._offset = index3
                                if address2 is FAILURE:
                                    address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                    self._offset = self._offset
                                else:
                                    address2 = FAILURE
                                if address2 is not FAILURE:
                                    elements0.append(address2)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                            if elements0 is None:
                                address0 = FAILURE
                            else:
                                address0 = self._actions.two_sided_operator(self._input, index2, self._offset, elements0)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
                                chunk7, max7 = None, self._offset + 2
                                if max7 <= self._input_size:
                                    chunk7 = self._input[self._offset:max7]
                                if chunk7 == 'or':
                                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                    self._offset = self._offset + 2
                                else:
                                    address0 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'or\'')
                                if address0 is FAILURE:
                                    self._offset = index1
                                    chunk8, max8 = None, self._offset + 3
                                    if max8 <= self._input_size:
                                        chunk8 = self._input[self._offset:max8]
                                    if chunk8 == 'and':
                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 3, [])
                                        self._offset = self._offset + 3
                                    else:
                                        address0 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'and\'')
                                    if address0 is FAILURE:
                                        self._offset = index1
                                        chunk9, max9 = None, self._offset + 3
                                        if max9 <= self._input_size:
                                            chunk9 = self._input[self._offset:max9]
                                        if chunk9 == 'isa':
                                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 3, [])
                                            self._offset = self._offset + 3
                                        else:
                                            address0 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'isa\'')
                                        if address0 is FAILURE:
                                            self._offset = index1
                                            chunk10, max10 = None, self._offset + 1
                                            if max10 <= self._input_size:
                                                chunk10 = self._input[self._offset:max10]
                                            if chunk10 == '@':
                                                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                self._offset = self._offset + 1
                                            else:
                                                address0 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('\'@\'')
                                            if address0 is FAILURE:
                                                self._offset = index1
                                                chunk11, max11 = None, self._offset + 2
                                                if max11 <= self._input_size:
                                                    chunk11 = self._input[self._offset:max11]
                                                if chunk11 == '==':
                                                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                    self._offset = self._offset + 2
                                                else:
                                                    address0 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('\'==\'')
                                                if address0 is FAILURE:
                                                    self._offset = index1
                                                    chunk12, max12 = None, self._offset + 2
                                                    if max12 <= self._input_size:
                                                        chunk12 = self._input[self._offset:max12]
                                                    if chunk12 == '!=':
                                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                        self._offset = self._offset + 2
                                                    else:
                                                        address0 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('\'!=\'')
                                                    if address0 is FAILURE:
                                                        self._offset = index1
                                                        chunk13, max13 = None, self._offset + 2
                                                        if max13 <= self._input_size:
                                                            chunk13 = self._input[self._offset:max13]
                                                        if chunk13 == '<=':
                                                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                            self._offset = self._offset + 2
                                                        else:
                                                            address0 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('\'<=\'')
                                                        if address0 is FAILURE:
                                                            self._offset = index1
                                                            chunk14, max14 = None, self._offset + 2
                                                            if max14 <= self._input_size:
                                                                chunk14 = self._input[self._offset:max14]
                                                            if chunk14 == '>=':
                                                                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                                                                self._offset = self._offset + 2
                                                            else:
                                                                address0 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'>=\'')
                                                            if address0 is FAILURE:
                                                                self._offset = index1
                                                                chunk15, max15 = None, self._offset + 1
                                                                if max15 <= self._input_size:
                                                                    chunk15 = self._input[self._offset:max15]
                                                                if chunk15 == '<':
                                                                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                                    self._offset = self._offset + 1
                                                                else:
                                                                    address0 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('\'<\'')
                                                                if address0 is FAILURE:
                                                                    self._offset = index1
                                                                    chunk16, max16 = None, self._offset + 1
                                                                    if max16 <= self._input_size:
                                                                        chunk16 = self._input[self._offset:max16]
                                                                    if chunk16 == '>':
                                                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                                        self._offset = self._offset + 1
                                                                    else:
                                                                        address0 = FAILURE
                                                                        if self._offset > self._failure:
                                                                            self._failure = self._offset
                                                                            self._expected = []
                                                                        if self._offset == self._failure:
                                                                            self._expected.append('\'>\'')
                                                                    if address0 is FAILURE:
                                                                        self._offset = index1
                                                                        chunk17, max17 = None, self._offset + 1
                                                                        if max17 <= self._input_size:
                                                                            chunk17 = self._input[self._offset:max17]
                                                                        if chunk17 == '&':
                                                                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                                                            self._offset = self._offset + 1
                                                                        else:
                                                                            address0 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('\'&\'')
                                                                        if address0 is FAILURE:
                                                                            self._offset = index1
        self._cache['two_sided_op'][index0] = (address0, self._offset)
        return address0

    def _read_one_sided_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['one_sided_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'has':
            address0 = self._actions.one_sided_operator(self._input, self._offset, self._offset + 3, [])
            self._offset = self._offset + 3
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'has\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '#':
                address0 = self._actions.overload_only_operator(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'#\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '0':
                    address0 = self._actions.overload_only_operator(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'0\'')
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '{':
                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'{\'')
                    if address1 is not FAILURE:
                        elements0.append(address1)
                        address2 = FAILURE
                        address2 = self._read__()
                        if address2 is not FAILURE:
                            elements0.append(address2)
                            address3 = FAILURE
                            chunk4, max4 = None, self._offset + 1
                            if max4 <= self._input_size:
                                chunk4 = self._input[self._offset:max4]
                            if chunk4 == '}':
                                address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address3 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address3 is not FAILURE:
                                elements0.append(address3)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.overload_only_operator(self._input, index2, self._offset, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index3, elements1 = self._offset, []
                        address4 = FAILURE
                        chunk5, max5 = None, self._offset + 3
                        if max5 <= self._input_size:
                            chunk5 = self._input[self._offset:max5]
                        if chunk5 == 'for':
                            address4 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                            self._offset = self._offset + 3
                        else:
                            address4 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'for\'')
                        if address4 is not FAILURE:
                            elements1.append(address4)
                            address5 = FAILURE
                            address5 = self._read__()
                            if address5 is not FAILURE:
                                elements1.append(address5)
                                address6 = FAILURE
                                chunk6, max6 = None, self._offset + 5
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 == 'every':
                                    address6 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                    self._offset = self._offset + 5
                                else:
                                    address6 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'every\'')
                                if address6 is not FAILURE:
                                    elements1.append(address6)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                        if elements1 is None:
                            address0 = FAILURE
                        else:
                            address0 = self._actions.overload_only_operator(self._input, index3, self._offset, elements1)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk7, max7 = None, self._offset + 1
                            if max7 <= self._input_size:
                                chunk7 = self._input[self._offset:max7]
                            if chunk7 == '?':
                                address0 = self._actions.overload_only_operator(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'?\'')
                            if address0 is FAILURE:
                                self._offset = index1
        self._cache['one_sided_op'][index0] = (address0, self._offset)
        return address0

    def _read_overload_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['overload_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '<[':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'<[\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_two_sided_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        chunk1, max1 = None, self._offset + 1
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == ']':
                            address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\']\'')
                        if address5 is not FAILURE:
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.left_op_overload(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address7 = FAILURE
            chunk2, max2 = None, self._offset + 1
            if max2 <= self._input_size:
                chunk2 = self._input[self._offset:max2]
            if chunk2 == '[':
                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address7 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'[\'')
            if address7 is not FAILURE:
                address8 = FAILURE
                address8 = self._read__()
                if address8 is not FAILURE:
                    elements1.append(address8)
                    address9 = FAILURE
                    address9 = self._read_two_sided_op()
                    if address9 is not FAILURE:
                        elements1.append(address9)
                        address10 = FAILURE
                        address10 = self._read__()
                        if address10 is not FAILURE:
                            elements1.append(address10)
                            address11 = FAILURE
                            chunk3, max3 = None, self._offset + 2
                            if max3 <= self._input_size:
                                chunk3 = self._input[self._offset:max3]
                            if chunk3 == ']>':
                                address11 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                self._offset = self._offset + 2
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\']>\'')
                            if address11 is not FAILURE:
                                address12 = FAILURE
                                address12 = self._read__()
                                if address12 is not FAILURE:
                                    elements1.append(address12)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.right_op_overload(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index4, elements2 = self._offset, []
                address13 = FAILURE
                chunk4, max4 = None, self._offset + 1
                if max4 <= self._input_size:
                    chunk4 = self._input[self._offset:max4]
                if chunk4 == '[':
                    address13 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address13 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'[\'')
                if address13 is not FAILURE:
                    address14 = FAILURE
                    address14 = self._read__()
                    if address14 is not FAILURE:
                        elements2.append(address14)
                        address15 = FAILURE
                        address15 = self._read_one_sided_op()
                        if address15 is not FAILURE:
                            elements2.append(address15)
                            address16 = FAILURE
                            address16 = self._read__()
                            if address16 is not FAILURE:
                                elements2.append(address16)
                                address17 = FAILURE
                                chunk5, max5 = None, self._offset + 1
                                if max5 <= self._input_size:
                                    chunk5 = self._input[self._offset:max5]
                                if chunk5 == ']':
                                    address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address17 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\']\'')
                                if address17 is not FAILURE:
                                    address18 = FAILURE
                                    address18 = self._read__()
                                    if address18 is not FAILURE:
                                        elements2.append(address18)
                                    else:
                                        elements2 = None
                                        self._offset = index4
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.one_sided_op_overload(self._input, index4, self._offset, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['overload_op'][index0] = (address0, self._offset)
        return address0

    def _read_special_accessor(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['special_accessor'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '#':
            address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'#\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '*':
                address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'*\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '+':
                    address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'+\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '=':
                        address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                        self._offset = self._offset + 1
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '^':
                            address0 = self._actions.special_accessor(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'^\'')
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['special_accessor'][index0] = (address0, self._offset)
        return address0

    def _read_accessor(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['accessor'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_basic_name()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode22(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address3 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '{':
                address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address3 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'{\'')
            if address3 is not FAILURE:
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements1.append(address4)
                    address5 = FAILURE
                    address5 = self._read_special_accessor()
                    if address5 is not FAILURE:
                        elements1.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements1.append(address6)
                            address7 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == '}':
                                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'}\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__()
                                if address8 is not FAILURE:
                                    elements1.append(address8)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode23(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index4, elements2 = self._offset, []
                address9 = FAILURE
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '<':
                    address9 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address9 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<\'')
                if address9 is not FAILURE:
                    address10 = FAILURE
                    index5 = self._offset
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '[':
                        address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address10 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'[\'')
                    self._offset = index5
                    if address10 is FAILURE:
                        address10 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address10 = FAILURE
                    if address10 is not FAILURE:
                        elements2.append(address10)
                        address11 = FAILURE
                        address11 = self._read__()
                        if address11 is not FAILURE:
                            elements2.append(address11)
                            address12 = FAILURE
                            address12 = self._read_special_entry()
                            if address12 is not FAILURE:
                                elements2.append(address12)
                                address13 = FAILURE
                                address13 = self._read__()
                                if address13 is not FAILURE:
                                    elements2.append(address13)
                                    address14 = FAILURE
                                    chunk4, max4 = None, self._offset + 1
                                    if max4 <= self._input_size:
                                        chunk4 = self._input[self._offset:max4]
                                    if chunk4 == '>':
                                        address14 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address14 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'>\'')
                                    if address14 is not FAILURE:
                                        address15 = FAILURE
                                        address15 = self._read__()
                                        if address15 is not FAILURE:
                                            elements2.append(address15)
                                        else:
                                            elements2 = None
                                            self._offset = index4
                                    else:
                                        elements2 = None
                                        self._offset = index4
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = TreeNode24(self._input[index4:self._offset], index4, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index6, elements3 = self._offset, []
                    address16 = FAILURE
                    chunk5, max5 = None, self._offset + 1
                    if max5 <= self._input_size:
                        chunk5 = self._input[self._offset:max5]
                    if chunk5 == '<':
                        address16 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address16 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'<\'')
                    if address16 is not FAILURE:
                        address17 = FAILURE
                        index7 = self._offset
                        chunk6, max6 = None, self._offset + 1
                        if max6 <= self._input_size:
                            chunk6 = self._input[self._offset:max6]
                        if chunk6 == '[':
                            address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address17 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'[\'')
                        self._offset = index7
                        if address17 is FAILURE:
                            address17 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address17 = FAILURE
                        if address17 is not FAILURE:
                            elements3.append(address17)
                            address18 = FAILURE
                            address18 = self._read__()
                            if address18 is not FAILURE:
                                elements3.append(address18)
                                address19 = FAILURE
                                address19 = self._read_expression()
                                if address19 is not FAILURE:
                                    elements3.append(address19)
                                    address20 = FAILURE
                                    address20 = self._read__()
                                    if address20 is not FAILURE:
                                        elements3.append(address20)
                                        address21 = FAILURE
                                        chunk7, max7 = None, self._offset + 1
                                        if max7 <= self._input_size:
                                            chunk7 = self._input[self._offset:max7]
                                        if chunk7 == '>':
                                            address21 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address21 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'>\'')
                                        if address21 is not FAILURE:
                                            address22 = FAILURE
                                            address22 = self._read__()
                                            if address22 is not FAILURE:
                                                elements3.append(address22)
                                            else:
                                                elements3 = None
                                                self._offset = index6
                                        else:
                                            elements3 = None
                                            self._offset = index6
                                    else:
                                        elements3 = None
                                        self._offset = index6
                                else:
                                    elements3 = None
                                    self._offset = index6
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                    if elements3 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.raw_accessor(self._input, index6, self._offset, elements3)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        address0 = self._read_overload_op()
                        if address0 is FAILURE:
                            self._offset = index1
                            index8, elements4 = self._offset, []
                            address23 = FAILURE
                            address23 = self._read_reduce()
                            if address23 is not FAILURE:
                                elements4.append(address23)
                                address24 = FAILURE
                                address24 = self._read__()
                                if address24 is not FAILURE:
                                    elements4.append(address24)
                                else:
                                    elements4 = None
                                    self._offset = index8
                            else:
                                elements4 = None
                                self._offset = index8
                            if elements4 is None:
                                address0 = FAILURE
                            else:
                                address0 = TreeNode26(self._input[index8:self._offset], index8, elements4)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
        self._cache['accessor'][index0] = (address0, self._offset)
        return address0

    def _read_accessing(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['accessing'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_reduce_expr()
        if address0 is FAILURE:
            self._offset = index1
            index2, elements0 = self._offset, []
            address1 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '<':
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'<\'')
            if address1 is not FAILURE:
                address2 = FAILURE
                index3 = self._offset
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == '[':
                    address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address2 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'[\'')
                self._offset = index3
                if address2 is FAILURE:
                    address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address2 = FAILURE
                if address2 is not FAILURE:
                    elements0.append(address2)
                    address3 = FAILURE
                    address3 = self._read__()
                    if address3 is not FAILURE:
                        elements0.append(address3)
                        address4 = FAILURE
                        address4 = self._read_special_entry()
                        if address4 is not FAILURE:
                            elements0.append(address4)
                            address5 = FAILURE
                            address5 = self._read__()
                            if address5 is not FAILURE:
                                elements0.append(address5)
                                address6 = FAILURE
                                chunk2, max2 = None, self._offset + 1
                                if max2 <= self._input_size:
                                    chunk2 = self._input[self._offset:max2]
                                if chunk2 == '>':
                                    address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address6 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'>\'')
                                if address6 is not FAILURE:
                                    address7 = FAILURE
                                    address7 = self._read__()
                                    if address7 is not FAILURE:
                                        elements0.append(address7)
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
            if elements0 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode27(self._input[index2:self._offset], index2, elements0)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_overload_op()
                if address0 is FAILURE:
                    self._offset = index1
                    address0 = self._read_name()
                    if address0 is FAILURE:
                        self._offset = index1
        self._cache['accessing'][index0] = (address0, self._offset)
        return address0

    def _read_access(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['access'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_accessing()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 1, self._offset, [], True
            while address3 is not FAILURE:
                index4, elements2 = self._offset, []
                address4 = FAILURE
                address4 = self._read__ws()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '.':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'.\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read_accessor()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index4
                    else:
                        elements2 = None
                        self._offset = index4
                else:
                    elements2 = None
                    self._offset = index4
                if elements2 is None:
                    address3 = FAILURE
                else:
                    address3 = TreeNode29(self._input[index4:self._offset], index4, elements2)
                    self._offset = self._offset
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.access(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index5, elements3 = self._offset, []
            address7 = FAILURE
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '<':
                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address7 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'<\'')
            if address7 is not FAILURE:
                address8 = FAILURE
                index6 = self._offset
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '[':
                    address8 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address8 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'[\'')
                self._offset = index6
                if address8 is FAILURE:
                    address8 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address8 = FAILURE
                if address8 is not FAILURE:
                    elements3.append(address8)
                    address9 = FAILURE
                    address9 = self._read__()
                    if address9 is not FAILURE:
                        elements3.append(address9)
                        address10 = FAILURE
                        address10 = self._read_special_entry()
                        if address10 is not FAILURE:
                            elements3.append(address10)
                            address11 = FAILURE
                            address11 = self._read__()
                            if address11 is not FAILURE:
                                elements3.append(address11)
                                address12 = FAILURE
                                chunk3, max3 = None, self._offset + 1
                                if max3 <= self._input_size:
                                    chunk3 = self._input[self._offset:max3]
                                if chunk3 == '>':
                                    address12 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address12 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'>\'')
                                if address12 is not FAILURE:
                                    address13 = FAILURE
                                    address13 = self._read__()
                                    if address13 is not FAILURE:
                                        elements3.append(address13)
                                    else:
                                        elements3 = None
                                        self._offset = index5
                                else:
                                    elements3 = None
                                    self._offset = index5
                            else:
                                elements3 = None
                                self._offset = index5
                        else:
                            elements3 = None
                            self._offset = index5
                    else:
                        elements3 = None
                        self._offset = index5
                else:
                    elements3 = None
                    self._offset = index5
            else:
                elements3 = None
                self._offset = index5
            if elements3 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode30(self._input[index5:self._offset], index5, elements3)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_name()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['access'][index0] = (address0, self._offset)
        return address0

    def _read_mult_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['mult_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '*':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'*\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '%/':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'%/\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '/':
                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'/\'')
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk3, max3 = None, self._offset + 1
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '%':
                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'%\'')
                    if address1 is not FAILURE:
                        elements0.append(address1)
                        address2 = FAILURE
                        index3 = self._offset
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '>':
                            address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address2 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'>\'')
                        self._offset = index3
                        if address2 is FAILURE:
                            address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address2 = FAILURE
                        if address2 is not FAILURE:
                            elements0.append(address2)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.two_sided_operator(self._input, index2, self._offset, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
        self._cache['mult_op'][index0] = (address0, self._offset)
        return address0

    def _read_add_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['add_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '+':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
            self._offset = self._offset + 1
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'+\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 1
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '-':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                self._offset = self._offset + 1
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'-\'')
            if address0 is FAILURE:
                self._offset = index1
        self._cache['add_op'][index0] = (address0, self._offset)
        return address0

    def _read_anor_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['anor_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'or':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
            self._offset = self._offset + 2
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'or\'')
        if address0 is FAILURE:
            self._offset = index1
            index2, elements0 = self._offset, []
            address1 = FAILURE
            chunk1, max1 = None, self._offset + 3
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'and':
                address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                self._offset = self._offset + 3
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'and\'')
            if address1 is not FAILURE:
                elements0.append(address1)
                address2 = FAILURE
                index3 = self._offset
                index4, elements1 = self._offset, []
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements1.append(address3)
                    address4 = FAILURE
                    chunk2, max2 = None, self._offset + 6
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == 'always':
                        address4 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                        self._offset = self._offset + 6
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'always\'')
                    if address4 is not FAILURE:
                        elements1.append(address4)
                    else:
                        elements1 = None
                        self._offset = index4
                else:
                    elements1 = None
                    self._offset = index4
                if elements1 is None:
                    address2 = FAILURE
                else:
                    address2 = TreeNode31(self._input[index4:self._offset], index4, elements1)
                    self._offset = self._offset
                self._offset = index3
                if address2 is FAILURE:
                    address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address2 = FAILURE
                if address2 is not FAILURE:
                    elements0.append(address2)
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
            if elements0 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.two_sided_operator(self._input, index2, self._offset, elements0)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
        self._cache['anor_op'][index0] = (address0, self._offset)
        return address0

    def _read_comp_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['comp_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '==':
            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
            self._offset = self._offset + 2
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'==\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '!=':
                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'!=\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 2
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '<=':
                    address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                    self._offset = self._offset + 2
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<=\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 2
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '>=':
                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 2, [])
                        self._offset = self._offset + 2
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>=\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 1
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '<':
                            address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                            self._offset = self._offset + 1
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'<\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 1
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '>':
                                address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 1, [])
                                self._offset = self._offset + 1
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'>\'')
                            if address0 is FAILURE:
                                self._offset = index1
                                index2, elements0 = self._offset, []
                                address1 = FAILURE
                                chunk6, max6 = None, self._offset + 3
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 == 'has':
                                    address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                    self._offset = self._offset + 3
                                else:
                                    address1 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'has\'')
                                if address1 is not FAILURE:
                                    elements0.append(address1)
                                    address2 = FAILURE
                                    index3 = self._offset
                                    index4, elements1 = self._offset, []
                                    address3 = FAILURE
                                    address3 = self._read__()
                                    if address3 is not FAILURE:
                                        elements1.append(address3)
                                        address4 = FAILURE
                                        chunk7, max7 = None, self._offset + 2
                                        if max7 <= self._input_size:
                                            chunk7 = self._input[self._offset:max7]
                                        if chunk7 == 'do':
                                            address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                            self._offset = self._offset + 2
                                        else:
                                            address4 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'do\'')
                                        if address4 is not FAILURE:
                                            elements1.append(address4)
                                        else:
                                            elements1 = None
                                            self._offset = index4
                                    else:
                                        elements1 = None
                                        self._offset = index4
                                    if elements1 is None:
                                        address2 = FAILURE
                                    else:
                                        address2 = TreeNode32(self._input[index4:self._offset], index4, elements1)
                                        self._offset = self._offset
                                    self._offset = index3
                                    if address2 is FAILURE:
                                        address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                        self._offset = self._offset
                                    else:
                                        address2 = FAILURE
                                    if address2 is not FAILURE:
                                        elements0.append(address2)
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                                if elements0 is None:
                                    address0 = FAILURE
                                else:
                                    address0 = self._actions.one_sided_operator(self._input, index2, self._offset, elements0)
                                    self._offset = self._offset
                                if address0 is FAILURE:
                                    self._offset = index1
                                    chunk8, max8 = None, self._offset + 3
                                    if max8 <= self._input_size:
                                        chunk8 = self._input[self._offset:max8]
                                    if chunk8 == 'isa':
                                        address0 = self._actions.two_sided_operator(self._input, self._offset, self._offset + 3, [])
                                        self._offset = self._offset + 3
                                    else:
                                        address0 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'isa\'')
                                    if address0 is FAILURE:
                                        self._offset = index1
        self._cache['comp_op'][index0] = (address0, self._offset)
        return address0

    def _read_assign_op(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['assign_op'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '+=':
            address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
            self._offset = self._offset + 2
        else:
            address0 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'+=\'')
        if address0 is FAILURE:
            self._offset = index1
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == '-=':
                address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                self._offset = self._offset + 2
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'-=\'')
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 2
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '*=':
                    address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                    self._offset = self._offset + 2
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'*=\'')
                if address0 is FAILURE:
                    self._offset = index1
                    chunk3, max3 = None, self._offset + 2
                    if max3 <= self._input_size:
                        chunk3 = self._input[self._offset:max3]
                    if chunk3 == '/=':
                        address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                        self._offset = self._offset + 2
                    else:
                        address0 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'/=\'')
                    if address0 is FAILURE:
                        self._offset = index1
                        chunk4, max4 = None, self._offset + 2
                        if max4 <= self._input_size:
                            chunk4 = self._input[self._offset:max4]
                        if chunk4 == '%=':
                            address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                            self._offset = self._offset + 2
                        else:
                            address0 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'%=\'')
                        if address0 is FAILURE:
                            self._offset = index1
                            chunk5, max5 = None, self._offset + 3
                            if max5 <= self._input_size:
                                chunk5 = self._input[self._offset:max5]
                            if chunk5 == '%/=':
                                address0 = self._actions.text(self._input, self._offset, self._offset + 3, [])
                                self._offset = self._offset + 3
                            else:
                                address0 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'%/=\'')
                            if address0 is FAILURE:
                                self._offset = index1
                                chunk6, max6 = None, self._offset + 2
                                if max6 <= self._input_size:
                                    chunk6 = self._input[self._offset:max6]
                                if chunk6 == '&=':
                                    address0 = self._actions.text(self._input, self._offset, self._offset + 2, [])
                                    self._offset = self._offset + 2
                                else:
                                    address0 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'&=\'')
                                if address0 is FAILURE:
                                    self._offset = index1
                                    index2, elements0 = self._offset, []
                                    address1 = FAILURE
                                    chunk7, max7 = None, self._offset + 1
                                    if max7 <= self._input_size:
                                        chunk7 = self._input[self._offset:max7]
                                    if chunk7 == '=':
                                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address1 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'=\'')
                                    if address1 is not FAILURE:
                                        elements0.append(address1)
                                        address2 = FAILURE
                                        index3 = self._offset
                                        chunk8, max8 = None, self._offset + 1
                                        if max8 <= self._input_size:
                                            chunk8 = self._input[self._offset:max8]
                                        if chunk8 == '>':
                                            address2 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address2 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'>\'')
                                        self._offset = index3
                                        if address2 is FAILURE:
                                            address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                            self._offset = self._offset
                                        else:
                                            address2 = FAILURE
                                        if address2 is not FAILURE:
                                            elements0.append(address2)
                                        else:
                                            elements0 = None
                                            self._offset = index2
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                    if elements0 is None:
                                        address0 = FAILURE
                                    else:
                                        address0 = self._actions.text(self._input, index2, self._offset, elements0)
                                        self._offset = self._offset
                                    if address0 is FAILURE:
                                        self._offset = index1
        self._cache['assign_op'][index0] = (address0, self._offset)
        return address0

    def _read_expression(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['expression'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        address0 = self._read_use_if()
        self._cache['expression'][index0] = (address0, self._offset)
        return address0

    def _read_use_if(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['use_if'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'use':
            address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
            self._offset = self._offset + 3
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'use\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_expression()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        chunk1, max1 = None, self._offset + 2
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == 'if':
                            address5 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                            self._offset = self._offset + 2
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'if\'')
                        if address5 is not FAILURE:
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_anor()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                    address8 = FAILURE
                                    address8 = self._read__()
                                    if address8 is not FAILURE:
                                        elements0.append(address8)
                                        address9 = FAILURE
                                        chunk2, max2 = None, self._offset + 9
                                        if max2 <= self._input_size:
                                            chunk2 = self._input[self._offset:max2]
                                        if chunk2 == 'otherwise':
                                            address9 = TreeNode(self._input[self._offset:self._offset + 9], self._offset, [])
                                            self._offset = self._offset + 9
                                        else:
                                            address9 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'otherwise\'')
                                        if address9 is not FAILURE:
                                            address10 = FAILURE
                                            address10 = self._read__()
                                            if address10 is not FAILURE:
                                                elements0.append(address10)
                                                address11 = FAILURE
                                                address11 = self._read_expression()
                                                if address11 is not FAILURE:
                                                    elements0.append(address11)
                                                else:
                                                    elements0 = None
                                                    self._offset = index2
                                            else:
                                                elements0 = None
                                                self._offset = index2
                                        else:
                                            elements0 = None
                                            self._offset = index2
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.use_if(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address12 = FAILURE
            chunk3, max3 = None, self._offset + 3
            if max3 <= self._input_size:
                chunk3 = self._input[self._offset:max3]
            if chunk3 == 'not':
                address12 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                self._offset = self._offset + 3
            else:
                address12 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'not\'')
            if address12 is not FAILURE:
                address13 = FAILURE
                address13 = self._read__()
                if address13 is not FAILURE:
                    elements1.append(address13)
                    address14 = FAILURE
                    address14 = self._read_anor()
                    if address14 is not FAILURE:
                        elements1.append(address14)
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.negate(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_anor()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['use_if'][index0] = (address0, self._offset)
        return address0

    def _read_anor(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['anor'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_comparison()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_anor_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_anor()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_comparison()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['anor'][index0] = (address0, self._offset)
        return address0

    def _read_comparison(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['comparison'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_roll_math()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_comp_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_comparison()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_roll_math()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['comparison'][index0] = (address0, self._offset)
        return address0

    def _read_roll_math(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['roll_math'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_add_math()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '&':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'&\'')
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    index3 = self._offset
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == '=':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    self._offset = index3
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_roll_math()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_add_math()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['roll_math'][index0] = (address0, self._offset)
        return address0

    def _read_add_math(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['add_math'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_mult_math()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_add_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    index3 = self._offset
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '=':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    self._offset = index3
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_add_math()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_mult_math()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['add_math'][index0] = (address0, self._offset)
        return address0

    def _read_mult_math(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['mult_math'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_lambda_expr()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_mult_op()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    index3 = self._offset
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '=':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'=\'')
                    self._offset = index3
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_mult_math()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.binary_op(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_lambda_expr()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['mult_math'][index0] = (address0, self._offset)
        return address0

    def _read_lambda_expr(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['lambda_expr'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_lambda_def()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_modify()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['lambda_expr'][index0] = (address0, self._offset)
        return address0

    def _read_modify(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modify'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_first_modifier_call()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            remaining0, index3, elements1, address3 = 0, self._offset, [], True
            while address3 is not FAILURE:
                address3 = self._read_modifier_call()
                if address3 is not FAILURE:
                    elements1.append(address3)
                    remaining0 -= 1
            if remaining0 <= 0:
                address2 = TreeNode(self._input[index3:self._offset], index3, elements1)
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modify(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_dice()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['modify'][index0] = (address0, self._offset)
        return address0

    def _read_dice(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['dice'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        index3 = self._offset
        index4 = self._offset
        address1 = self._read_name()
        if address1 is FAILURE:
            self._offset = index4
            address1 = self._read_string()
            if address1 is FAILURE:
                self._offset = index4
        self._offset = index3
        if address1 is FAILURE:
            address1 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read_reduce_expr()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 is not None and chunk0.lower() == 'd'.lower():
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('`d`')
                    if address4 is not FAILURE:
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index5 = self._offset
                            index6 = self._offset
                            address6 = self._read_name()
                            if address6 is FAILURE:
                                self._offset = index6
                                address6 = self._read_string()
                                if address6 is FAILURE:
                                    self._offset = index6
                            self._offset = index5
                            if address6 is FAILURE:
                                address6 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                self._offset = self._offset
                            else:
                                address6 = FAILURE
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_reduce_expr()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.dice(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_access()
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_reduce_expr()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['dice'][index0] = (address0, self._offset)
        return address0

    def _read_reduce_expr(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['reduce_expr'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_roll_def()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_new_bag()
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_reduce()
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == '(':
                        address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'(\'')
                    if address1 is not FAILURE:
                        address2 = FAILURE
                        address2 = self._read__ws()
                        if address2 is not FAILURE:
                            elements0.append(address2)
                            address3 = FAILURE
                            address3 = self._read_expression()
                            if address3 is not FAILURE:
                                elements0.append(address3)
                                address4 = FAILURE
                                address4 = self._read__ws()
                                if address4 is not FAILURE:
                                    elements0.append(address4)
                                    address5 = FAILURE
                                    chunk1, max1 = None, self._offset + 1
                                    if max1 <= self._input_size:
                                        chunk1 = self._input[self._offset:max1]
                                    if chunk1 == ')':
                                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address5 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\')\'')
                                    if address5 is not FAILURE:
                                        address6 = FAILURE
                                        address6 = self._read__()
                                        if address6 is not FAILURE:
                                            elements0.append(address6)
                                        else:
                                            elements0 = None
                                            self._offset = index2
                                    else:
                                        elements0 = None
                                        self._offset = index2
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = TreeNode42(self._input[index2:self._offset], index2, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        address0 = self._read_atom()
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['reduce_expr'][index0] = (address0, self._offset)
        return address0

    def _read_atom(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['atom'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_number()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_name()
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_string()
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['atom'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_tail(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_tail'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_access()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                address3 = self._read_modifier_args()
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[index2:index2], index2, [])
                    self._offset = index2
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modifier_call(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_tail'][index0] = (address0, self._offset)
        return address0

    def _read_first_modifier_call(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['first_modifier_call'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_dice()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '-':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'-\'')
                if address3 is FAILURE:
                    self._offset = index2
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == ':':
                        address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address3 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\':\'')
                    if address3 is FAILURE:
                        self._offset = index2
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    chunk2, max2 = None, self._offset + 1
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == '>':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>\'')
                    if address4 is not FAILURE:
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read_modifier_tail()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.first_modifier_call(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['first_modifier_call'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_call(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_call'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read__ws()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            chunk0, max0 = None, self._offset + 2
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '->':
                address2 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                self._offset = self._offset + 2
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'->\'')
            if address2 is not FAILURE:
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read_modifier_tail()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode45(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['modifier_call'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_args(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_args'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '(':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'(\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                remaining0, index2, elements1, address4 = 0, self._offset, [], True
                while address4 is not FAILURE:
                    index3, elements2 = self._offset, []
                    address5 = FAILURE
                    address5 = self._read_expression()
                    if address5 is not FAILURE:
                        elements2.append(address5)
                        address6 = FAILURE
                        address6 = self._read__()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                            address7 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == ',':
                                address7 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\',\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__ws()
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                else:
                                    elements2 = None
                                    self._offset = index3
                            else:
                                elements2 = None
                                self._offset = index3
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                    if elements2 is None:
                        address4 = FAILURE
                    else:
                        address4 = TreeNode47(self._input[index3:self._offset], index3, elements2)
                        self._offset = self._offset
                    if address4 is not FAILURE:
                        elements1.append(address4)
                        remaining0 -= 1
                if remaining0 <= 0:
                    address3 = TreeNode(self._input[index2:self._offset], index2, elements1)
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address9 = FAILURE
                    index4 = self._offset
                    address9 = self._read_expression()
                    if address9 is FAILURE:
                        address9 = TreeNode(self._input[index4:index4], index4, [])
                        self._offset = index4
                    if address9 is not FAILURE:
                        elements0.append(address9)
                        address10 = FAILURE
                        address10 = self._read__()
                        if address10 is not FAILURE:
                            elements0.append(address10)
                            address11 = FAILURE
                            chunk2, max2 = None, self._offset + 1
                            if max2 <= self._input_size:
                                chunk2 = self._input[self._offset:max2]
                            if chunk2 == ')':
                                address11 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address11 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\')\'')
                            if address11 is not FAILURE:
                                address12 = FAILURE
                                address12 = self._read__()
                                if address12 is not FAILURE:
                                    elements0.append(address12)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.arg_list(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_args'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_params(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_params'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_basic_name()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ',':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\',\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read__ws()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode48(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address7 = FAILURE
            index4 = self._offset
            address7 = self._read_basic_name()
            if address7 is FAILURE:
                address7 = TreeNode(self._input[index4:index4], index4, [])
                self._offset = index4
            if address7 is not FAILURE:
                elements0.append(address7)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.param_list(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_params'][index0] = (address0, self._offset)
        return address0

    def _read_small_modifier_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['small_modifier_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_modifier_params()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == ':':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\':\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        index2 = self._offset
                        chunk1, max1 = None, self._offset + 1
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == '[':
                            address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'[\'')
                        self._offset = index2
                        if address5 is FAILURE:
                            address5 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                            self._offset = self._offset
                        else:
                            address5 = FAILURE
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_expression()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.small_modifier_body(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['small_modifier_body'][index0] = (address0, self._offset)
        return address0

    def _read_normal_modifier_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['normal_modifier_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_modifier_params()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index2 = self._offset
                chunk0, max0 = None, self._offset + 1
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == ':':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\':\'')
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[index2:index2], index2, [])
                    self._offset = index2
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__ws()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        chunk1, max1 = None, self._offset + 1
                        if max1 <= self._input_size:
                            chunk1 = self._input[self._offset:max1]
                        if chunk1 == '[':
                            address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                            self._offset = self._offset + 1
                        else:
                            address5 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'[\'')
                        if address5 is not FAILURE:
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                index3 = self._offset
                                address7 = self._read_block_body()
                                if address7 is FAILURE:
                                    address7 = TreeNode(self._input[index3:index3], index3, [])
                                    self._offset = index3
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                    address8 = FAILURE
                                    address8 = self._read__()
                                    if address8 is not FAILURE:
                                        elements0.append(address8)
                                        address9 = FAILURE
                                        chunk2, max2 = None, self._offset + 1
                                        if max2 <= self._input_size:
                                            chunk2 = self._input[self._offset:max2]
                                        if chunk2 == ']':
                                            address9 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address9 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\']\'')
                                        if address9 is not FAILURE:
                                            address10 = FAILURE
                                            address10 = self._read__()
                                            if address10 is not FAILURE:
                                                elements0.append(address10)
                                            else:
                                                elements0 = None
                                                self._offset = index1
                                        else:
                                            elements0 = None
                                            self._offset = index1
                                    else:
                                        elements0 = None
                                        self._offset = index1
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.normal_modifier_body(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['normal_modifier_body'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_def_target(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_def_target'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_access()
        if address0 is FAILURE:
            self._offset = index1
            index2, elements0 = self._offset, []
            address1 = FAILURE
            chunk0, max0 = None, self._offset + 1
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == '<':
                address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                self._offset = self._offset + 1
            else:
                address1 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'<\'')
            if address1 is not FAILURE:
                address2 = FAILURE
                address2 = self._read__()
                if address2 is not FAILURE:
                    elements0.append(address2)
                    address3 = FAILURE
                    address3 = self._read_special_entry()
                    if address3 is not FAILURE:
                        elements0.append(address3)
                        address4 = FAILURE
                        address4 = self._read__()
                        if address4 is not FAILURE:
                            elements0.append(address4)
                            address5 = FAILURE
                            chunk1, max1 = None, self._offset + 1
                            if max1 <= self._input_size:
                                chunk1 = self._input[self._offset:max1]
                            if chunk1 == '>':
                                address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                self._offset = self._offset + 1
                            else:
                                address5 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'>\'')
                            if address5 is not FAILURE:
                                address6 = FAILURE
                                address6 = self._read__()
                                if address6 is not FAILURE:
                                    elements0.append(address6)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
            if elements0 is None:
                address0 = FAILURE
            else:
                address0 = TreeNode51(self._input[index2:self._offset], index2, elements0)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                chunk2, max2 = None, self._offset + 1
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == '?':
                    address0 = self._actions.special_ref(self._input, self._offset, self._offset + 1, [])
                    self._offset = self._offset + 1
                else:
                    address0 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'?\'')
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['modifier_def_target'][index0] = (address0, self._offset)
        return address0

    def _read_modifier_def(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['modifier_def'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_modifier_def_target()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk0, max0 = None, self._offset + 2
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == '<-':
                    address3 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<-\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    index2 = self._offset
                    chunk1, max1 = None, self._offset + 1
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == '>':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>\'')
                    self._offset = index2
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__ws()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index3 = self._offset
                            address6 = self._read_small_modifier_body()
                            if address6 is FAILURE:
                                self._offset = index3
                                address6 = self._read_normal_modifier_body()
                                if address6 is FAILURE:
                                    self._offset = index3
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modifier_def(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['modifier_def'][index0] = (address0, self._offset)
        return address0

    def _read_lambda_def(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['lambda_def'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '!':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'!\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 2
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == '<-':
                    address3 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                    self._offset = self._offset + 2
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'<-\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    index2 = self._offset
                    chunk2, max2 = None, self._offset + 1
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == '>':
                        address4 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'>\'')
                    self._offset = index2
                    if address4 is FAILURE:
                        address4 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address4 = FAILURE
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read__ws()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index3 = self._offset
                            address6 = self._read_small_modifier_body()
                            if address6 is FAILURE:
                                self._offset = index3
                                address6 = self._read_normal_modifier_body()
                                if address6 is FAILURE:
                                    self._offset = index3
                            if address6 is not FAILURE:
                                elements0.append(address6)
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.modifier_def(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['lambda_def'][index0] = (address0, self._offset)
        return address0

    def _read_then(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['then'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'then':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'then\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_stmt_or_expr()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode54(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['then'][index0] = (address0, self._offset)
        return address0

    def _read_if_then(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['if_then'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'if':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'if\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_expression()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_then()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.if_(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['if_then'][index0] = (address0, self._offset)
        return address0

    def _read_unless(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['unless'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 6
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'unless':
            address1 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
            self._offset = self._offset + 6
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'unless\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_expression()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_then()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.unless(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['unless'][index0] = (address0, self._offset)
        return address0

    def _read_otherwise(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['otherwise'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 9
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'otherwise':
            address1 = TreeNode(self._input[self._offset:self._offset + 9], self._offset, [])
            self._offset = self._offset + 9
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'otherwise\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_stmt_or_expr()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.otherwise(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['otherwise'][index0] = (address0, self._offset)
        return address0

    def _read_basic_load_list(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['basic_load_list'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_basic_name()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ',':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\',\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read__ws()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode58(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address7 = FAILURE
            index4 = self._offset
            address7 = self._read_basic_name()
            if address7 is FAILURE:
                address7 = TreeNode(self._input[index4:index4], index4, [])
                self._offset = index4
            if address7 is not FAILURE:
                elements0.append(address7)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['basic_load_list'][index0] = (address0, self._offset)
        return address0

    def _read_access_load_list(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['access_load_list'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_access()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ',':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\',\'')
                    if address5 is not FAILURE:
                        address6 = FAILURE
                        address6 = self._read__ws()
                        if address6 is not FAILURE:
                            elements2.append(address6)
                        else:
                            elements2 = None
                            self._offset = index3
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode59(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address7 = FAILURE
            index4 = self._offset
            address7 = self._read_access()
            if address7 is FAILURE:
                address7 = TreeNode(self._input[index4:index4], index4, [])
                self._offset = index4
            if address7 is not FAILURE:
                elements0.append(address7)
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['access_load_list'][index0] = (address0, self._offset)
        return address0

    def _read_loadable(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['loadable'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_new_bag()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_access_load_list()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['loadable'][index0] = (address0, self._offset)
        return address0

    def _read_load_into(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['load_into'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'into':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'into\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_access()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode60(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['load_into'][index0] = (address0, self._offset)
        return address0

    def _read_load_from(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['load_from'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'from':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'from\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_loadable()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode61(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['load_from'][index0] = (address0, self._offset)
        return address0

    def _read_load(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['load'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 4
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'load':
            address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
            self._offset = self._offset + 4
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'load\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 1
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == '*':
                    address3 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                    self._offset = self._offset + 1
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'*\'')
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_load_from()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                index3 = self._offset
                                address7 = self._read_load_into()
                                if address7 is FAILURE:
                                    address7 = TreeNode(self._input[index3:index3], index3, [])
                                    self._offset = index3
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index2
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.load_from_into(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index4, elements1 = self._offset, []
            address8 = FAILURE
            chunk2, max2 = None, self._offset + 4
            if max2 <= self._input_size:
                chunk2 = self._input[self._offset:max2]
            if chunk2 == 'load':
                address8 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                self._offset = self._offset + 4
            else:
                address8 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'load\'')
            if address8 is not FAILURE:
                address9 = FAILURE
                address9 = self._read__()
                if address9 is not FAILURE:
                    elements1.append(address9)
                    address10 = FAILURE
                    address10 = self._read_loadable()
                    if address10 is not FAILURE:
                        elements1.append(address10)
                        address11 = FAILURE
                        address11 = self._read__()
                        if address11 is not FAILURE:
                            elements1.append(address11)
                            address12 = FAILURE
                            address12 = self._read_load_from()
                            if address12 is not FAILURE:
                                elements1.append(address12)
                                address13 = FAILURE
                                address13 = self._read__()
                                if address13 is not FAILURE:
                                    elements1.append(address13)
                                    address14 = FAILURE
                                    address14 = self._read_load_into()
                                    if address14 is not FAILURE:
                                        elements1.append(address14)
                                    else:
                                        elements1 = None
                                        self._offset = index4
                                else:
                                    elements1 = None
                                    self._offset = index4
                            else:
                                elements1 = None
                                self._offset = index4
                        else:
                            elements1 = None
                            self._offset = index4
                    else:
                        elements1 = None
                        self._offset = index4
                else:
                    elements1 = None
                    self._offset = index4
            else:
                elements1 = None
                self._offset = index4
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.load_from_into(self._input, index4, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index5, elements2 = self._offset, []
                address15 = FAILURE
                chunk3, max3 = None, self._offset + 4
                if max3 <= self._input_size:
                    chunk3 = self._input[self._offset:max3]
                if chunk3 == 'load':
                    address15 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                    self._offset = self._offset + 4
                else:
                    address15 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'load\'')
                if address15 is not FAILURE:
                    address16 = FAILURE
                    address16 = self._read__()
                    if address16 is not FAILURE:
                        elements2.append(address16)
                        address17 = FAILURE
                        address17 = self._read_loadable()
                        if address17 is not FAILURE:
                            elements2.append(address17)
                            address18 = FAILURE
                            address18 = self._read__()
                            if address18 is not FAILURE:
                                elements2.append(address18)
                                address19 = FAILURE
                                address19 = self._read_load_from()
                                if address19 is not FAILURE:
                                    elements2.append(address19)
                                else:
                                    elements2 = None
                                    self._offset = index5
                            else:
                                elements2 = None
                                self._offset = index5
                        else:
                            elements2 = None
                            self._offset = index5
                    else:
                        elements2 = None
                        self._offset = index5
                else:
                    elements2 = None
                    self._offset = index5
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.load_from(self._input, index5, self._offset, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
                    index6, elements3 = self._offset, []
                    address20 = FAILURE
                    chunk4, max4 = None, self._offset + 4
                    if max4 <= self._input_size:
                        chunk4 = self._input[self._offset:max4]
                    if chunk4 == 'load':
                        address20 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                        self._offset = self._offset + 4
                    else:
                        address20 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'load\'')
                    if address20 is not FAILURE:
                        address21 = FAILURE
                        address21 = self._read__()
                        if address21 is not FAILURE:
                            elements3.append(address21)
                            address22 = FAILURE
                            address22 = self._read_loadable()
                            if address22 is not FAILURE:
                                elements3.append(address22)
                                address23 = FAILURE
                                address23 = self._read__()
                                if address23 is not FAILURE:
                                    elements3.append(address23)
                                    address24 = FAILURE
                                    address24 = self._read_load_into()
                                    if address24 is not FAILURE:
                                        elements3.append(address24)
                                    else:
                                        elements3 = None
                                        self._offset = index6
                                else:
                                    elements3 = None
                                    self._offset = index6
                            else:
                                elements3 = None
                                self._offset = index6
                        else:
                            elements3 = None
                            self._offset = index6
                    else:
                        elements3 = None
                        self._offset = index6
                    if elements3 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.load_into(self._input, index6, self._offset, elements3)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index7, elements4 = self._offset, []
                        address25 = FAILURE
                        chunk5, max5 = None, self._offset + 4
                        if max5 <= self._input_size:
                            chunk5 = self._input[self._offset:max5]
                        if chunk5 == 'load':
                            address25 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                            self._offset = self._offset + 4
                        else:
                            address25 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'load\'')
                        if address25 is not FAILURE:
                            address26 = FAILURE
                            address26 = self._read__()
                            if address26 is not FAILURE:
                                elements4.append(address26)
                                address27 = FAILURE
                                address27 = self._read_loadable()
                                if address27 is not FAILURE:
                                    elements4.append(address27)
                                else:
                                    elements4 = None
                                    self._offset = index7
                            else:
                                elements4 = None
                                self._offset = index7
                        else:
                            elements4 = None
                            self._offset = index7
                        if elements4 is None:
                            address0 = FAILURE
                        else:
                            address0 = self._actions.load(self._input, index7, self._offset, elements4)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
        self._cache['load'][index0] = (address0, self._offset)
        return address0

    def _read_except_when(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['except_when'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 6
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'except':
            address1 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
            self._offset = self._offset + 6
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'except\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 4
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == 'when':
                    address3 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                    self._offset = self._offset + 4
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'when\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_expression()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            address6 = self._read__()
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read_then()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.predicated_statement(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['except_when'][index0] = (address0, self._offset)
        return address0

    def _read_restart_pos(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['restart_pos'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 6
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'before':
            address1 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
            self._offset = self._offset + 6
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'before\'')
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index3 = self._offset
                address3 = self._read_name()
                if address3 is FAILURE:
                    address3 = TreeNode(self._input[index3:index3], index3, [])
                    self._offset = index3
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.restart(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index4, elements1 = self._offset, []
            address4 = FAILURE
            chunk1, max1 = None, self._offset + 2
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'at':
                address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                self._offset = self._offset + 2
            else:
                address4 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'at\'')
            if address4 is not FAILURE:
                elements1.append(address4)
                address5 = FAILURE
                address5 = self._read__()
                if address5 is not FAILURE:
                    elements1.append(address5)
                    address6 = FAILURE
                    index5 = self._offset
                    address6 = self._read_name()
                    if address6 is FAILURE:
                        address6 = TreeNode(self._input[index5:index5], index5, [])
                        self._offset = index5
                    if address6 is not FAILURE:
                        elements1.append(address6)
                    else:
                        elements1 = None
                        self._offset = index4
                else:
                    elements1 = None
                    self._offset = index4
            else:
                elements1 = None
                self._offset = index4
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.restart(self._input, index4, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index6, elements2 = self._offset, []
                address7 = FAILURE
                chunk2, max2 = None, self._offset + 5
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == 'after':
                    address7 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                    self._offset = self._offset + 5
                else:
                    address7 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'after\'')
                if address7 is not FAILURE:
                    elements2.append(address7)
                    address8 = FAILURE
                    address8 = self._read__()
                    if address8 is not FAILURE:
                        elements2.append(address8)
                        address9 = FAILURE
                        index7 = self._offset
                        address9 = self._read_name()
                        if address9 is FAILURE:
                            address9 = TreeNode(self._input[index7:index7], index7, [])
                            self._offset = index7
                        if address9 is not FAILURE:
                            elements2.append(address9)
                        else:
                            elements2 = None
                            self._offset = index6
                    else:
                        elements2 = None
                        self._offset = index6
                else:
                    elements2 = None
                    self._offset = index6
                if elements2 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.restart(self._input, index6, self._offset, elements2)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['restart_pos'][index0] = (address0, self._offset)
        return address0

    def _read_stmt_or_expr(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['stmt_or_expr'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_statement()
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_expression()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['stmt_or_expr'][index0] = (address0, self._offset)
        return address0

    def _read_block_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['block_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        remaining0, index2, elements1, address2 = 0, self._offset, [], True
        while address2 is not FAILURE:
            index3, elements2 = self._offset, []
            address3 = FAILURE
            address3 = self._read_statement()
            if address3 is not FAILURE:
                elements2.append(address3)
                address4 = FAILURE
                address4 = self._read__()
                if address4 is not FAILURE:
                    elements2.append(address4)
                    address5 = FAILURE
                    index4 = self._offset
                    chunk0, max0 = None, self._offset + 1
                    if max0 <= self._input_size:
                        chunk0 = self._input[self._offset:max0]
                    if chunk0 == ']':
                        address5 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                        self._offset = self._offset + 1
                    else:
                        address5 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\']\'')
                    self._offset = index4
                    if address5 is FAILURE:
                        address5 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                        self._offset = self._offset
                    else:
                        address5 = FAILURE
                    if address5 is not FAILURE:
                        elements2.append(address5)
                    else:
                        elements2 = None
                        self._offset = index3
                else:
                    elements2 = None
                    self._offset = index3
            else:
                elements2 = None
                self._offset = index3
            if elements2 is None:
                address2 = FAILURE
            else:
                address2 = TreeNode72(self._input[index3:self._offset], index3, elements2)
                self._offset = self._offset
            if address2 is not FAILURE:
                elements1.append(address2)
                remaining0 -= 1
        if remaining0 <= 0:
            address1 = TreeNode(self._input[index2:self._offset], index2, elements1)
            self._offset = self._offset
        else:
            address1 = FAILURE
        if address1 is not FAILURE:
            elements0.append(address1)
            address6 = FAILURE
            address6 = self._read__()
            if address6 is not FAILURE:
                elements0.append(address6)
                address7 = FAILURE
                address7 = self._read_statement()
                if address7 is not FAILURE:
                    elements0.append(address7)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode71(self._input[index1:self._offset], index1, elements0)
            self._offset = self._offset
        self._cache['block_body'][index0] = (address0, self._offset)
        return address0

    def _read_loop_name(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['loop_name'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 1
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == '@':
            address1 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
            self._offset = self._offset + 1
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'@\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_basic_name()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.loop_name(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['loop_name'][index0] = (address0, self._offset)
        return address0

    def _read_loop_body(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['loop_body'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 2
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'do':
            address1 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
            self._offset = self._offset + 2
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'do\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                address3 = FAILURE
                address3 = self._read_stmt_or_expr()
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.loop_body(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['loop_body'][index0] = (address0, self._offset)
        return address0

    def _read_but_if_stmt(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['but_if_stmt'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        address1 = self._read_expression()
        if address1 is not FAILURE:
            elements0.append(address1)
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                index3 = self._offset
                chunk0, max0 = None, self._offset + 3
                if max0 <= self._input_size:
                    chunk0 = self._input[self._offset:max0]
                if chunk0 == 'but':
                    address3 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                    self._offset = self._offset + 3
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'but\'')
                self._offset = index3
                if address3 is not FAILURE:
                    address3 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                    self._offset = self._offset
                else:
                    address3 = FAILURE
                if address3 is not FAILURE:
                    elements0.append(address3)
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = TreeNode75(self._input[index2:self._offset], index2, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            address0 = self._read_stmt_or_expr()
            if address0 is FAILURE:
                self._offset = index1
        self._cache['but_if_stmt'][index0] = (address0, self._offset)
        return address0

    def _read_but_if(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['but_if'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'but':
            address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
            self._offset = self._offset + 3
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'but\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            index2 = self._offset
            chunk1, max1 = None, self._offset + 6
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'always':
                address2 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                self._offset = self._offset + 6
            else:
                address2 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'always\'')
            self._offset = index2
            if address2 is FAILURE:
                address2 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                self._offset = self._offset
            else:
                address2 = FAILURE
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read__()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    chunk2, max2 = None, self._offset + 2
                    if max2 <= self._input_size:
                        chunk2 = self._input[self._offset:max2]
                    if chunk2 == 'if':
                        address4 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                        self._offset = self._offset + 2
                    else:
                        address4 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'if\'')
                    if address4 is not FAILURE:
                        address5 = FAILURE
                        address5 = self._read__()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                            address6 = FAILURE
                            index3 = self._offset
                            address6 = self._read_expression()
                            if address6 is FAILURE:
                                self._offset = index3
                                chunk3, max3 = None, self._offset + 1
                                if max3 <= self._input_size:
                                    chunk3 = self._input[self._offset:max3]
                                if chunk3 == '*':
                                    address6 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address6 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'*\'')
                                if address6 is FAILURE:
                                    self._offset = index3
                            if address6 is not FAILURE:
                                elements0.append(address6)
                                address7 = FAILURE
                                address7 = self._read__()
                                if address7 is not FAILURE:
                                    elements0.append(address7)
                                    address8 = FAILURE
                                    chunk4, max4 = None, self._offset + 6
                                    if max4 <= self._input_size:
                                        chunk4 = self._input[self._offset:max4]
                                    if chunk4 == 'occurs':
                                        address8 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                                        self._offset = self._offset + 6
                                    else:
                                        address8 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'occurs\'')
                                    if address8 is not FAILURE:
                                        address9 = FAILURE
                                        address9 = self._read__()
                                        if address9 is not FAILURE:
                                            elements0.append(address9)
                                            address10 = FAILURE
                                            address10 = self._read_then()
                                            if address10 is not FAILURE:
                                                elements0.append(address10)
                                            else:
                                                elements0 = None
                                                self._offset = index1
                                        else:
                                            elements0 = None
                                            self._offset = index1
                                    else:
                                        elements0 = None
                                        self._offset = index1
                                else:
                                    elements0 = None
                                    self._offset = index1
                            else:
                                elements0 = None
                                self._offset = index1
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.but_if(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['but_if'][index0] = (address0, self._offset)
        return address0

    def _read_always(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['always'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 3
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'but':
            address1 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
            self._offset = self._offset + 3
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'but\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                chunk1, max1 = None, self._offset + 6
                if max1 <= self._input_size:
                    chunk1 = self._input[self._offset:max1]
                if chunk1 == 'always':
                    address3 = TreeNode(self._input[self._offset:self._offset + 6], self._offset, [])
                    self._offset = self._offset + 6
                else:
                    address3 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'always\'')
                if address3 is not FAILURE:
                    address4 = FAILURE
                    address4 = self._read__ws()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_stmt_or_expr()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index1
                    else:
                        elements0 = None
                        self._offset = index1
                else:
                    elements0 = None
                    self._offset = index1
            else:
                elements0 = None
                self._offset = index1
        else:
            elements0 = None
            self._offset = index1
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.always(self._input, index1, self._offset, elements0)
            self._offset = self._offset
        self._cache['always'][index0] = (address0, self._offset)
        return address0

    def _read_attempt(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['attempt'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        index2, elements0 = self._offset, []
        address1 = FAILURE
        chunk0, max0 = None, self._offset + 7
        if max0 <= self._input_size:
            chunk0 = self._input[self._offset:max0]
        if chunk0 == 'attempt':
            address1 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
            self._offset = self._offset + 7
        else:
            address1 = FAILURE
            if self._offset > self._failure:
                self._failure = self._offset
                self._expected = []
            if self._offset == self._failure:
                self._expected.append('\'attempt\'')
        if address1 is not FAILURE:
            address2 = FAILURE
            address2 = self._read__ws()
            if address2 is not FAILURE:
                elements0.append(address2)
                address3 = FAILURE
                address3 = self._read_but_if_stmt()
                if address3 is not FAILURE:
                    elements0.append(address3)
                    address4 = FAILURE
                    address4 = self._read__ws()
                    if address4 is not FAILURE:
                        elements0.append(address4)
                        address5 = FAILURE
                        address5 = self._read_always()
                        if address5 is not FAILURE:
                            elements0.append(address5)
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                else:
                    elements0 = None
                    self._offset = index2
            else:
                elements0 = None
                self._offset = index2
        else:
            elements0 = None
            self._offset = index2
        if elements0 is None:
            address0 = FAILURE
        else:
            address0 = self._actions.attempt(self._input, index2, self._offset, elements0)
            self._offset = self._offset
        if address0 is FAILURE:
            self._offset = index1
            index3, elements1 = self._offset, []
            address6 = FAILURE
            chunk1, max1 = None, self._offset + 7
            if max1 <= self._input_size:
                chunk1 = self._input[self._offset:max1]
            if chunk1 == 'attempt':
                address6 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                self._offset = self._offset + 7
            else:
                address6 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'attempt\'')
            if address6 is not FAILURE:
                address7 = FAILURE
                address7 = self._read__ws()
                if address7 is not FAILURE:
                    elements1.append(address7)
                    address8 = FAILURE
                    address8 = self._read_but_if_stmt()
                    if address8 is not FAILURE:
                        elements1.append(address8)
                        address9 = FAILURE
                        address9 = self._read__ws()
                        if address9 is not FAILURE:
                            elements1.append(address9)
                            address10 = FAILURE
                            remaining0, index4, elements2, address11 = 1, self._offset, [], True
                            while address11 is not FAILURE:
                                address11 = self._read_but_if()
                                if address11 is not FAILURE:
                                    elements2.append(address11)
                                    remaining0 -= 1
                            if remaining0 <= 0:
                                address10 = TreeNode(self._input[index4:self._offset], index4, elements2)
                                self._offset = self._offset
                            else:
                                address10 = FAILURE
                            if address10 is not FAILURE:
                                elements1.append(address10)
                                address12 = FAILURE
                                index5 = self._offset
                                index6, elements3 = self._offset, []
                                address13 = FAILURE
                                address13 = self._read__ws()
                                if address13 is not FAILURE:
                                    elements3.append(address13)
                                    address14 = FAILURE
                                    address14 = self._read_always()
                                    if address14 is not FAILURE:
                                        elements3.append(address14)
                                    else:
                                        elements3 = None
                                        self._offset = index6
                                else:
                                    elements3 = None
                                    self._offset = index6
                                if elements3 is None:
                                    address12 = FAILURE
                                else:
                                    address12 = TreeNode80(self._input[index6:self._offset], index6, elements3)
                                    self._offset = self._offset
                                if address12 is FAILURE:
                                    address12 = TreeNode(self._input[index5:index5], index5, [])
                                    self._offset = index5
                                if address12 is not FAILURE:
                                    elements1.append(address12)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                    else:
                        elements1 = None
                        self._offset = index3
                else:
                    elements1 = None
                    self._offset = index3
            else:
                elements1 = None
                self._offset = index3
            if elements1 is None:
                address0 = FAILURE
            else:
                address0 = self._actions.attempt(self._input, index3, self._offset, elements1)
                self._offset = self._offset
            if address0 is FAILURE:
                self._offset = index1
                index7, elements4 = self._offset, []
                address15 = FAILURE
                chunk2, max2 = None, self._offset + 7
                if max2 <= self._input_size:
                    chunk2 = self._input[self._offset:max2]
                if chunk2 == 'attempt':
                    address15 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                    self._offset = self._offset + 7
                else:
                    address15 = FAILURE
                    if self._offset > self._failure:
                        self._failure = self._offset
                        self._expected = []
                    if self._offset == self._failure:
                        self._expected.append('\'attempt\'')
                if address15 is not FAILURE:
                    address16 = FAILURE
                    address16 = self._read__ws()
                    if address16 is not FAILURE:
                        elements4.append(address16)
                        address17 = FAILURE
                        address17 = self._read_but_if_stmt()
                        if address17 is not FAILURE:
                            elements4.append(address17)
                        else:
                            elements4 = None
                            self._offset = index7
                    else:
                        elements4 = None
                        self._offset = index7
                else:
                    elements4 = None
                    self._offset = index7
                if elements4 is None:
                    address0 = FAILURE
                else:
                    address0 = self._actions.attempt(self._input, index7, self._offset, elements4)
                    self._offset = self._offset
                if address0 is FAILURE:
                    self._offset = index1
        self._cache['attempt'][index0] = (address0, self._offset)
        return address0

    def _read_statement(self):
        address0, index0 = FAILURE, self._offset
        cached = self._cache['statement'].get(index0)
        if cached:
            self._offset = cached[1]
            return cached[0]
        index1 = self._offset
        address0 = self._read_eos()
        if address0 is FAILURE:
            self._offset = index1
            chunk0, max0 = None, self._offset + 5
            if max0 <= self._input_size:
                chunk0 = self._input[self._offset:max0]
            if chunk0 == 'leave':
                address0 = self._actions.leave(self._input, self._offset, self._offset + 5, [])
                self._offset = self._offset + 5
            else:
                address0 = FAILURE
                if self._offset > self._failure:
                    self._failure = self._offset
                    self._expected = []
                if self._offset == self._failure:
                    self._expected.append('\'leave\'')
            if address0 is FAILURE:
                self._offset = index1
                address0 = self._read_attempt()
                if address0 is FAILURE:
                    self._offset = index1
                    index2, elements0 = self._offset, []
                    address1 = FAILURE
                    chunk1, max1 = None, self._offset + 4
                    if max1 <= self._input_size:
                        chunk1 = self._input[self._offset:max1]
                    if chunk1 == 'oops':
                        address1 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                        self._offset = self._offset + 4
                    else:
                        address1 = FAILURE
                        if self._offset > self._failure:
                            self._failure = self._offset
                            self._expected = []
                        if self._offset == self._failure:
                            self._expected.append('\'oops\'')
                    if address1 is not FAILURE:
                        address2 = FAILURE
                        address2 = self._read__()
                        if address2 is not FAILURE:
                            elements0.append(address2)
                            address3 = FAILURE
                            address3 = self._read_expression()
                            if address3 is not FAILURE:
                                elements0.append(address3)
                            else:
                                elements0 = None
                                self._offset = index2
                        else:
                            elements0 = None
                            self._offset = index2
                    else:
                        elements0 = None
                        self._offset = index2
                    if elements0 is None:
                        address0 = FAILURE
                    else:
                        address0 = self._actions.oops(self._input, index2, self._offset, elements0)
                        self._offset = self._offset
                    if address0 is FAILURE:
                        self._offset = index1
                        index3, elements1 = self._offset, []
                        address4 = FAILURE
                        chunk2, max2 = None, self._offset + 5
                        if max2 <= self._input_size:
                            chunk2 = self._input[self._offset:max2]
                        if chunk2 == 'clear':
                            address4 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                            self._offset = self._offset + 5
                        else:
                            address4 = FAILURE
                            if self._offset > self._failure:
                                self._failure = self._offset
                                self._expected = []
                            if self._offset == self._failure:
                                self._expected.append('\'clear\'')
                        if address4 is not FAILURE:
                            address5 = FAILURE
                            address5 = self._read__()
                            if address5 is not FAILURE:
                                elements1.append(address5)
                                address6 = FAILURE
                                address6 = self._read_access()
                                if address6 is not FAILURE:
                                    elements1.append(address6)
                                else:
                                    elements1 = None
                                    self._offset = index3
                            else:
                                elements1 = None
                                self._offset = index3
                        else:
                            elements1 = None
                            self._offset = index3
                        if elements1 is None:
                            address0 = FAILURE
                        else:
                            address0 = self._actions.clear(self._input, index3, self._offset, elements1)
                            self._offset = self._offset
                        if address0 is FAILURE:
                            self._offset = index1
                            index4, elements2 = self._offset, []
                            address7 = FAILURE
                            chunk3, max3 = None, self._offset + 7
                            if max3 <= self._input_size:
                                chunk3 = self._input[self._offset:max3]
                            if chunk3 == 'restart':
                                address7 = TreeNode(self._input[self._offset:self._offset + 7], self._offset, [])
                                self._offset = self._offset + 7
                            else:
                                address7 = FAILURE
                                if self._offset > self._failure:
                                    self._failure = self._offset
                                    self._expected = []
                                if self._offset == self._failure:
                                    self._expected.append('\'restart\'')
                            if address7 is not FAILURE:
                                address8 = FAILURE
                                address8 = self._read__()
                                if address8 is not FAILURE:
                                    elements2.append(address8)
                                    address9 = FAILURE
                                    address9 = self._read_restart_pos()
                                    if address9 is not FAILURE:
                                        elements2.append(address9)
                                    else:
                                        elements2 = None
                                        self._offset = index4
                                else:
                                    elements2 = None
                                    self._offset = index4
                            else:
                                elements2 = None
                                self._offset = index4
                            if elements2 is None:
                                address0 = FAILURE
                            else:
                                address0 = TreeNode84(self._input[index4:self._offset], index4, elements2)
                                self._offset = self._offset
                            if address0 is FAILURE:
                                self._offset = index1
                                index5, elements3 = self._offset, []
                                address10 = FAILURE
                                chunk4, max4 = None, self._offset + 1
                                if max4 <= self._input_size:
                                    chunk4 = self._input[self._offset:max4]
                                if chunk4 == '[':
                                    address10 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                    self._offset = self._offset + 1
                                else:
                                    address10 = FAILURE
                                    if self._offset > self._failure:
                                        self._failure = self._offset
                                        self._expected = []
                                    if self._offset == self._failure:
                                        self._expected.append('\'[\'')
                                if address10 is not FAILURE:
                                    address11 = FAILURE
                                    index6 = self._offset
                                    chunk5, max5 = None, self._offset + 1
                                    if max5 <= self._input_size:
                                        chunk5 = self._input[self._offset:max5]
                                    if chunk5 == ':':
                                        address11 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address11 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\':\'')
                                    self._offset = index6
                                    if address11 is FAILURE:
                                        address11 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                        self._offset = self._offset
                                    else:
                                        address11 = FAILURE
                                    if address11 is not FAILURE:
                                        elements3.append(address11)
                                        address12 = FAILURE
                                        address12 = self._read__ws()
                                        if address12 is not FAILURE:
                                            elements3.append(address12)
                                            address13 = FAILURE
                                            address13 = self._read_block_body()
                                            if address13 is not FAILURE:
                                                elements3.append(address13)
                                                address14 = FAILURE
                                                address14 = self._read__ws()
                                                if address14 is not FAILURE:
                                                    elements3.append(address14)
                                                    address15 = FAILURE
                                                    chunk6, max6 = None, self._offset + 1
                                                    if max6 <= self._input_size:
                                                        chunk6 = self._input[self._offset:max6]
                                                    if chunk6 == ']':
                                                        address15 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                        self._offset = self._offset + 1
                                                    else:
                                                        address15 = FAILURE
                                                        if self._offset > self._failure:
                                                            self._failure = self._offset
                                                            self._expected = []
                                                        if self._offset == self._failure:
                                                            self._expected.append('\']\'')
                                                    if address15 is not FAILURE:
                                                        address16 = FAILURE
                                                        address16 = self._read__()
                                                        if address16 is not FAILURE:
                                                            elements3.append(address16)
                                                        else:
                                                            elements3 = None
                                                            self._offset = index5
                                                    else:
                                                        elements3 = None
                                                        self._offset = index5
                                                else:
                                                    elements3 = None
                                                    self._offset = index5
                                            else:
                                                elements3 = None
                                                self._offset = index5
                                        else:
                                            elements3 = None
                                            self._offset = index5
                                    else:
                                        elements3 = None
                                        self._offset = index5
                                else:
                                    elements3 = None
                                    self._offset = index5
                                if elements3 is None:
                                    address0 = FAILURE
                                else:
                                    address0 = self._actions.block(self._input, index5, self._offset, elements3)
                                    self._offset = self._offset
                                if address0 is FAILURE:
                                    self._offset = index1
                                    index7, elements4 = self._offset, []
                                    address17 = FAILURE
                                    chunk7, max7 = None, self._offset + 1
                                    if max7 <= self._input_size:
                                        chunk7 = self._input[self._offset:max7]
                                    if chunk7 == '[':
                                        address17 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                        self._offset = self._offset + 1
                                    else:
                                        address17 = FAILURE
                                        if self._offset > self._failure:
                                            self._failure = self._offset
                                            self._expected = []
                                        if self._offset == self._failure:
                                            self._expected.append('\'[\'')
                                    if address17 is not FAILURE:
                                        address18 = FAILURE
                                        index8 = self._offset
                                        chunk8, max8 = None, self._offset + 1
                                        if max8 <= self._input_size:
                                            chunk8 = self._input[self._offset:max8]
                                        if chunk8 == ':':
                                            address18 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                            self._offset = self._offset + 1
                                        else:
                                            address18 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\':\'')
                                        self._offset = index8
                                        if address18 is FAILURE:
                                            address18 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                            self._offset = self._offset
                                        else:
                                            address18 = FAILURE
                                        if address18 is not FAILURE:
                                            elements4.append(address18)
                                            address19 = FAILURE
                                            address19 = self._read__ws()
                                            if address19 is not FAILURE:
                                                elements4.append(address19)
                                                address20 = FAILURE
                                                chunk9, max9 = None, self._offset + 1
                                                if max9 <= self._input_size:
                                                    chunk9 = self._input[self._offset:max9]
                                                if chunk9 == ']':
                                                    address20 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                    self._offset = self._offset + 1
                                                else:
                                                    address20 = FAILURE
                                                    if self._offset > self._failure:
                                                        self._failure = self._offset
                                                        self._expected = []
                                                    if self._offset == self._failure:
                                                        self._expected.append('\']\'')
                                                if address20 is not FAILURE:
                                                    address21 = FAILURE
                                                    address21 = self._read__()
                                                    if address21 is not FAILURE:
                                                        elements4.append(address21)
                                                    else:
                                                        elements4 = None
                                                        self._offset = index7
                                                else:
                                                    elements4 = None
                                                    self._offset = index7
                                            else:
                                                elements4 = None
                                                self._offset = index7
                                        else:
                                            elements4 = None
                                            self._offset = index7
                                    else:
                                        elements4 = None
                                        self._offset = index7
                                    if elements4 is None:
                                        address0 = FAILURE
                                    else:
                                        address0 = self._actions.block(self._input, index7, self._offset, elements4)
                                        self._offset = self._offset
                                    if address0 is FAILURE:
                                        self._offset = index1
                                        index9, elements5 = self._offset, []
                                        address22 = FAILURE
                                        chunk10, max10 = None, self._offset + 2
                                        if max10 <= self._input_size:
                                            chunk10 = self._input[self._offset:max10]
                                        if chunk10 == '={':
                                            address22 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                            self._offset = self._offset + 2
                                        else:
                                            address22 = FAILURE
                                            if self._offset > self._failure:
                                                self._failure = self._offset
                                                self._expected = []
                                            if self._offset == self._failure:
                                                self._expected.append('\'={\'')
                                        if address22 is not FAILURE:
                                            address23 = FAILURE
                                            index10 = self._offset
                                            chunk11, max11 = None, self._offset + 1
                                            if max11 <= self._input_size:
                                                chunk11 = self._input[self._offset:max11]
                                            if chunk11 == ':':
                                                address23 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                self._offset = self._offset + 1
                                            else:
                                                address23 = FAILURE
                                                if self._offset > self._failure:
                                                    self._failure = self._offset
                                                    self._expected = []
                                                if self._offset == self._failure:
                                                    self._expected.append('\':\'')
                                            self._offset = index10
                                            if address23 is FAILURE:
                                                address23 = TreeNode(self._input[self._offset:self._offset], self._offset, [])
                                                self._offset = self._offset
                                            else:
                                                address23 = FAILURE
                                            if address23 is not FAILURE:
                                                elements5.append(address23)
                                                address24 = FAILURE
                                                address24 = self._read__()
                                                if address24 is not FAILURE:
                                                    elements5.append(address24)
                                                    address25 = FAILURE
                                                    address25 = self._read_access()
                                                    if address25 is not FAILURE:
                                                        elements5.append(address25)
                                                        address26 = FAILURE
                                                        address26 = self._read__()
                                                        if address26 is not FAILURE:
                                                            elements5.append(address26)
                                                            address27 = FAILURE
                                                            chunk12, max12 = None, self._offset + 1
                                                            if max12 <= self._input_size:
                                                                chunk12 = self._input[self._offset:max12]
                                                            if chunk12 == '}':
                                                                address27 = TreeNode(self._input[self._offset:self._offset + 1], self._offset, [])
                                                                self._offset = self._offset + 1
                                                            else:
                                                                address27 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'}\'')
                                                            if address27 is not FAILURE:
                                                                address28 = FAILURE
                                                                address28 = self._read__()
                                                                if address28 is not FAILURE:
                                                                    elements5.append(address28)
                                                                else:
                                                                    elements5 = None
                                                                    self._offset = index9
                                                            else:
                                                                elements5 = None
                                                                self._offset = index9
                                                        else:
                                                            elements5 = None
                                                            self._offset = index9
                                                    else:
                                                        elements5 = None
                                                        self._offset = index9
                                                else:
                                                    elements5 = None
                                                    self._offset = index9
                                            else:
                                                elements5 = None
                                                self._offset = index9
                                        else:
                                            elements5 = None
                                            self._offset = index9
                                        if elements5 is None:
                                            address0 = FAILURE
                                        else:
                                            address0 = self._actions.reduce_and_assign(self._input, index9, self._offset, elements5)
                                            self._offset = self._offset
                                        if address0 is FAILURE:
                                            self._offset = index1
                                            address0 = self._read_load()
                                            if address0 is FAILURE:
                                                self._offset = index1
                                                address0 = self._read_modifier_def()
                                                if address0 is FAILURE:
                                                    self._offset = index1
                                                    index11, elements6 = self._offset, []
                                                    address29 = FAILURE
                                                    address29 = self._read_if_then()
                                                    if address29 is not FAILURE:
                                                        elements6.append(address29)
                                                        address30 = FAILURE
                                                        remaining0, index12, elements7, address31 = 0, self._offset, [], True
                                                        while address31 is not FAILURE:
                                                            index13, elements8 = self._offset, []
                                                            address32 = FAILURE
                                                            address32 = self._read__ws()
                                                            if address32 is not FAILURE:
                                                                elements8.append(address32)
                                                                address33 = FAILURE
                                                                address33 = self._read_unless()
                                                                if address33 is not FAILURE:
                                                                    elements8.append(address33)
                                                                else:
                                                                    elements8 = None
                                                                    self._offset = index13
                                                            else:
                                                                elements8 = None
                                                                self._offset = index13
                                                            if elements8 is None:
                                                                address31 = FAILURE
                                                            else:
                                                                address31 = TreeNode89(self._input[index13:self._offset], index13, elements8)
                                                                self._offset = self._offset
                                                            if address31 is not FAILURE:
                                                                elements7.append(address31)
                                                                remaining0 -= 1
                                                        if remaining0 <= 0:
                                                            address30 = TreeNode(self._input[index12:self._offset], index12, elements7)
                                                            self._offset = self._offset
                                                        else:
                                                            address30 = FAILURE
                                                        if address30 is not FAILURE:
                                                            elements6.append(address30)
                                                            address34 = FAILURE
                                                            index14 = self._offset
                                                            index15, elements9 = self._offset, []
                                                            address35 = FAILURE
                                                            address35 = self._read__ws()
                                                            if address35 is not FAILURE:
                                                                elements9.append(address35)
                                                                address36 = FAILURE
                                                                address36 = self._read_otherwise()
                                                                if address36 is not FAILURE:
                                                                    elements9.append(address36)
                                                                else:
                                                                    elements9 = None
                                                                    self._offset = index15
                                                            else:
                                                                elements9 = None
                                                                self._offset = index15
                                                            if elements9 is None:
                                                                address34 = FAILURE
                                                            else:
                                                                address34 = TreeNode90(self._input[index15:self._offset], index15, elements9)
                                                                self._offset = self._offset
                                                            if address34 is FAILURE:
                                                                address34 = TreeNode(self._input[index14:index14], index14, [])
                                                                self._offset = index14
                                                            if address34 is not FAILURE:
                                                                elements6.append(address34)
                                                            else:
                                                                elements6 = None
                                                                self._offset = index11
                                                        else:
                                                            elements6 = None
                                                            self._offset = index11
                                                    else:
                                                        elements6 = None
                                                        self._offset = index11
                                                    if elements6 is None:
                                                        address0 = FAILURE
                                                    else:
                                                        address0 = self._actions.if_stmt(self._input, index11, self._offset, elements6)
                                                        self._offset = self._offset
                                                    if address0 is FAILURE:
                                                        self._offset = index1
                                                        index16, elements10 = self._offset, []
                                                        address37 = FAILURE
                                                        chunk13, max13 = None, self._offset + 3
                                                        if max13 <= self._input_size:
                                                            chunk13 = self._input[self._offset:max13]
                                                        if chunk13 == 'for':
                                                            address37 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                            self._offset = self._offset + 3
                                                        else:
                                                            address37 = FAILURE
                                                            if self._offset > self._failure:
                                                                self._failure = self._offset
                                                                self._expected = []
                                                            if self._offset == self._failure:
                                                                self._expected.append('\'for\'')
                                                        if address37 is not FAILURE:
                                                            address38 = FAILURE
                                                            address38 = self._read__()
                                                            if address38 is not FAILURE:
                                                                elements10.append(address38)
                                                                address39 = FAILURE
                                                                chunk14, max14 = None, self._offset + 5
                                                                if max14 <= self._input_size:
                                                                    chunk14 = self._input[self._offset:max14]
                                                                if chunk14 == 'every':
                                                                    address39 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                                                    self._offset = self._offset + 5
                                                                else:
                                                                    address39 = FAILURE
                                                                    if self._offset > self._failure:
                                                                        self._failure = self._offset
                                                                        self._expected = []
                                                                    if self._offset == self._failure:
                                                                        self._expected.append('\'every\'')
                                                                if address39 is not FAILURE:
                                                                    address40 = FAILURE
                                                                    address40 = self._read__()
                                                                    if address40 is not FAILURE:
                                                                        elements10.append(address40)
                                                                        address41 = FAILURE
                                                                        index17 = self._offset
                                                                        address41 = self._read_loop_name()
                                                                        if address41 is FAILURE:
                                                                            address41 = TreeNode(self._input[index17:index17], index17, [])
                                                                            self._offset = index17
                                                                        if address41 is not FAILURE:
                                                                            elements10.append(address41)
                                                                            address42 = FAILURE
                                                                            address42 = self._read__()
                                                                            if address42 is not FAILURE:
                                                                                elements10.append(address42)
                                                                                address43 = FAILURE
                                                                                address43 = self._read_basic_name()
                                                                                if address43 is not FAILURE:
                                                                                    elements10.append(address43)
                                                                                    address44 = FAILURE
                                                                                    address44 = self._read__()
                                                                                    if address44 is not FAILURE:
                                                                                        elements10.append(address44)
                                                                                        address45 = FAILURE
                                                                                        chunk15, max15 = None, self._offset + 4
                                                                                        if max15 <= self._input_size:
                                                                                            chunk15 = self._input[self._offset:max15]
                                                                                        if chunk15 == 'that':
                                                                                            address45 = TreeNode(self._input[self._offset:self._offset + 4], self._offset, [])
                                                                                            self._offset = self._offset + 4
                                                                                        else:
                                                                                            address45 = FAILURE
                                                                                            if self._offset > self._failure:
                                                                                                self._failure = self._offset
                                                                                                self._expected = []
                                                                                            if self._offset == self._failure:
                                                                                                self._expected.append('\'that\'')
                                                                                        if address45 is not FAILURE:
                                                                                            address46 = FAILURE
                                                                                            address46 = self._read__()
                                                                                            if address46 is not FAILURE:
                                                                                                elements10.append(address46)
                                                                                                address47 = FAILURE
                                                                                                address47 = self._read_expression()
                                                                                                if address47 is not FAILURE:
                                                                                                    elements10.append(address47)
                                                                                                    address48 = FAILURE
                                                                                                    address48 = self._read__()
                                                                                                    if address48 is not FAILURE:
                                                                                                        elements10.append(address48)
                                                                                                        address49 = FAILURE
                                                                                                        chunk16, max16 = None, self._offset + 3
                                                                                                        if max16 <= self._input_size:
                                                                                                            chunk16 = self._input[self._offset:max16]
                                                                                                        if chunk16 == 'has':
                                                                                                            address49 = TreeNode(self._input[self._offset:self._offset + 3], self._offset, [])
                                                                                                            self._offset = self._offset + 3
                                                                                                        else:
                                                                                                            address49 = FAILURE
                                                                                                            if self._offset > self._failure:
                                                                                                                self._failure = self._offset
                                                                                                                self._expected = []
                                                                                                            if self._offset == self._failure:
                                                                                                                self._expected.append('\'has\'')
                                                                                                        if address49 is not FAILURE:
                                                                                                            address50 = FAILURE
                                                                                                            address50 = self._read__()
                                                                                                            if address50 is not FAILURE:
                                                                                                                elements10.append(address50)
                                                                                                                address51 = FAILURE
                                                                                                                address51 = self._read_loop_body()
                                                                                                                if address51 is not FAILURE:
                                                                                                                    elements10.append(address51)
                                                                                                                else:
                                                                                                                    elements10 = None
                                                                                                                    self._offset = index16
                                                                                                            else:
                                                                                                                elements10 = None
                                                                                                                self._offset = index16
                                                                                                        else:
                                                                                                            elements10 = None
                                                                                                            self._offset = index16
                                                                                                    else:
                                                                                                        elements10 = None
                                                                                                        self._offset = index16
                                                                                                else:
                                                                                                    elements10 = None
                                                                                                    self._offset = index16
                                                                                            else:
                                                                                                elements10 = None
                                                                                                self._offset = index16
                                                                                        else:
                                                                                            elements10 = None
                                                                                            self._offset = index16
                                                                                    else:
                                                                                        elements10 = None
                                                                                        self._offset = index16
                                                                                else:
                                                                                    elements10 = None
                                                                                    self._offset = index16
                                                                            else:
                                                                                elements10 = None
                                                                                self._offset = index16
                                                                        else:
                                                                            elements10 = None
                                                                            self._offset = index16
                                                                    else:
                                                                        elements10 = None
                                                                        self._offset = index16
                                                                else:
                                                                    elements10 = None
                                                                    self._offset = index16
                                                            else:
                                                                elements10 = None
                                                                self._offset = index16
                                                        else:
                                                            elements10 = None
                                                            self._offset = index16
                                                        if elements10 is None:
                                                            address0 = FAILURE
                                                        else:
                                                            address0 = self._actions.for_every(self._input, index16, self._offset, elements10)
                                                            self._offset = self._offset
                                                        if address0 is FAILURE:
                                                            self._offset = index1
                                                            index18, elements11 = self._offset, []
                                                            address52 = FAILURE
                                                            chunk17, max17 = None, self._offset + 5
                                                            if max17 <= self._input_size:
                                                                chunk17 = self._input[self._offset:max17]
                                                            if chunk17 == 'until':
                                                                address52 = TreeNode(self._input[self._offset:self._offset + 5], self._offset, [])
                                                                self._offset = self._offset + 5
                                                            else:
                                                                address52 = FAILURE
                                                                if self._offset > self._failure:
                                                                    self._failure = self._offset
                                                                    self._expected = []
                                                                if self._offset == self._failure:
                                                                    self._expected.append('\'until\'')
                                                            if address52 is not FAILURE:
                                                                address53 = FAILURE
                                                                address53 = self._read__()
                                                                if address53 is not FAILURE:
                                                                    elements11.append(address53)
                                                                    address54 = FAILURE
                                                                    index19 = self._offset
                                                                    address54 = self._read_loop_name()
                                                                    if address54 is FAILURE:
                                                                        address54 = TreeNode(self._input[index19:index19], index19, [])
                                                                        self._offset = index19
                                                                    if address54 is not FAILURE:
                                                                        elements11.append(address54)
                                                                        address55 = FAILURE
                                                                        address55 = self._read__()
                                                                        if address55 is not FAILURE:
                                                                            elements11.append(address55)
                                                                            address56 = FAILURE
                                                                            address56 = self._read_expression()
                                                                            if address56 is not FAILURE:
                                                                                elements11.append(address56)
                                                                                address57 = FAILURE
                                                                                address57 = self._read__()
                                                                                if address57 is not FAILURE:
                                                                                    elements11.append(address57)
                                                                                    address58 = FAILURE
                                                                                    address58 = self._read_loop_body()
                                                                                    if address58 is not FAILURE:
                                                                                        elements11.append(address58)
                                                                                        address59 = FAILURE
                                                                                        address59 = self._read__ws()
                                                                                        if address59 is not FAILURE:
                                                                                            elements11.append(address59)
                                                                                            address60 = FAILURE
                                                                                            remaining1, index20, elements12, address61 = 0, self._offset, [], True
                                                                                            while address61 is not FAILURE:
                                                                                                index21, elements13 = self._offset, []
                                                                                                address62 = FAILURE
                                                                                                address62 = self._read_except_when()
                                                                                                if address62 is not FAILURE:
                                                                                                    elements13.append(address62)
                                                                                                    address63 = FAILURE
                                                                                                    address63 = self._read__ws()
                                                                                                    if address63 is not FAILURE:
                                                                                                        elements13.append(address63)
                                                                                                    else:
                                                                                                        elements13 = None
                                                                                                        self._offset = index21
                                                                                                else:
                                                                                                    elements13 = None
                                                                                                    self._offset = index21
                                                                                                if elements13 is None:
                                                                                                    address61 = FAILURE
                                                                                                else:
                                                                                                    address61 = TreeNode93(self._input[index21:self._offset], index21, elements13)
                                                                                                    self._offset = self._offset
                                                                                                if address61 is not FAILURE:
                                                                                                    elements12.append(address61)
                                                                                                    remaining1 -= 1
                                                                                            if remaining1 <= 0:
                                                                                                address60 = TreeNode(self._input[index20:self._offset], index20, elements12)
                                                                                                self._offset = self._offset
                                                                                            else:
                                                                                                address60 = FAILURE
                                                                                            if address60 is not FAILURE:
                                                                                                elements11.append(address60)
                                                                                                address64 = FAILURE
                                                                                                index22 = self._offset
                                                                                                address64 = self._read_otherwise()
                                                                                                if address64 is FAILURE:
                                                                                                    address64 = TreeNode(self._input[index22:index22], index22, [])
                                                                                                    self._offset = index22
                                                                                                if address64 is not FAILURE:
                                                                                                    elements11.append(address64)
                                                                                                else:
                                                                                                    elements11 = None
                                                                                                    self._offset = index18
                                                                                            else:
                                                                                                elements11 = None
                                                                                                self._offset = index18
                                                                                        else:
                                                                                            elements11 = None
                                                                                            self._offset = index18
                                                                                    else:
                                                                                        elements11 = None
                                                                                        self._offset = index18
                                                                                else:
                                                                                    elements11 = None
                                                                                    self._offset = index18
                                                                            else:
                                                                                elements11 = None
                                                                                self._offset = index18
                                                                        else:
                                                                            elements11 = None
                                                                            self._offset = index18
                                                                    else:
                                                                        elements11 = None
                                                                        self._offset = index18
                                                                else:
                                                                    elements11 = None
                                                                    self._offset = index18
                                                            else:
                                                                elements11 = None
                                                                self._offset = index18
                                                            if elements11 is None:
                                                                address0 = FAILURE
                                                            else:
                                                                address0 = self._actions.until_do(self._input, index18, self._offset, elements11)
                                                                self._offset = self._offset
                                                            if address0 is FAILURE:
                                                                self._offset = index1
                                                                index23, elements14 = self._offset, []
                                                                address65 = FAILURE
                                                                address65 = self._read_access()
                                                                if address65 is not FAILURE:
                                                                    elements14.append(address65)
                                                                    address66 = FAILURE
                                                                    address66 = self._read__()
                                                                    if address66 is not FAILURE:
                                                                        elements14.append(address66)
                                                                        address67 = FAILURE
                                                                        chunk18, max18 = None, self._offset + 2
                                                                        if max18 <= self._input_size:
                                                                            chunk18 = self._input[self._offset:max18]
                                                                        if chunk18 == '=>':
                                                                            address67 = TreeNode(self._input[self._offset:self._offset + 2], self._offset, [])
                                                                            self._offset = self._offset + 2
                                                                        else:
                                                                            address67 = FAILURE
                                                                            if self._offset > self._failure:
                                                                                self._failure = self._offset
                                                                                self._expected = []
                                                                            if self._offset == self._failure:
                                                                                self._expected.append('\'=>\'')
                                                                        if address67 is not FAILURE:
                                                                            address68 = FAILURE
                                                                            address68 = self._read__()
                                                                            if address68 is not FAILURE:
                                                                                elements14.append(address68)
                                                                                address69 = FAILURE
                                                                                address69 = self._read_modifier_tail()
                                                                                if address69 is not FAILURE:
                                                                                    elements14.append(address69)
                                                                                    address70 = FAILURE
                                                                                    remaining2, index24, elements15, address71 = 0, self._offset, [], True
                                                                                    while address71 is not FAILURE:
                                                                                        address71 = self._read_modifier_call()
                                                                                        if address71 is not FAILURE:
                                                                                            elements15.append(address71)
                                                                                            remaining2 -= 1
                                                                                    if remaining2 <= 0:
                                                                                        address70 = TreeNode(self._input[index24:self._offset], index24, elements15)
                                                                                        self._offset = self._offset
                                                                                    else:
                                                                                        address70 = FAILURE
                                                                                    if address70 is not FAILURE:
                                                                                        elements14.append(address70)
                                                                                    else:
                                                                                        elements14 = None
                                                                                        self._offset = index23
                                                                                else:
                                                                                    elements14 = None
                                                                                    self._offset = index23
                                                                            else:
                                                                                elements14 = None
                                                                                self._offset = index23
                                                                        else:
                                                                            elements14 = None
                                                                            self._offset = index23
                                                                    else:
                                                                        elements14 = None
                                                                        self._offset = index23
                                                                else:
                                                                    elements14 = None
                                                                    self._offset = index23
                                                                if elements14 is None:
                                                                    address0 = FAILURE
                                                                else:
                                                                    address0 = self._actions.modify_and_assign(self._input, index23, self._offset, elements14)
                                                                    self._offset = self._offset
                                                                if address0 is FAILURE:
                                                                    self._offset = index1
                                                                    index25, elements16 = self._offset, []
                                                                    address72 = FAILURE
                                                                    address72 = self._read_access()
                                                                    if address72 is not FAILURE:
                                                                        elements16.append(address72)
                                                                        address73 = FAILURE
                                                                        address73 = self._read__()
                                                                        if address73 is not FAILURE:
                                                                            elements16.append(address73)
                                                                            address74 = FAILURE
                                                                            address74 = self._read_assign_op()
                                                                            if address74 is not FAILURE:
                                                                                elements16.append(address74)
                                                                                address75 = FAILURE
                                                                                address75 = self._read__ws()
                                                                                if address75 is not FAILURE:
                                                                                    elements16.append(address75)
                                                                                    address76 = FAILURE
                                                                                    address76 = self._read_expression()
                                                                                    if address76 is not FAILURE:
                                                                                        elements16.append(address76)
                                                                                    else:
                                                                                        elements16 = None
                                                                                        self._offset = index25
                                                                                else:
                                                                                    elements16 = None
                                                                                    self._offset = index25
                                                                            else:
                                                                                elements16 = None
                                                                                self._offset = index25
                                                                        else:
                                                                            elements16 = None
                                                                            self._offset = index25
                                                                    else:
                                                                        elements16 = None
                                                                        self._offset = index25
                                                                    if elements16 is None:
                                                                        address0 = FAILURE
                                                                    else:
                                                                        address0 = self._actions.assignment(self._input, index25, self._offset, elements16)
                                                                        self._offset = self._offset
                                                                    if address0 is FAILURE:
                                                                        self._offset = index1
                                                                        index26, elements17 = self._offset, []
                                                                        address77 = FAILURE
                                                                        address77 = self._read_expression()
                                                                        if address77 is not FAILURE:
                                                                            elements17.append(address77)
                                                                            address78 = FAILURE
                                                                            address78 = self._read__()
                                                                            if address78 is not FAILURE:
                                                                                elements17.append(address78)
                                                                                address79 = FAILURE
                                                                                address79 = self._read_eos()
                                                                                if address79 is not FAILURE:
                                                                                    elements17.append(address79)
                                                                                else:
                                                                                    elements17 = None
                                                                                    self._offset = index26
                                                                            else:
                                                                                elements17 = None
                                                                                self._offset = index26
                                                                        else:
                                                                            elements17 = None
                                                                            self._offset = index26
                                                                        if elements17 is None:
                                                                            address0 = FAILURE
                                                                        else:
                                                                            address0 = TreeNode96(self._input[index26:self._offset], index26, elements17)
                                                                            self._offset = self._offset
                                                                        if address0 is FAILURE:
                                                                            self._offset = index1
        self._cache['statement'][index0] = (address0, self._offset)
        return address0


class Parser(Grammar):
    def __init__(self, input, actions, types):
        self._input = input
        self._input_size = len(input)
        self._actions = actions
        self._types = types
        self._offset = 0
        self._cache = defaultdict(dict)
        self._failure = 0
        self._expected = []

    def parse(self):
        tree = self._read_start()
        if tree is not FAILURE and self._offset == self._input_size:
            return tree
        if not self._expected:
            self._failure = self._offset
            self._expected.append('<EOF>')
        raise ParseError(format_error(self._input, self._failure, self._expected))


def format_error(input, offset, expected):
    lines, line_no, position = input.split('\n'), 0, 0
    while position <= offset:
        position += len(lines[line_no]) + 1
        line_no += 1
    message, line = 'Line ' + str(line_no) + ': expected ' + ', '.join(expected) + '\n', lines[line_no - 1]
    message += line + '\n'
    position -= len(line) + 1
    message += ' ' * (offset - position)
    return message + '^'

def parse(input, actions=None, types=None):
    parser = Parser(input, actions, types)
    return parser.parse()
# This file was generated from grammar.peg # See http://canopy.jcoglan.com/ for documentation.