# --------------------------------------------------
# THIS IS A GENERATED FILE. DO NOT MODIFY.
# Changes will be overwritten by the generation script.
#    Generated by: sbin/generate_parser.py
#    Grammar file: src/hgvs/_data/hgvs.pymeta
#    Grammar hash: 3a6ac8d6d2dda7f4a178efe0081659e0
# Parsley version: 1.3
#  Python version: 3.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0]
# --------------------------------------------------


def createParserClass(GrammarBase, ruleGlobals):
    if ruleGlobals is None:
        ruleGlobals = {}

    class Grammar(GrammarBase):
        def rule_hgvs_variant(self):
            _locals = {"self": self}
            self.locals["hgvs_variant"] = _locals

            def _G_or_1():
                self._trace("", (697, 707), self.input.position)
                _G_apply_2, lastError = self._apply(self.rule_g_variant, "g_variant", [])
                self.considerError(lastError, None)
                return (_G_apply_2, self.currentError)

            def _G_or_3():
                self._trace("", (709, 719), self.input.position)
                _G_apply_4, lastError = self._apply(self.rule_m_variant, "m_variant", [])
                self.considerError(lastError, None)
                return (_G_apply_4, self.currentError)

            def _G_or_5():
                self._trace("", (721, 731), self.input.position)
                _G_apply_6, lastError = self._apply(self.rule_c_variant, "c_variant", [])
                self.considerError(lastError, None)
                return (_G_apply_6, self.currentError)

            def _G_or_7():
                self._trace("", (733, 743), self.input.position)
                _G_apply_8, lastError = self._apply(self.rule_n_variant, "n_variant", [])
                self.considerError(lastError, None)
                return (_G_apply_8, self.currentError)

            def _G_or_9():
                self._trace("", (746, 756), self.input.position)
                _G_apply_10, lastError = self._apply(self.rule_r_variant, "r_variant", [])
                self.considerError(lastError, None)
                return (_G_apply_10, self.currentError)

            def _G_or_11():
                self._trace("", (758, 768), self.input.position)
                _G_apply_12, lastError = self._apply(self.rule_p_variant, "p_variant", [])
                self.considerError(lastError, None)
                return (_G_apply_12, self.currentError)

            _G_or_13, lastError = self._or([_G_or_1, _G_or_3, _G_or_5, _G_or_7, _G_or_9, _G_or_11])
            self.considerError(lastError, "hgvs_variant")
            return (_G_or_13, self.currentError)

        def rule_c_variant(self):
            _locals = {"self": self}
            self.locals["c_variant"] = _locals
            self._trace("", (781, 786), self.input.position)
            _G_apply_14, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "c_variant")
            _locals["ac"] = _G_apply_14
            self._trace("", (789, 803), self.input.position)
            _G_apply_15, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "c_variant")
            _locals["gene"] = _G_apply_15
            self._trace("", (808, 812), self.input.position)
            _G_exactly_16, lastError = self.exactly(":")
            self.considerError(lastError, "c_variant")
            self._trace("", (812, 816), self.input.position)
            _G_exactly_17, lastError = self.exactly("c")
            self.considerError(lastError, "c_variant")
            _locals["type"] = _G_exactly_17
            self._trace("", (821, 825), self.input.position)
            _G_exactly_18, lastError = self.exactly(".")
            self.considerError(lastError, "c_variant")
            self._trace("", (825, 835), self.input.position)
            _G_apply_19, lastError = self._apply(self.rule_c_posedit, "c_posedit", [])
            self.considerError(lastError, "c_variant")
            _locals["posedit"] = _G_apply_19
            _G_python_21, lastError = eval(self._G_expr_20, self.globals, _locals), None
            self.considerError(lastError, "c_variant")
            return (_G_python_21, self.currentError)

        def rule_g_variant(self):
            _locals = {"self": self}
            self.locals["g_variant"] = _locals
            self._trace("", (941, 946), self.input.position)
            _G_apply_22, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "g_variant")
            _locals["ac"] = _G_apply_22
            self._trace("", (949, 963), self.input.position)
            _G_apply_23, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "g_variant")
            _locals["gene"] = _G_apply_23
            self._trace("", (968, 972), self.input.position)
            _G_exactly_24, lastError = self.exactly(":")
            self.considerError(lastError, "g_variant")
            self._trace("", (972, 976), self.input.position)
            _G_exactly_25, lastError = self.exactly("g")
            self.considerError(lastError, "g_variant")
            _locals["type"] = _G_exactly_25
            self._trace("", (981, 985), self.input.position)
            _G_exactly_26, lastError = self.exactly(".")
            self.considerError(lastError, "g_variant")
            self._trace("", (985, 995), self.input.position)
            _G_apply_27, lastError = self._apply(self.rule_g_posedit, "g_posedit", [])
            self.considerError(lastError, "g_variant")
            _locals["posedit"] = _G_apply_27
            _G_python_28, lastError = eval(self._G_expr_20, self.globals, _locals), None
            self.considerError(lastError, "g_variant")
            return (_G_python_28, self.currentError)

        def rule_m_variant(self):
            _locals = {"self": self}
            self.locals["m_variant"] = _locals
            self._trace("", (1101, 1106), self.input.position)
            _G_apply_29, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "m_variant")
            _locals["ac"] = _G_apply_29
            self._trace("", (1109, 1123), self.input.position)
            _G_apply_30, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "m_variant")
            _locals["gene"] = _G_apply_30
            self._trace("", (1128, 1132), self.input.position)
            _G_exactly_31, lastError = self.exactly(":")
            self.considerError(lastError, "m_variant")
            self._trace("", (1132, 1136), self.input.position)
            _G_exactly_32, lastError = self.exactly("m")
            self.considerError(lastError, "m_variant")
            _locals["type"] = _G_exactly_32
            self._trace("", (1141, 1145), self.input.position)
            _G_exactly_33, lastError = self.exactly(".")
            self.considerError(lastError, "m_variant")
            self._trace("", (1145, 1155), self.input.position)
            _G_apply_34, lastError = self._apply(self.rule_m_posedit, "m_posedit", [])
            self.considerError(lastError, "m_variant")
            _locals["posedit"] = _G_apply_34
            _G_python_35, lastError = eval(self._G_expr_20, self.globals, _locals), None
            self.considerError(lastError, "m_variant")
            return (_G_python_35, self.currentError)

        def rule_n_variant(self):
            _locals = {"self": self}
            self.locals["n_variant"] = _locals
            self._trace("", (1261, 1266), self.input.position)
            _G_apply_36, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "n_variant")
            _locals["ac"] = _G_apply_36
            self._trace("", (1269, 1283), self.input.position)
            _G_apply_37, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "n_variant")
            _locals["gene"] = _G_apply_37
            self._trace("", (1288, 1292), self.input.position)
            _G_exactly_38, lastError = self.exactly(":")
            self.considerError(lastError, "n_variant")
            self._trace("", (1292, 1296), self.input.position)
            _G_exactly_39, lastError = self.exactly("n")
            self.considerError(lastError, "n_variant")
            _locals["type"] = _G_exactly_39
            self._trace("", (1301, 1305), self.input.position)
            _G_exactly_40, lastError = self.exactly(".")
            self.considerError(lastError, "n_variant")
            self._trace("", (1305, 1315), self.input.position)
            _G_apply_41, lastError = self._apply(self.rule_n_posedit, "n_posedit", [])
            self.considerError(lastError, "n_variant")
            _locals["posedit"] = _G_apply_41
            _G_python_42, lastError = eval(self._G_expr_20, self.globals, _locals), None
            self.considerError(lastError, "n_variant")
            return (_G_python_42, self.currentError)

        def rule_p_variant(self):
            _locals = {"self": self}
            self.locals["p_variant"] = _locals
            self._trace("", (1421, 1426), self.input.position)
            _G_apply_43, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "p_variant")
            _locals["ac"] = _G_apply_43
            self._trace("", (1429, 1443), self.input.position)
            _G_apply_44, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "p_variant")
            _locals["gene"] = _G_apply_44
            self._trace("", (1448, 1452), self.input.position)
            _G_exactly_45, lastError = self.exactly(":")
            self.considerError(lastError, "p_variant")
            self._trace("", (1452, 1456), self.input.position)
            _G_exactly_46, lastError = self.exactly("p")
            self.considerError(lastError, "p_variant")
            _locals["type"] = _G_exactly_46
            self._trace("", (1461, 1465), self.input.position)
            _G_exactly_47, lastError = self.exactly(".")
            self.considerError(lastError, "p_variant")
            self._trace("", (1465, 1475), self.input.position)
            _G_apply_48, lastError = self._apply(self.rule_p_posedit, "p_posedit", [])
            self.considerError(lastError, "p_variant")
            _locals["posedit"] = _G_apply_48
            _G_python_49, lastError = eval(self._G_expr_20, self.globals, _locals), None
            self.considerError(lastError, "p_variant")
            return (_G_python_49, self.currentError)

        def rule_r_variant(self):
            _locals = {"self": self}
            self.locals["r_variant"] = _locals
            self._trace("", (1581, 1586), self.input.position)
            _G_apply_50, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "r_variant")
            _locals["ac"] = _G_apply_50
            self._trace("", (1589, 1603), self.input.position)
            _G_apply_51, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "r_variant")
            _locals["gene"] = _G_apply_51
            self._trace("", (1608, 1612), self.input.position)
            _G_exactly_52, lastError = self.exactly(":")
            self.considerError(lastError, "r_variant")
            self._trace("", (1612, 1616), self.input.position)
            _G_exactly_53, lastError = self.exactly("r")
            self.considerError(lastError, "r_variant")
            _locals["type"] = _G_exactly_53
            self._trace("", (1621, 1625), self.input.position)
            _G_exactly_54, lastError = self.exactly(".")
            self.considerError(lastError, "r_variant")
            self._trace("", (1625, 1635), self.input.position)
            _G_apply_55, lastError = self._apply(self.rule_r_posedit, "r_posedit", [])
            self.considerError(lastError, "r_variant")
            _locals["posedit"] = _G_apply_55
            _G_python_56, lastError = eval(self._G_expr_20, self.globals, _locals), None
            self.considerError(lastError, "r_variant")
            return (_G_python_56, self.currentError)

        def rule_hgvs_position(self):
            _locals = {"self": self}
            self.locals["hgvs_position"] = _locals

            def _G_or_57():
                self._trace("", (1920, 1936), self.input.position)
                _G_apply_58, lastError = self._apply(
                    self.rule_g_hgvs_position, "g_hgvs_position", []
                )
                self.considerError(lastError, None)
                return (_G_apply_58, self.currentError)

            def _G_or_59():
                self._trace("", (1938, 1954), self.input.position)
                _G_apply_60, lastError = self._apply(
                    self.rule_m_hgvs_position, "m_hgvs_position", []
                )
                self.considerError(lastError, None)
                return (_G_apply_60, self.currentError)

            def _G_or_61():
                self._trace("", (1956, 1972), self.input.position)
                _G_apply_62, lastError = self._apply(
                    self.rule_c_hgvs_position, "c_hgvs_position", []
                )
                self.considerError(lastError, None)
                return (_G_apply_62, self.currentError)

            def _G_or_63():
                self._trace("", (1974, 1990), self.input.position)
                _G_apply_64, lastError = self._apply(
                    self.rule_n_hgvs_position, "n_hgvs_position", []
                )
                self.considerError(lastError, None)
                return (_G_apply_64, self.currentError)

            def _G_or_65():
                self._trace("", (1992, 2008), self.input.position)
                _G_apply_66, lastError = self._apply(
                    self.rule_r_hgvs_position, "r_hgvs_position", []
                )
                self.considerError(lastError, None)
                return (_G_apply_66, self.currentError)

            def _G_or_67():
                self._trace("", (2010, 2026), self.input.position)
                _G_apply_68, lastError = self._apply(
                    self.rule_p_hgvs_position, "p_hgvs_position", []
                )
                self.considerError(lastError, None)
                return (_G_apply_68, self.currentError)

            _G_or_69, lastError = self._or(
                [_G_or_57, _G_or_59, _G_or_61, _G_or_63, _G_or_65, _G_or_67]
            )
            self.considerError(lastError, "hgvs_position")
            return (_G_or_69, self.currentError)

        def rule_c_hgvs_position(self):
            _locals = {"self": self}
            self.locals["c_hgvs_position"] = _locals
            self._trace("", (2045, 2050), self.input.position)
            _G_apply_70, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "c_hgvs_position")
            _locals["ac"] = _G_apply_70
            self._trace("", (2053, 2067), self.input.position)
            _G_apply_71, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "c_hgvs_position")
            _locals["gene"] = _G_apply_71
            self._trace("", (2072, 2076), self.input.position)
            _G_exactly_72, lastError = self.exactly(":")
            self.considerError(lastError, "c_hgvs_position")
            self._trace("", (2076, 2080), self.input.position)
            _G_exactly_73, lastError = self.exactly("c")
            self.considerError(lastError, "c_hgvs_position")
            _locals["type"] = _G_exactly_73
            self._trace("", (2085, 2089), self.input.position)
            _G_exactly_74, lastError = self.exactly(".")
            self.considerError(lastError, "c_hgvs_position")
            self._trace("", (2089, 2100), self.input.position)
            _G_apply_75, lastError = self._apply(self.rule_c_interval, "c_interval", [])
            self.considerError(lastError, "c_hgvs_position")
            _locals["pos"] = _G_apply_75
            _G_python_77, lastError = eval(self._G_expr_76, self.globals, _locals), None
            self.considerError(lastError, "c_hgvs_position")
            return (_G_python_77, self.currentError)

        def rule_g_hgvs_position(self):
            _locals = {"self": self}
            self.locals["g_hgvs_position"] = _locals
            self._trace("", (2194, 2199), self.input.position)
            _G_apply_78, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "g_hgvs_position")
            _locals["ac"] = _G_apply_78
            self._trace("", (2202, 2216), self.input.position)
            _G_apply_79, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "g_hgvs_position")
            _locals["gene"] = _G_apply_79
            self._trace("", (2221, 2225), self.input.position)
            _G_exactly_80, lastError = self.exactly(":")
            self.considerError(lastError, "g_hgvs_position")
            self._trace("", (2225, 2229), self.input.position)
            _G_exactly_81, lastError = self.exactly("g")
            self.considerError(lastError, "g_hgvs_position")
            _locals["type"] = _G_exactly_81
            self._trace("", (2234, 2238), self.input.position)
            _G_exactly_82, lastError = self.exactly(".")
            self.considerError(lastError, "g_hgvs_position")
            self._trace("", (2238, 2249), self.input.position)
            _G_apply_83, lastError = self._apply(self.rule_g_interval, "g_interval", [])
            self.considerError(lastError, "g_hgvs_position")
            _locals["pos"] = _G_apply_83
            _G_python_84, lastError = eval(self._G_expr_76, self.globals, _locals), None
            self.considerError(lastError, "g_hgvs_position")
            return (_G_python_84, self.currentError)

        def rule_m_hgvs_position(self):
            _locals = {"self": self}
            self.locals["m_hgvs_position"] = _locals
            self._trace("", (2343, 2348), self.input.position)
            _G_apply_85, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "m_hgvs_position")
            _locals["ac"] = _G_apply_85
            self._trace("", (2351, 2365), self.input.position)
            _G_apply_86, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "m_hgvs_position")
            _locals["gene"] = _G_apply_86
            self._trace("", (2370, 2374), self.input.position)
            _G_exactly_87, lastError = self.exactly(":")
            self.considerError(lastError, "m_hgvs_position")
            self._trace("", (2374, 2378), self.input.position)
            _G_exactly_88, lastError = self.exactly("m")
            self.considerError(lastError, "m_hgvs_position")
            _locals["type"] = _G_exactly_88
            self._trace("", (2383, 2387), self.input.position)
            _G_exactly_89, lastError = self.exactly(".")
            self.considerError(lastError, "m_hgvs_position")
            self._trace("", (2387, 2398), self.input.position)
            _G_apply_90, lastError = self._apply(self.rule_m_interval, "m_interval", [])
            self.considerError(lastError, "m_hgvs_position")
            _locals["pos"] = _G_apply_90
            _G_python_91, lastError = eval(self._G_expr_76, self.globals, _locals), None
            self.considerError(lastError, "m_hgvs_position")
            return (_G_python_91, self.currentError)

        def rule_n_hgvs_position(self):
            _locals = {"self": self}
            self.locals["n_hgvs_position"] = _locals
            self._trace("", (2492, 2497), self.input.position)
            _G_apply_92, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "n_hgvs_position")
            _locals["ac"] = _G_apply_92
            self._trace("", (2500, 2514), self.input.position)
            _G_apply_93, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "n_hgvs_position")
            _locals["gene"] = _G_apply_93
            self._trace("", (2519, 2523), self.input.position)
            _G_exactly_94, lastError = self.exactly(":")
            self.considerError(lastError, "n_hgvs_position")
            self._trace("", (2523, 2527), self.input.position)
            _G_exactly_95, lastError = self.exactly("n")
            self.considerError(lastError, "n_hgvs_position")
            _locals["type"] = _G_exactly_95
            self._trace("", (2532, 2536), self.input.position)
            _G_exactly_96, lastError = self.exactly(".")
            self.considerError(lastError, "n_hgvs_position")
            self._trace("", (2536, 2547), self.input.position)
            _G_apply_97, lastError = self._apply(self.rule_n_interval, "n_interval", [])
            self.considerError(lastError, "n_hgvs_position")
            _locals["pos"] = _G_apply_97
            _G_python_98, lastError = eval(self._G_expr_76, self.globals, _locals), None
            self.considerError(lastError, "n_hgvs_position")
            return (_G_python_98, self.currentError)

        def rule_p_hgvs_position(self):
            _locals = {"self": self}
            self.locals["p_hgvs_position"] = _locals
            self._trace("", (2641, 2646), self.input.position)
            _G_apply_99, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "p_hgvs_position")
            _locals["ac"] = _G_apply_99
            self._trace("", (2649, 2663), self.input.position)
            _G_apply_100, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "p_hgvs_position")
            _locals["gene"] = _G_apply_100
            self._trace("", (2668, 2672), self.input.position)
            _G_exactly_101, lastError = self.exactly(":")
            self.considerError(lastError, "p_hgvs_position")
            self._trace("", (2672, 2676), self.input.position)
            _G_exactly_102, lastError = self.exactly("p")
            self.considerError(lastError, "p_hgvs_position")
            _locals["type"] = _G_exactly_102
            self._trace("", (2681, 2685), self.input.position)
            _G_exactly_103, lastError = self.exactly(".")
            self.considerError(lastError, "p_hgvs_position")
            self._trace("", (2685, 2696), self.input.position)
            _G_apply_104, lastError = self._apply(self.rule_p_interval, "p_interval", [])
            self.considerError(lastError, "p_hgvs_position")
            _locals["pos"] = _G_apply_104
            _G_python_105, lastError = eval(self._G_expr_76, self.globals, _locals), None
            self.considerError(lastError, "p_hgvs_position")
            return (_G_python_105, self.currentError)

        def rule_r_hgvs_position(self):
            _locals = {"self": self}
            self.locals["r_hgvs_position"] = _locals
            self._trace("", (2790, 2795), self.input.position)
            _G_apply_106, lastError = self._apply(self.rule_accn, "accn", [])
            self.considerError(lastError, "r_hgvs_position")
            _locals["ac"] = _G_apply_106
            self._trace("", (2798, 2812), self.input.position)
            _G_apply_107, lastError = self._apply(self.rule_opt_gene_expr, "opt_gene_expr", [])
            self.considerError(lastError, "r_hgvs_position")
            _locals["gene"] = _G_apply_107
            self._trace("", (2817, 2821), self.input.position)
            _G_exactly_108, lastError = self.exactly(":")
            self.considerError(lastError, "r_hgvs_position")
            self._trace("", (2821, 2825), self.input.position)
            _G_exactly_109, lastError = self.exactly("r")
            self.considerError(lastError, "r_hgvs_position")
            _locals["type"] = _G_exactly_109
            self._trace("", (2830, 2834), self.input.position)
            _G_exactly_110, lastError = self.exactly(".")
            self.considerError(lastError, "r_hgvs_position")
            self._trace("", (2834, 2845), self.input.position)
            _G_apply_111, lastError = self._apply(self.rule_r_interval, "r_interval", [])
            self.considerError(lastError, "r_hgvs_position")
            _locals["pos"] = _G_apply_111
            _G_python_112, lastError = eval(self._G_expr_76, self.globals, _locals), None
            self.considerError(lastError, "r_hgvs_position")
            return (_G_python_112, self.currentError)

        def rule_c_typed_posedit(self):
            _locals = {"self": self}
            self.locals["c_typed_posedit"] = _locals
            self._trace("", (3249, 3253), self.input.position)
            _G_exactly_113, lastError = self.exactly("c")
            self.considerError(lastError, "c_typed_posedit")
            _locals["type"] = _G_exactly_113
            self._trace("", (3258, 3262), self.input.position)
            _G_exactly_114, lastError = self.exactly(".")
            self.considerError(lastError, "c_typed_posedit")
            self._trace("", (3262, 3272), self.input.position)
            _G_apply_115, lastError = self._apply(self.rule_c_posedit, "c_posedit", [])
            self.considerError(lastError, "c_typed_posedit")
            _locals["posedit"] = _G_apply_115
            _G_python_117, lastError = eval(self._G_expr_116, self.globals, _locals), None
            self.considerError(lastError, "c_typed_posedit")
            return (_G_python_117, self.currentError)

        def rule_g_typed_posedit(self):
            _locals = {"self": self}
            self.locals["g_typed_posedit"] = _locals
            self._trace("", (3357, 3361), self.input.position)
            _G_exactly_118, lastError = self.exactly("g")
            self.considerError(lastError, "g_typed_posedit")
            _locals["type"] = _G_exactly_118
            self._trace("", (3366, 3370), self.input.position)
            _G_exactly_119, lastError = self.exactly(".")
            self.considerError(lastError, "g_typed_posedit")
            self._trace("", (3370, 3380), self.input.position)
            _G_apply_120, lastError = self._apply(self.rule_g_posedit, "g_posedit", [])
            self.considerError(lastError, "g_typed_posedit")
            _locals["posedit"] = _G_apply_120
            _G_python_121, lastError = eval(self._G_expr_116, self.globals, _locals), None
            self.considerError(lastError, "g_typed_posedit")
            return (_G_python_121, self.currentError)

        def rule_m_typed_posedit(self):
            _locals = {"self": self}
            self.locals["m_typed_posedit"] = _locals
            self._trace("", (3465, 3469), self.input.position)
            _G_exactly_122, lastError = self.exactly("m")
            self.considerError(lastError, "m_typed_posedit")
            _locals["type"] = _G_exactly_122
            self._trace("", (3474, 3478), self.input.position)
            _G_exactly_123, lastError = self.exactly(".")
            self.considerError(lastError, "m_typed_posedit")
            self._trace("", (3478, 3488), self.input.position)
            _G_apply_124, lastError = self._apply(self.rule_m_posedit, "m_posedit", [])
            self.considerError(lastError, "m_typed_posedit")
            _locals["posedit"] = _G_apply_124
            _G_python_125, lastError = eval(self._G_expr_116, self.globals, _locals), None
            self.considerError(lastError, "m_typed_posedit")
            return (_G_python_125, self.currentError)

        def rule_n_typed_posedit(self):
            _locals = {"self": self}
            self.locals["n_typed_posedit"] = _locals
            self._trace("", (3573, 3577), self.input.position)
            _G_exactly_126, lastError = self.exactly("n")
            self.considerError(lastError, "n_typed_posedit")
            _locals["type"] = _G_exactly_126
            self._trace("", (3582, 3586), self.input.position)
            _G_exactly_127, lastError = self.exactly(".")
            self.considerError(lastError, "n_typed_posedit")
            self._trace("", (3586, 3596), self.input.position)
            _G_apply_128, lastError = self._apply(self.rule_n_posedit, "n_posedit", [])
            self.considerError(lastError, "n_typed_posedit")
            _locals["posedit"] = _G_apply_128
            _G_python_129, lastError = eval(self._G_expr_116, self.globals, _locals), None
            self.considerError(lastError, "n_typed_posedit")
            return (_G_python_129, self.currentError)

        def rule_p_typed_posedit(self):
            _locals = {"self": self}
            self.locals["p_typed_posedit"] = _locals
            self._trace("", (3681, 3685), self.input.position)
            _G_exactly_130, lastError = self.exactly("p")
            self.considerError(lastError, "p_typed_posedit")
            _locals["type"] = _G_exactly_130
            self._trace("", (3690, 3694), self.input.position)
            _G_exactly_131, lastError = self.exactly(".")
            self.considerError(lastError, "p_typed_posedit")
            self._trace("", (3694, 3704), self.input.position)
            _G_apply_132, lastError = self._apply(self.rule_p_posedit, "p_posedit", [])
            self.considerError(lastError, "p_typed_posedit")
            _locals["posedit"] = _G_apply_132
            _G_python_133, lastError = eval(self._G_expr_116, self.globals, _locals), None
            self.considerError(lastError, "p_typed_posedit")
            return (_G_python_133, self.currentError)

        def rule_r_typed_posedit(self):
            _locals = {"self": self}
            self.locals["r_typed_posedit"] = _locals
            self._trace("", (3789, 3793), self.input.position)
            _G_exactly_134, lastError = self.exactly("r")
            self.considerError(lastError, "r_typed_posedit")
            _locals["type"] = _G_exactly_134
            self._trace("", (3798, 3802), self.input.position)
            _G_exactly_135, lastError = self.exactly(".")
            self.considerError(lastError, "r_typed_posedit")
            self._trace("", (3802, 3812), self.input.position)
            _G_apply_136, lastError = self._apply(self.rule_r_posedit, "r_posedit", [])
            self.considerError(lastError, "r_typed_posedit")
            _locals["posedit"] = _G_apply_136
            _G_python_137, lastError = eval(self._G_expr_116, self.globals, _locals), None
            self.considerError(lastError, "r_typed_posedit")
            return (_G_python_137, self.currentError)

        def rule_c_posedit(self):
            _locals = {"self": self}
            self.locals["c_posedit"] = _locals
            self._trace("", (4010, 4021), self.input.position)
            _G_apply_138, lastError = self._apply(self.rule_c_interval, "c_interval", [])
            self.considerError(lastError, "c_posedit")
            _locals["pos"] = _G_apply_138
            self._trace("", (4025, 4034), self.input.position)
            _G_apply_139, lastError = self._apply(self.rule_dna_edit, "dna_edit", [])
            self.considerError(lastError, "c_posedit")
            _locals["edit"] = _G_apply_139
            _G_python_141, lastError = eval(self._G_expr_140, self.globals, _locals), None
            self.considerError(lastError, "c_posedit")
            return (_G_python_141, self.currentError)

        def rule_g_posedit(self):
            _locals = {"self": self}
            self.locals["g_posedit"] = _locals
            self._trace("", (4094, 4105), self.input.position)
            _G_apply_142, lastError = self._apply(self.rule_g_interval, "g_interval", [])
            self.considerError(lastError, "g_posedit")
            _locals["pos"] = _G_apply_142
            self._trace("", (4109, 4118), self.input.position)
            _G_apply_143, lastError = self._apply(self.rule_dna_edit, "dna_edit", [])
            self.considerError(lastError, "g_posedit")
            _locals["edit"] = _G_apply_143
            _G_python_144, lastError = eval(self._G_expr_140, self.globals, _locals), None
            self.considerError(lastError, "g_posedit")
            return (_G_python_144, self.currentError)

        def rule_m_posedit(self):
            _locals = {"self": self}
            self.locals["m_posedit"] = _locals
            self._trace("", (4178, 4189), self.input.position)
            _G_apply_145, lastError = self._apply(self.rule_m_interval, "m_interval", [])
            self.considerError(lastError, "m_posedit")
            _locals["pos"] = _G_apply_145
            self._trace("", (4193, 4202), self.input.position)
            _G_apply_146, lastError = self._apply(self.rule_dna_edit, "dna_edit", [])
            self.considerError(lastError, "m_posedit")
            _locals["edit"] = _G_apply_146
            _G_python_147, lastError = eval(self._G_expr_140, self.globals, _locals), None
            self.considerError(lastError, "m_posedit")
            return (_G_python_147, self.currentError)

        def rule_n_posedit(self):
            _locals = {"self": self}
            self.locals["n_posedit"] = _locals
            self._trace("", (4262, 4273), self.input.position)
            _G_apply_148, lastError = self._apply(self.rule_n_interval, "n_interval", [])
            self.considerError(lastError, "n_posedit")
            _locals["pos"] = _G_apply_148
            self._trace("", (4277, 4286), self.input.position)
            _G_apply_149, lastError = self._apply(self.rule_dna_edit, "dna_edit", [])
            self.considerError(lastError, "n_posedit")
            _locals["edit"] = _G_apply_149
            _G_python_150, lastError = eval(self._G_expr_140, self.globals, _locals), None
            self.considerError(lastError, "n_posedit")
            return (_G_python_150, self.currentError)

        def rule_r_posedit(self):
            _locals = {"self": self}
            self.locals["r_posedit"] = _locals

            def _G_or_151():
                self._trace("", (4348, 4358), self.input.position)
                _G_apply_152, lastError = self._apply(self.rule_r_interval, "r_interval", [])
                self.considerError(lastError, None)
                _locals["pos"] = _G_apply_152
                self._trace("", (4362, 4371), self.input.position)
                _G_apply_153, lastError = self._apply(self.rule_rna_edit, "rna_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_153
                _G_python_154, lastError = eval(self._G_expr_140, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_154, self.currentError)

            def _G_or_155():
                self._trace("", (4427, 4430), self.input.position)
                _G_exactly_156, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (4430, 4441), self.input.position)
                _G_apply_157, lastError = self._apply(self.rule_r_interval, "r_interval", [])
                self.considerError(lastError, None)
                _locals["pos"] = _G_apply_157
                self._trace("", (4445, 4454), self.input.position)
                _G_apply_158, lastError = self._apply(self.rule_rna_edit, "rna_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_158
                self._trace("", (4459, 4463), self.input.position)
                _G_exactly_159, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_161, lastError = eval(self._G_expr_160, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_161, self.currentError)

            _G_or_162, lastError = self._or([_G_or_151, _G_or_155])
            self.considerError(lastError, "r_posedit")
            return (_G_or_162, self.currentError)

        def rule_p_posedit(self):
            _locals = {"self": self}
            self.locals["p_posedit"] = _locals

            def _G_or_163():
                self._trace("", (4540, 4550), self.input.position)
                _G_apply_164, lastError = self._apply(self.rule_p_interval, "p_interval", [])
                self.considerError(lastError, None)
                _locals["pos"] = _G_apply_164
                self._trace("", (4554, 4563), self.input.position)
                _G_apply_165, lastError = self._apply(self.rule_pro_edit, "pro_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_165
                _G_python_166, lastError = eval(self._G_expr_140, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_166, self.currentError)

            def _G_or_167():
                self._trace("", (4619, 4622), self.input.position)
                _G_exactly_168, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (4622, 4633), self.input.position)
                _G_apply_169, lastError = self._apply(self.rule_p_interval, "p_interval", [])
                self.considerError(lastError, None)
                _locals["pos"] = _G_apply_169
                self._trace("", (4637, 4646), self.input.position)
                _G_apply_170, lastError = self._apply(self.rule_pro_edit, "pro_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_170
                self._trace("", (4651, 4655), self.input.position)
                _G_exactly_171, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_172, lastError = eval(self._G_expr_160, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_172, self.currentError)

            def _G_or_173():
                self._trace("", (4720, 4738), self.input.position)
                _G_apply_174, lastError = self._apply(
                    self.rule_p_posedit_special, "p_posedit_special", []
                )
                self.considerError(lastError, None)
                return (_G_apply_174, self.currentError)

            _G_or_175, lastError = self._or([_G_or_163, _G_or_167, _G_or_173])
            self.considerError(lastError, "p_posedit")
            return (_G_or_175, self.currentError)

        def rule_p_posedit_special(self):
            _locals = {"self": self}
            self.locals["p_posedit_special"] = _locals

            def _G_or_176():
                self._trace("", (4758, 4769), self.input.position)
                _G_exactly_177, lastError = self.exactly("=")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_177
                _G_python_179, lastError = eval(self._G_expr_178, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_179, self.currentError)

            def _G_or_180():
                self._trace("", (4831, 4835), self.input.position)
                _G_exactly_181, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (4835, 4839), self.input.position)
                _G_exactly_182, lastError = self.exactly("=")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_182
                self._trace("", (4841, 4845), self.input.position)
                _G_exactly_183, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_185, lastError = eval(self._G_expr_184, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_185, self.currentError)

            def _G_or_186():
                self._trace("", (4904, 4908), self.input.position)
                _G_exactly_187, lastError = self.exactly("0")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_187
                self._trace("", (4910, 4914), self.input.position)
                _G_exactly_188, lastError = self.exactly("?")
                self.considerError(lastError, None)
                _G_python_189, lastError = eval(self._G_expr_184, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_189, self.currentError)

            def _G_or_190():
                self._trace("", (4973, 4977), self.input.position)
                _G_exactly_191, lastError = self.exactly("0")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_191
                _G_python_192, lastError = eval(self._G_expr_178, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_192, self.currentError)

            def _G_or_193():
                self._trace("", (5039, 5043), self.input.position)
                _G_exactly_194, lastError = self.exactly("?")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_194
                _G_python_195, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_195, self.currentError)

            _G_or_196, lastError = self._or([_G_or_176, _G_or_180, _G_or_186, _G_or_190, _G_or_193])
            self.considerError(lastError, "p_posedit_special")
            return (_G_or_196, self.currentError)

        def rule_dna_edit_mu(self):
            _locals = {"self": self}
            self.locals["dna_edit_mu"] = _locals

            def _G_or_197():
                self._trace("", (5394, 5403), self.input.position)
                _G_apply_198, lastError = self._apply(self.rule_dna_edit, "dna_edit", [])
                self.considerError(lastError, None)
                return (_G_apply_198, self.currentError)

            def _G_or_199():
                self._trace("", (5405, 5409), self.input.position)
                _G_exactly_200, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (5409, 5418), self.input.position)
                _G_apply_201, lastError = self._apply(self.rule_dna_edit, "dna_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_201
                self._trace("", (5423, 5427), self.input.position)
                _G_exactly_202, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_204, lastError = eval(self._G_expr_203, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_204, self.currentError)

            _G_or_205, lastError = self._or([_G_or_197, _G_or_199])
            self.considerError(lastError, "dna_edit_mu")
            return (_G_or_205, self.currentError)

        def rule_dna_edit(self):
            _locals = {"self": self}
            self.locals["dna_edit"] = _locals

            def _G_or_206():
                self._trace("", (5465, 5475), self.input.position)
                _G_apply_207, lastError = self._apply(self.rule_dna_ident, "dna_ident", [])
                self.considerError(lastError, None)
                return (_G_apply_207, self.currentError)

            def _G_or_208():
                self._trace("", (5477, 5487), self.input.position)
                _G_apply_209, lastError = self._apply(self.rule_dna_subst, "dna_subst", [])
                self.considerError(lastError, None)
                return (_G_apply_209, self.currentError)

            def _G_or_210():
                self._trace("", (5489, 5500), self.input.position)
                _G_apply_211, lastError = self._apply(self.rule_dna_delins, "dna_delins", [])
                self.considerError(lastError, None)
                return (_G_apply_211, self.currentError)

            def _G_or_212():
                self._trace("", (5502, 5510), self.input.position)
                _G_apply_213, lastError = self._apply(self.rule_dna_ins, "dna_ins", [])
                self.considerError(lastError, None)
                return (_G_apply_213, self.currentError)

            def _G_or_214():
                self._trace("", (5512, 5520), self.input.position)
                _G_apply_215, lastError = self._apply(self.rule_dna_del, "dna_del", [])
                self.considerError(lastError, None)
                return (_G_apply_215, self.currentError)

            def _G_or_216():
                self._trace("", (5522, 5530), self.input.position)
                _G_apply_217, lastError = self._apply(self.rule_dna_dup, "dna_dup", [])
                self.considerError(lastError, None)
                return (_G_apply_217, self.currentError)

            def _G_or_218():
                self._trace("", (5532, 5540), self.input.position)
                _G_apply_219, lastError = self._apply(self.rule_dna_inv, "dna_inv", [])
                self.considerError(lastError, None)
                return (_G_apply_219, self.currentError)

            def _G_or_220():
                self._trace("", (5542, 5550), self.input.position)
                _G_apply_221, lastError = self._apply(self.rule_dna_con, "dna_con", [])
                self.considerError(lastError, None)
                return (_G_apply_221, self.currentError)

            def _G_or_222():
                self._trace("", (5552, 5561), self.input.position)
                _G_apply_223, lastError = self._apply(self.rule_dna_copy, "dna_copy", [])
                self.considerError(lastError, None)
                return (_G_apply_223, self.currentError)

            _G_or_224, lastError = self._or(
                [
                    _G_or_206,
                    _G_or_208,
                    _G_or_210,
                    _G_or_212,
                    _G_or_214,
                    _G_or_216,
                    _G_or_218,
                    _G_or_220,
                    _G_or_222,
                ]
            )
            self.considerError(lastError, "dna_edit")
            return (_G_or_224, self.currentError)

        def rule_dna_ident(self):
            _locals = {"self": self}
            self.locals["dna_ident"] = _locals

            def _G_consumedby_225():
                def _G_many_226():
                    self._trace("", (5576, 5579), self.input.position)
                    _G_apply_227, lastError = self._apply(self.rule_dna, "dna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_227, self.currentError)

                _G_many_228, lastError = self.many(_G_many_226)
                self.considerError(lastError, None)
                return (_G_many_228, self.currentError)

            _G_consumedby_229, lastError = self.consumedby(_G_consumedby_225)
            self.considerError(lastError, "dna_ident")
            _locals["ref"] = _G_consumedby_229
            self._trace("", (5585, 5589), self.input.position)
            _G_exactly_230, lastError = self.exactly("=")
            self.considerError(lastError, "dna_ident")
            _G_python_232, lastError = eval(self._G_expr_231, self.globals, _locals), None
            self.considerError(lastError, "dna_ident")
            return (_G_python_232, self.currentError)

        def rule_dna_subst(self):
            _locals = {"self": self}
            self.locals["dna_subst"] = _locals
            self._trace("", (5651, 5655), self.input.position)
            _G_apply_233, lastError = self._apply(self.rule_dna, "dna", [])
            self.considerError(lastError, "dna_subst")
            _locals["ref"] = _G_apply_233
            self._trace("", (5659, 5663), self.input.position)
            _G_exactly_234, lastError = self.exactly(">")
            self.considerError(lastError, "dna_subst")
            self._trace("", (5663, 5667), self.input.position)
            _G_apply_235, lastError = self._apply(self.rule_dna, "dna", [])
            self.considerError(lastError, "dna_subst")
            _locals["alt"] = _G_apply_235
            _G_python_237, lastError = eval(self._G_expr_236, self.globals, _locals), None
            self.considerError(lastError, "dna_subst")
            return (_G_python_237, self.currentError)

        def rule_dna_delins(self):
            _locals = {"self": self}
            self.locals["dna_delins"] = _locals
            self._trace("", (5728, 5734), self.input.position)
            _G_exactly_238, lastError = self.exactly("del")
            self.considerError(lastError, "dna_delins")

            def _G_or_239():
                def _G_consumedby_240():
                    self._trace("", (5737, 5740), self.input.position)
                    _G_apply_241, lastError = self._apply(self.rule_num, "num", [])
                    self.considerError(lastError, None)
                    return (_G_apply_241, self.currentError)

                _G_consumedby_242, lastError = self.consumedby(_G_consumedby_240)
                self.considerError(lastError, None)
                return (_G_consumedby_242, self.currentError)

            def _G_or_243():
                def _G_consumedby_244():
                    def _G_many_245():
                        self._trace("", (5743, 5746), self.input.position)
                        _G_apply_246, lastError = self._apply(self.rule_dna, "dna", [])
                        self.considerError(lastError, None)
                        return (_G_apply_246, self.currentError)

                    _G_many_247, lastError = self.many(_G_many_245)
                    self.considerError(lastError, None)
                    return (_G_many_247, self.currentError)

                _G_consumedby_248, lastError = self.consumedby(_G_consumedby_244)
                self.considerError(lastError, None)
                return (_G_consumedby_248, self.currentError)

            _G_or_249, lastError = self._or([_G_or_239, _G_or_243])
            self.considerError(lastError, "dna_delins")
            _locals["ref"] = _G_or_249
            self._trace("", (5753, 5759), self.input.position)
            _G_exactly_250, lastError = self.exactly("ins")
            self.considerError(lastError, "dna_delins")

            def _G_consumedby_251():
                def _G_many1_252():
                    self._trace("", (5761, 5764), self.input.position)
                    _G_apply_253, lastError = self._apply(self.rule_dna, "dna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_253, self.currentError)

                _G_many1_254, lastError = self.many(_G_many1_252, _G_many1_252())
                self.considerError(lastError, None)
                return (_G_many1_254, self.currentError)

            _G_consumedby_255, lastError = self.consumedby(_G_consumedby_251)
            self.considerError(lastError, "dna_delins")
            _locals["alt"] = _G_consumedby_255
            _G_python_256, lastError = eval(self._G_expr_236, self.globals, _locals), None
            self.considerError(lastError, "dna_delins")
            return (_G_python_256, self.currentError)

        def rule_dna_del(self):
            _locals = {"self": self}
            self.locals["dna_del"] = _locals
            self._trace("", (5823, 5829), self.input.position)
            _G_exactly_257, lastError = self.exactly("del")
            self.considerError(lastError, "dna_del")

            def _G_or_258():
                def _G_consumedby_259():
                    self._trace("", (5832, 5835), self.input.position)
                    _G_apply_260, lastError = self._apply(self.rule_num, "num", [])
                    self.considerError(lastError, None)
                    return (_G_apply_260, self.currentError)

                _G_consumedby_261, lastError = self.consumedby(_G_consumedby_259)
                self.considerError(lastError, None)
                return (_G_consumedby_261, self.currentError)

            def _G_or_262():
                def _G_consumedby_263():
                    def _G_many_264():
                        self._trace("", (5838, 5841), self.input.position)
                        _G_apply_265, lastError = self._apply(self.rule_dna, "dna", [])
                        self.considerError(lastError, None)
                        return (_G_apply_265, self.currentError)

                    _G_many_266, lastError = self.many(_G_many_264)
                    self.considerError(lastError, None)
                    return (_G_many_266, self.currentError)

                _G_consumedby_267, lastError = self.consumedby(_G_consumedby_263)
                self.considerError(lastError, None)
                return (_G_consumedby_267, self.currentError)

            _G_or_268, lastError = self._or([_G_or_258, _G_or_262])
            self.considerError(lastError, "dna_del")
            _locals["ref"] = _G_or_268
            _G_python_270, lastError = eval(self._G_expr_269, self.globals, _locals), None
            self.considerError(lastError, "dna_del")
            return (_G_python_270, self.currentError)

        def rule_dna_ins(self):
            _locals = {"self": self}
            self.locals["dna_ins"] = _locals
            self._trace("", (5901, 5907), self.input.position)
            _G_exactly_271, lastError = self.exactly("ins")
            self.considerError(lastError, "dna_ins")

            def _G_consumedby_272():
                def _G_many1_273():
                    self._trace("", (5909, 5912), self.input.position)
                    _G_apply_274, lastError = self._apply(self.rule_dna, "dna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_274, self.currentError)

                _G_many1_275, lastError = self.many(_G_many1_273, _G_many1_273())
                self.considerError(lastError, None)
                return (_G_many1_275, self.currentError)

            _G_consumedby_276, lastError = self.consumedby(_G_consumedby_272)
            self.considerError(lastError, "dna_ins")
            _locals["alt"] = _G_consumedby_276
            _G_python_278, lastError = eval(self._G_expr_277, self.globals, _locals), None
            self.considerError(lastError, "dna_ins")
            return (_G_python_278, self.currentError)

        def rule_dna_dup(self):
            _locals = {"self": self}
            self.locals["dna_dup"] = _locals
            self._trace("", (5979, 5985), self.input.position)
            _G_exactly_279, lastError = self.exactly("dup")
            self.considerError(lastError, "dna_dup")

            def _G_consumedby_280():
                def _G_many_281():
                    self._trace("", (5987, 5990), self.input.position)
                    _G_apply_282, lastError = self._apply(self.rule_dna, "dna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_282, self.currentError)

                _G_many_283, lastError = self.many(_G_many_281)
                self.considerError(lastError, None)
                return (_G_many_283, self.currentError)

            _G_consumedby_284, lastError = self.consumedby(_G_consumedby_280)
            self.considerError(lastError, "dna_dup")
            _locals["ref"] = _G_consumedby_284
            _G_python_286, lastError = eval(self._G_expr_285, self.globals, _locals), None
            self.considerError(lastError, "dna_dup")
            return (_G_python_286, self.currentError)

        def rule_dna_inv(self):
            _locals = {"self": self}
            self.locals["dna_inv"] = _locals
            self._trace("", (6043, 6049), self.input.position)
            _G_exactly_287, lastError = self.exactly("inv")
            self.considerError(lastError, "dna_inv")

            def _G_or_288():
                def _G_consumedby_289():
                    self._trace("", (6052, 6055), self.input.position)
                    _G_apply_290, lastError = self._apply(self.rule_num, "num", [])
                    self.considerError(lastError, None)
                    return (_G_apply_290, self.currentError)

                _G_consumedby_291, lastError = self.consumedby(_G_consumedby_289)
                self.considerError(lastError, None)
                return (_G_consumedby_291, self.currentError)

            def _G_or_292():
                def _G_consumedby_293():
                    def _G_many_294():
                        self._trace("", (6058, 6061), self.input.position)
                        _G_apply_295, lastError = self._apply(self.rule_dna, "dna", [])
                        self.considerError(lastError, None)
                        return (_G_apply_295, self.currentError)

                    _G_many_296, lastError = self.many(_G_many_294)
                    self.considerError(lastError, None)
                    return (_G_many_296, self.currentError)

                _G_consumedby_297, lastError = self.consumedby(_G_consumedby_293)
                self.considerError(lastError, None)
                return (_G_consumedby_297, self.currentError)

            _G_or_298, lastError = self._or([_G_or_288, _G_or_292])
            self.considerError(lastError, "dna_inv")
            _locals["ref"] = _G_or_298
            _G_python_300, lastError = eval(self._G_expr_299, self.globals, _locals), None
            self.considerError(lastError, "dna_inv")
            return (_G_python_300, self.currentError)

        def rule_dna_con(self):
            _locals = {"self": self}
            self.locals["dna_con"] = _locals
            self._trace("", (6108, 6114), self.input.position)
            _G_exactly_301, lastError = self.exactly("con")
            self.considerError(lastError, "dna_con")
            self._trace("", (6114, 6128), self.input.position)
            _G_apply_302, lastError = self._apply(self.rule_hgvs_position, "hgvs_position", [])
            self.considerError(lastError, "dna_con")
            _locals["pos"] = _G_apply_302
            _G_python_304, lastError = eval(self._G_expr_303, self.globals, _locals), None
            self.considerError(lastError, "dna_con")
            return (_G_python_304, self.currentError)

        def rule_dna_copy(self):
            _locals = {"self": self}
            self.locals["dna_copy"] = _locals
            self._trace("", (6218, 6225), self.input.position)
            _G_exactly_305, lastError = self.exactly("copy")
            self.considerError(lastError, "dna_copy")
            self._trace("", (6225, 6229), self.input.position)
            _G_apply_306, lastError = self._apply(self.rule_num, "num", [])
            self.considerError(lastError, "dna_copy")
            _locals["n"] = _G_apply_306
            _G_python_308, lastError = eval(self._G_expr_307, self.globals, _locals), None
            self.considerError(lastError, "dna_copy")
            return (_G_python_308, self.currentError)

        def rule_rna_edit_mu(self):
            _locals = {"self": self}
            self.locals["rna_edit_mu"] = _locals

            def _G_or_309():
                self._trace("", (6274, 6283), self.input.position)
                _G_apply_310, lastError = self._apply(self.rule_rna_edit, "rna_edit", [])
                self.considerError(lastError, None)
                return (_G_apply_310, self.currentError)

            def _G_or_311():
                self._trace("", (6285, 6289), self.input.position)
                _G_exactly_312, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (6289, 6298), self.input.position)
                _G_apply_313, lastError = self._apply(self.rule_rna_edit, "rna_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_313
                self._trace("", (6303, 6307), self.input.position)
                _G_exactly_314, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_315, lastError = eval(self._G_expr_203, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_315, self.currentError)

            _G_or_316, lastError = self._or([_G_or_309, _G_or_311])
            self.considerError(lastError, "rna_edit_mu")
            return (_G_or_316, self.currentError)

        def rule_rna_edit(self):
            _locals = {"self": self}
            self.locals["rna_edit"] = _locals

            def _G_or_317():
                self._trace("", (6345, 6355), self.input.position)
                _G_apply_318, lastError = self._apply(self.rule_rna_ident, "rna_ident", [])
                self.considerError(lastError, None)
                return (_G_apply_318, self.currentError)

            def _G_or_319():
                self._trace("", (6357, 6367), self.input.position)
                _G_apply_320, lastError = self._apply(self.rule_rna_subst, "rna_subst", [])
                self.considerError(lastError, None)
                return (_G_apply_320, self.currentError)

            def _G_or_321():
                self._trace("", (6369, 6380), self.input.position)
                _G_apply_322, lastError = self._apply(self.rule_rna_delins, "rna_delins", [])
                self.considerError(lastError, None)
                return (_G_apply_322, self.currentError)

            def _G_or_323():
                self._trace("", (6382, 6390), self.input.position)
                _G_apply_324, lastError = self._apply(self.rule_rna_ins, "rna_ins", [])
                self.considerError(lastError, None)
                return (_G_apply_324, self.currentError)

            def _G_or_325():
                self._trace("", (6392, 6400), self.input.position)
                _G_apply_326, lastError = self._apply(self.rule_rna_del, "rna_del", [])
                self.considerError(lastError, None)
                return (_G_apply_326, self.currentError)

            def _G_or_327():
                self._trace("", (6402, 6410), self.input.position)
                _G_apply_328, lastError = self._apply(self.rule_rna_dup, "rna_dup", [])
                self.considerError(lastError, None)
                return (_G_apply_328, self.currentError)

            def _G_or_329():
                self._trace("", (6412, 6420), self.input.position)
                _G_apply_330, lastError = self._apply(self.rule_rna_inv, "rna_inv", [])
                self.considerError(lastError, None)
                return (_G_apply_330, self.currentError)

            def _G_or_331():
                self._trace("", (6422, 6430), self.input.position)
                _G_apply_332, lastError = self._apply(self.rule_rna_con, "rna_con", [])
                self.considerError(lastError, None)
                return (_G_apply_332, self.currentError)

            _G_or_333, lastError = self._or(
                [
                    _G_or_317,
                    _G_or_319,
                    _G_or_321,
                    _G_or_323,
                    _G_or_325,
                    _G_or_327,
                    _G_or_329,
                    _G_or_331,
                ]
            )
            self.considerError(lastError, "rna_edit")
            return (_G_or_333, self.currentError)

        def rule_rna_ident(self):
            _locals = {"self": self}
            self.locals["rna_ident"] = _locals

            def _G_consumedby_334():
                def _G_many_335():
                    self._trace("", (6445, 6448), self.input.position)
                    _G_apply_336, lastError = self._apply(self.rule_rna, "rna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_336, self.currentError)

                _G_many_337, lastError = self.many(_G_many_335)
                self.considerError(lastError, None)
                return (_G_many_337, self.currentError)

            _G_consumedby_338, lastError = self.consumedby(_G_consumedby_334)
            self.considerError(lastError, "rna_ident")
            _locals["ref"] = _G_consumedby_338
            self._trace("", (6454, 6458), self.input.position)
            _G_exactly_339, lastError = self.exactly("=")
            self.considerError(lastError, "rna_ident")
            _G_python_340, lastError = eval(self._G_expr_231, self.globals, _locals), None
            self.considerError(lastError, "rna_ident")
            return (_G_python_340, self.currentError)

        def rule_rna_subst(self):
            _locals = {"self": self}
            self.locals["rna_subst"] = _locals
            self._trace("", (6527, 6531), self.input.position)
            _G_apply_341, lastError = self._apply(self.rule_rna, "rna", [])
            self.considerError(lastError, "rna_subst")
            _locals["ref"] = _G_apply_341
            self._trace("", (6535, 6539), self.input.position)
            _G_exactly_342, lastError = self.exactly(">")
            self.considerError(lastError, "rna_subst")
            self._trace("", (6539, 6543), self.input.position)
            _G_apply_343, lastError = self._apply(self.rule_rna, "rna", [])
            self.considerError(lastError, "rna_subst")
            _locals["alt"] = _G_apply_343
            _G_python_344, lastError = eval(self._G_expr_236, self.globals, _locals), None
            self.considerError(lastError, "rna_subst")
            return (_G_python_344, self.currentError)

        def rule_rna_delins(self):
            _locals = {"self": self}
            self.locals["rna_delins"] = _locals
            self._trace("", (6611, 6617), self.input.position)
            _G_exactly_345, lastError = self.exactly("del")
            self.considerError(lastError, "rna_delins")

            def _G_or_346():
                def _G_consumedby_347():
                    self._trace("", (6620, 6623), self.input.position)
                    _G_apply_348, lastError = self._apply(self.rule_num, "num", [])
                    self.considerError(lastError, None)
                    return (_G_apply_348, self.currentError)

                _G_consumedby_349, lastError = self.consumedby(_G_consumedby_347)
                self.considerError(lastError, None)
                return (_G_consumedby_349, self.currentError)

            def _G_or_350():
                def _G_consumedby_351():
                    def _G_many_352():
                        self._trace("", (6626, 6629), self.input.position)
                        _G_apply_353, lastError = self._apply(self.rule_rna, "rna", [])
                        self.considerError(lastError, None)
                        return (_G_apply_353, self.currentError)

                    _G_many_354, lastError = self.many(_G_many_352)
                    self.considerError(lastError, None)
                    return (_G_many_354, self.currentError)

                _G_consumedby_355, lastError = self.consumedby(_G_consumedby_351)
                self.considerError(lastError, None)
                return (_G_consumedby_355, self.currentError)

            _G_or_356, lastError = self._or([_G_or_346, _G_or_350])
            self.considerError(lastError, "rna_delins")
            _locals["ref"] = _G_or_356
            self._trace("", (6636, 6642), self.input.position)
            _G_exactly_357, lastError = self.exactly("ins")
            self.considerError(lastError, "rna_delins")

            def _G_consumedby_358():
                def _G_many1_359():
                    self._trace("", (6644, 6647), self.input.position)
                    _G_apply_360, lastError = self._apply(self.rule_rna, "rna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_360, self.currentError)

                _G_many1_361, lastError = self.many(_G_many1_359, _G_many1_359())
                self.considerError(lastError, None)
                return (_G_many1_361, self.currentError)

            _G_consumedby_362, lastError = self.consumedby(_G_consumedby_358)
            self.considerError(lastError, "rna_delins")
            _locals["alt"] = _G_consumedby_362
            _G_python_363, lastError = eval(self._G_expr_236, self.globals, _locals), None
            self.considerError(lastError, "rna_delins")
            return (_G_python_363, self.currentError)

        def rule_rna_del(self):
            _locals = {"self": self}
            self.locals["rna_del"] = _locals
            self._trace("", (6706, 6712), self.input.position)
            _G_exactly_364, lastError = self.exactly("del")
            self.considerError(lastError, "rna_del")

            def _G_or_365():
                def _G_consumedby_366():
                    self._trace("", (6715, 6718), self.input.position)
                    _G_apply_367, lastError = self._apply(self.rule_num, "num", [])
                    self.considerError(lastError, None)
                    return (_G_apply_367, self.currentError)

                _G_consumedby_368, lastError = self.consumedby(_G_consumedby_366)
                self.considerError(lastError, None)
                return (_G_consumedby_368, self.currentError)

            def _G_or_369():
                def _G_consumedby_370():
                    def _G_many_371():
                        self._trace("", (6721, 6724), self.input.position)
                        _G_apply_372, lastError = self._apply(self.rule_rna, "rna", [])
                        self.considerError(lastError, None)
                        return (_G_apply_372, self.currentError)

                    _G_many_373, lastError = self.many(_G_many_371)
                    self.considerError(lastError, None)
                    return (_G_many_373, self.currentError)

                _G_consumedby_374, lastError = self.consumedby(_G_consumedby_370)
                self.considerError(lastError, None)
                return (_G_consumedby_374, self.currentError)

            _G_or_375, lastError = self._or([_G_or_365, _G_or_369])
            self.considerError(lastError, "rna_del")
            _locals["ref"] = _G_or_375
            _G_python_376, lastError = eval(self._G_expr_269, self.globals, _locals), None
            self.considerError(lastError, "rna_del")
            return (_G_python_376, self.currentError)

        def rule_rna_ins(self):
            _locals = {"self": self}
            self.locals["rna_ins"] = _locals
            self._trace("", (6791, 6797), self.input.position)
            _G_exactly_377, lastError = self.exactly("ins")
            self.considerError(lastError, "rna_ins")

            def _G_consumedby_378():
                def _G_many1_379():
                    self._trace("", (6799, 6802), self.input.position)
                    _G_apply_380, lastError = self._apply(self.rule_rna, "rna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_380, self.currentError)

                _G_many1_381, lastError = self.many(_G_many1_379, _G_many1_379())
                self.considerError(lastError, None)
                return (_G_many1_381, self.currentError)

            _G_consumedby_382, lastError = self.consumedby(_G_consumedby_378)
            self.considerError(lastError, "rna_ins")
            _locals["alt"] = _G_consumedby_382
            _G_python_383, lastError = eval(self._G_expr_277, self.globals, _locals), None
            self.considerError(lastError, "rna_ins")
            return (_G_python_383, self.currentError)

        def rule_rna_dup(self):
            _locals = {"self": self}
            self.locals["rna_dup"] = _locals
            self._trace("", (6876, 6882), self.input.position)
            _G_exactly_384, lastError = self.exactly("dup")
            self.considerError(lastError, "rna_dup")

            def _G_consumedby_385():
                def _G_many_386():
                    self._trace("", (6884, 6887), self.input.position)
                    _G_apply_387, lastError = self._apply(self.rule_rna, "rna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_387, self.currentError)

                _G_many_388, lastError = self.many(_G_many_386)
                self.considerError(lastError, None)
                return (_G_many_388, self.currentError)

            _G_consumedby_389, lastError = self.consumedby(_G_consumedby_385)
            self.considerError(lastError, "rna_dup")
            _locals["ref"] = _G_consumedby_389
            _G_python_390, lastError = eval(self._G_expr_285, self.globals, _locals), None
            self.considerError(lastError, "rna_dup")
            return (_G_python_390, self.currentError)

        def rule_rna_inv(self):
            _locals = {"self": self}
            self.locals["rna_inv"] = _locals
            self._trace("", (6947, 6953), self.input.position)
            _G_exactly_391, lastError = self.exactly("inv")
            self.considerError(lastError, "rna_inv")

            def _G_or_392():
                def _G_consumedby_393():
                    self._trace("", (6956, 6959), self.input.position)
                    _G_apply_394, lastError = self._apply(self.rule_num, "num", [])
                    self.considerError(lastError, None)
                    return (_G_apply_394, self.currentError)

                _G_consumedby_395, lastError = self.consumedby(_G_consumedby_393)
                self.considerError(lastError, None)
                return (_G_consumedby_395, self.currentError)

            def _G_or_396():
                def _G_consumedby_397():
                    def _G_many_398():
                        self._trace("", (6962, 6965), self.input.position)
                        _G_apply_399, lastError = self._apply(self.rule_rna, "rna", [])
                        self.considerError(lastError, None)
                        return (_G_apply_399, self.currentError)

                    _G_many_400, lastError = self.many(_G_many_398)
                    self.considerError(lastError, None)
                    return (_G_many_400, self.currentError)

                _G_consumedby_401, lastError = self.consumedby(_G_consumedby_397)
                self.considerError(lastError, None)
                return (_G_consumedby_401, self.currentError)

            _G_or_402, lastError = self._or([_G_or_392, _G_or_396])
            self.considerError(lastError, "rna_inv")
            _locals["ref"] = _G_or_402
            _G_python_403, lastError = eval(self._G_expr_299, self.globals, _locals), None
            self.considerError(lastError, "rna_inv")
            return (_G_python_403, self.currentError)

        def rule_rna_con(self):
            _locals = {"self": self}
            self.locals["rna_con"] = _locals
            self._trace("", (7019, 7025), self.input.position)
            _G_exactly_404, lastError = self.exactly("con")
            self.considerError(lastError, "rna_con")
            self._trace("", (7025, 7039), self.input.position)
            _G_apply_405, lastError = self._apply(self.rule_hgvs_position, "hgvs_position", [])
            self.considerError(lastError, "rna_con")
            _locals["pos"] = _G_apply_405
            _G_python_406, lastError = eval(self._G_expr_303, self.globals, _locals), None
            self.considerError(lastError, "rna_con")
            return (_G_python_406, self.currentError)

        def rule_pro_edit_mu(self):
            _locals = {"self": self}
            self.locals["pro_edit_mu"] = _locals

            def _G_or_407():
                self._trace("", (7138, 7147), self.input.position)
                _G_apply_408, lastError = self._apply(self.rule_pro_edit, "pro_edit", [])
                self.considerError(lastError, None)
                return (_G_apply_408, self.currentError)

            def _G_or_409():
                self._trace("", (7149, 7153), self.input.position)
                _G_exactly_410, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (7153, 7162), self.input.position)
                _G_apply_411, lastError = self._apply(self.rule_pro_edit, "pro_edit", [])
                self.considerError(lastError, None)
                _locals["edit"] = _G_apply_411
                self._trace("", (7167, 7171), self.input.position)
                _G_exactly_412, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_413, lastError = eval(self._G_expr_203, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_413, self.currentError)

            _G_or_414, lastError = self._or([_G_or_407, _G_or_409])
            self.considerError(lastError, "pro_edit_mu")
            return (_G_or_414, self.currentError)

        def rule_pro_edit(self):
            _locals = {"self": self}
            self.locals["pro_edit"] = _locals

            def _G_or_415():
                self._trace("", (7209, 7216), self.input.position)
                _G_apply_416, lastError = self._apply(self.rule_pro_fs, "pro_fs", [])
                self.considerError(lastError, None)
                return (_G_apply_416, self.currentError)

            def _G_or_417():
                self._trace("", (7218, 7226), self.input.position)
                _G_apply_418, lastError = self._apply(self.rule_pro_ext, "pro_ext", [])
                self.considerError(lastError, None)
                return (_G_apply_418, self.currentError)

            def _G_or_419():
                self._trace("", (7228, 7238), self.input.position)
                _G_apply_420, lastError = self._apply(self.rule_pro_subst, "pro_subst", [])
                self.considerError(lastError, None)
                return (_G_apply_420, self.currentError)

            def _G_or_421():
                self._trace("", (7240, 7251), self.input.position)
                _G_apply_422, lastError = self._apply(self.rule_pro_delins, "pro_delins", [])
                self.considerError(lastError, None)
                return (_G_apply_422, self.currentError)

            def _G_or_423():
                self._trace("", (7253, 7261), self.input.position)
                _G_apply_424, lastError = self._apply(self.rule_pro_ins, "pro_ins", [])
                self.considerError(lastError, None)
                return (_G_apply_424, self.currentError)

            def _G_or_425():
                self._trace("", (7263, 7271), self.input.position)
                _G_apply_426, lastError = self._apply(self.rule_pro_del, "pro_del", [])
                self.considerError(lastError, None)
                return (_G_apply_426, self.currentError)

            def _G_or_427():
                self._trace("", (7273, 7281), self.input.position)
                _G_apply_428, lastError = self._apply(self.rule_pro_dup, "pro_dup", [])
                self.considerError(lastError, None)
                return (_G_apply_428, self.currentError)

            def _G_or_429():
                self._trace("", (7283, 7293), self.input.position)
                _G_apply_430, lastError = self._apply(self.rule_pro_ident, "pro_ident", [])
                self.considerError(lastError, None)
                return (_G_apply_430, self.currentError)

            _G_or_431, lastError = self._or(
                [
                    _G_or_415,
                    _G_or_417,
                    _G_or_419,
                    _G_or_421,
                    _G_or_423,
                    _G_or_425,
                    _G_or_427,
                    _G_or_429,
                ]
            )
            self.considerError(lastError, "pro_edit")
            return (_G_or_431, self.currentError)

        def rule_pro_subst(self):
            _locals = {"self": self}
            self.locals["pro_subst"] = _locals

            def _G_or_432():
                self._trace("", (7308, 7313), self.input.position)
                _G_apply_433, lastError = self._apply(self.rule_aat13, "aat13", [])
                self.considerError(lastError, None)
                return (_G_apply_433, self.currentError)

            def _G_or_434():
                self._trace("", (7314, 7317), self.input.position)
                _G_exactly_435, lastError = self.exactly("?")
                self.considerError(lastError, None)
                return (_G_exactly_435, self.currentError)

            _G_or_436, lastError = self._or([_G_or_432, _G_or_434])
            self.considerError(lastError, "pro_subst")
            _locals["alt"] = _G_or_436
            _G_python_438, lastError = eval(self._G_expr_437, self.globals, _locals), None
            self.considerError(lastError, "pro_subst")
            return (_G_python_438, self.currentError)

        def rule_pro_delins(self):
            _locals = {"self": self}
            self.locals["pro_delins"] = _locals
            self._trace("", (7386, 7395), self.input.position)
            _G_exactly_439, lastError = self.exactly("delins")
            self.considerError(lastError, "pro_delins")
            self._trace("", (7395, 7405), self.input.position)
            _G_apply_440, lastError = self._apply(self.rule_aat13_seq, "aat13_seq", [])
            self.considerError(lastError, "pro_delins")
            _locals["alt"] = _G_apply_440
            _G_python_442, lastError = eval(self._G_expr_441, self.globals, _locals), None
            self.considerError(lastError, "pro_delins")
            return (_G_python_442, self.currentError)

        def rule_pro_del(self):
            _locals = {"self": self}
            self.locals["pro_del"] = _locals
            self._trace("", (7469, 7475), self.input.position)
            _G_exactly_443, lastError = self.exactly("del")
            self.considerError(lastError, "pro_del")
            _G_python_445, lastError = eval(self._G_expr_444, self.globals, _locals), None
            self.considerError(lastError, "pro_del")
            return (_G_python_445, self.currentError)

        def rule_pro_ins(self):
            _locals = {"self": self}
            self.locals["pro_ins"] = _locals
            self._trace("", (7553, 7559), self.input.position)
            _G_exactly_446, lastError = self.exactly("ins")
            self.considerError(lastError, "pro_ins")
            self._trace("", (7559, 7569), self.input.position)
            _G_apply_447, lastError = self._apply(self.rule_aat13_seq, "aat13_seq", [])
            self.considerError(lastError, "pro_ins")
            _locals["alt"] = _G_apply_447
            _G_python_449, lastError = eval(self._G_expr_448, self.globals, _locals), None
            self.considerError(lastError, "pro_ins")
            return (_G_python_449, self.currentError)

        def rule_pro_dup(self):
            _locals = {"self": self}
            self.locals["pro_dup"] = _locals
            self._trace("", (7638, 7644), self.input.position)
            _G_exactly_450, lastError = self.exactly("dup")
            self.considerError(lastError, "pro_dup")
            _G_python_452, lastError = eval(self._G_expr_451, self.globals, _locals), None
            self.considerError(lastError, "pro_dup")
            return (_G_python_452, self.currentError)

        def rule_pro_fs(self):
            _locals = {"self": self}
            self.locals["pro_fs"] = _locals

            def _G_or_453():
                self._trace("", (7710, 7715), self.input.position)
                _G_apply_454, lastError = self._apply(self.rule_aat13, "aat13", [])
                self.considerError(lastError, None)
                return (_G_apply_454, self.currentError)

            def _G_or_455():
                _G_python_456, lastError = (""), None
                self.considerError(lastError, None)
                return (_G_python_456, self.currentError)

            _G_or_457, lastError = self._or([_G_or_453, _G_or_455])
            self.considerError(lastError, "pro_fs")
            _locals["alt"] = _G_or_457
            self._trace("", (7730, 7733), self.input.position)
            _G_apply_458, lastError = self._apply(self.rule_fs, "fs", [])
            self.considerError(lastError, "pro_fs")
            _locals["length"] = _G_apply_458
            _G_python_460, lastError = eval(self._G_expr_459, self.globals, _locals), None
            self.considerError(lastError, "pro_fs")
            return (_G_python_460, self.currentError)

        def rule_pro_ext(self):
            _locals = {"self": self}
            self.locals["pro_ext"] = _locals

            def _G_optional_461():
                self._trace("", (7803, 7809), self.input.position)
                _G_apply_462, lastError = self._apply(self.rule_aat13, "aat13", [])
                self.considerError(lastError, None)
                return (_G_apply_462, self.currentError)

            def _G_optional_463():
                return (None, self.input.nullError())

            _G_or_464, lastError = self._or([_G_optional_461, _G_optional_463])
            self.considerError(lastError, "pro_ext")
            _locals["alt"] = _G_or_464
            self._trace("", (7814, 7818), self.input.position)
            _G_apply_465, lastError = self._apply(self.rule_ext, "ext", [])
            self.considerError(lastError, "pro_ext")
            _locals["aaterm"] = _G_apply_465[0]
            _locals["length"] = _G_apply_465[1]
            _G_python_467, lastError = eval(self._G_expr_466, self.globals, _locals), None
            self.considerError(lastError, "pro_ext")
            return (_G_python_467, self.currentError)

        def rule_pro_ident(self):
            _locals = {"self": self}
            self.locals["pro_ident"] = _locals
            self._trace("", (7914, 7918), self.input.position)
            _G_exactly_468, lastError = self.exactly("=")
            self.considerError(lastError, "pro_ident")
            _G_python_470, lastError = eval(self._G_expr_469, self.globals, _locals), None
            self.considerError(lastError, "pro_ident")
            return (_G_python_470, self.currentError)

        def rule_c_interval(self):
            _locals = {"self": self}
            self.locals["c_interval"] = _locals

            def _G_or_471():
                self._trace("", (8240, 8255), self.input.position)
                _G_apply_472, lastError = self._apply(
                    self.rule_def_c_interval, "def_c_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_472, self.currentError)

            def _G_or_473():
                self._trace("", (8257, 8261), self.input.position)
                _G_exactly_474, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8261, 8276), self.input.position)
                _G_apply_475, lastError = self._apply(
                    self.rule_def_c_interval, "def_c_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_475
                self._trace("", (8279, 8283), self.input.position)
                _G_exactly_476, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_478, lastError = eval(self._G_expr_477, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_478, self.currentError)

            _G_or_479, lastError = self._or([_G_or_471, _G_or_473])
            self.considerError(lastError, "c_interval")
            return (_G_or_479, self.currentError)

        def rule_g_interval(self):
            _locals = {"self": self}
            self.locals["g_interval"] = _locals

            def _G_or_480():
                self._trace("", (8319, 8334), self.input.position)
                _G_apply_481, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_481, self.currentError)

            def _G_or_482():
                self._trace("", (8336, 8340), self.input.position)
                _G_exactly_483, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8340, 8355), self.input.position)
                _G_apply_484, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_484
                self._trace("", (8358, 8362), self.input.position)
                _G_exactly_485, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_486, lastError = eval(self._G_expr_477, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_486, self.currentError)

            _G_or_487, lastError = self._or([_G_or_480, _G_or_482])
            self.considerError(lastError, "g_interval")
            return (_G_or_487, self.currentError)

        def rule_m_interval(self):
            _locals = {"self": self}
            self.locals["m_interval"] = _locals

            def _G_or_488():
                self._trace("", (8398, 8413), self.input.position)
                _G_apply_489, lastError = self._apply(
                    self.rule_def_m_interval, "def_m_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_489, self.currentError)

            def _G_or_490():
                self._trace("", (8415, 8419), self.input.position)
                _G_exactly_491, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8419, 8434), self.input.position)
                _G_apply_492, lastError = self._apply(
                    self.rule_def_m_interval, "def_m_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_492
                self._trace("", (8437, 8441), self.input.position)
                _G_exactly_493, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_494, lastError = eval(self._G_expr_477, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_494, self.currentError)

            _G_or_495, lastError = self._or([_G_or_488, _G_or_490])
            self.considerError(lastError, "m_interval")
            return (_G_or_495, self.currentError)

        def rule_n_interval(self):
            _locals = {"self": self}
            self.locals["n_interval"] = _locals

            def _G_or_496():
                self._trace("", (8477, 8492), self.input.position)
                _G_apply_497, lastError = self._apply(
                    self.rule_def_n_interval, "def_n_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_497, self.currentError)

            def _G_or_498():
                self._trace("", (8494, 8498), self.input.position)
                _G_exactly_499, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8498, 8513), self.input.position)
                _G_apply_500, lastError = self._apply(
                    self.rule_def_n_interval, "def_n_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_500
                self._trace("", (8516, 8520), self.input.position)
                _G_exactly_501, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_502, lastError = eval(self._G_expr_477, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_502, self.currentError)

            _G_or_503, lastError = self._or([_G_or_496, _G_or_498])
            self.considerError(lastError, "n_interval")
            return (_G_or_503, self.currentError)

        def rule_p_interval(self):
            _locals = {"self": self}
            self.locals["p_interval"] = _locals

            def _G_or_504():
                self._trace("", (8556, 8571), self.input.position)
                _G_apply_505, lastError = self._apply(
                    self.rule_def_p_interval, "def_p_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_505, self.currentError)

            def _G_or_506():
                self._trace("", (8573, 8577), self.input.position)
                _G_exactly_507, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8577, 8592), self.input.position)
                _G_apply_508, lastError = self._apply(
                    self.rule_def_p_interval, "def_p_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_508
                self._trace("", (8595, 8599), self.input.position)
                _G_exactly_509, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_510, lastError = eval(self._G_expr_477, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_510, self.currentError)

            _G_or_511, lastError = self._or([_G_or_504, _G_or_506])
            self.considerError(lastError, "p_interval")
            return (_G_or_511, self.currentError)

        def rule_r_interval(self):
            _locals = {"self": self}
            self.locals["r_interval"] = _locals

            def _G_or_512():
                self._trace("", (8635, 8650), self.input.position)
                _G_apply_513, lastError = self._apply(
                    self.rule_def_r_interval, "def_r_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_513, self.currentError)

            def _G_or_514():
                self._trace("", (8652, 8656), self.input.position)
                _G_exactly_515, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8656, 8671), self.input.position)
                _G_apply_516, lastError = self._apply(
                    self.rule_def_r_interval, "def_r_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_516
                self._trace("", (8674, 8678), self.input.position)
                _G_exactly_517, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_518, lastError = eval(self._G_expr_477, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_518, self.currentError)

            _G_or_519, lastError = self._or([_G_or_512, _G_or_514])
            self.considerError(lastError, "r_interval")
            return (_G_or_519, self.currentError)

        def rule_def_g_interval(self):
            _locals = {"self": self}
            self.locals["def_g_interval"] = _locals

            def _G_or_520():
                self._trace("", (8742, 8747), self.input.position)
                _G_apply_521, lastError = self._apply(self.rule_g_pos, "g_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_521
                self._trace("", (8753, 8757), self.input.position)
                _G_exactly_522, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (8757, 8763), self.input.position)
                _G_apply_523, lastError = self._apply(self.rule_g_pos, "g_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_523
                _G_python_525, lastError = eval(self._G_expr_524, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_525, self.currentError)

            def _G_or_526():
                self._trace("", (8809, 8814), self.input.position)
                _G_apply_527, lastError = self._apply(self.rule_g_pos, "g_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_527
                _G_python_529, lastError = eval(self._G_expr_528, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_529, self.currentError)

            _G_or_530, lastError = self._or([_G_or_520, _G_or_526])
            self.considerError(lastError, "def_g_interval")
            return (_G_or_530, self.currentError)

        def rule_def_m_interval(self):
            _locals = {"self": self}
            self.locals["def_m_interval"] = _locals

            def _G_or_531():
                self._trace("", (8894, 8899), self.input.position)
                _G_apply_532, lastError = self._apply(self.rule_m_pos, "m_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_532
                self._trace("", (8905, 8909), self.input.position)
                _G_exactly_533, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (8909, 8915), self.input.position)
                _G_apply_534, lastError = self._apply(self.rule_m_pos, "m_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_534
                _G_python_535, lastError = eval(self._G_expr_524, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_535, self.currentError)

            def _G_or_536():
                self._trace("", (8961, 8966), self.input.position)
                _G_apply_537, lastError = self._apply(self.rule_m_pos, "m_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_537
                _G_python_538, lastError = eval(self._G_expr_528, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_538, self.currentError)

            _G_or_539, lastError = self._or([_G_or_531, _G_or_536])
            self.considerError(lastError, "def_m_interval")
            return (_G_or_539, self.currentError)

        def rule_def_p_interval(self):
            _locals = {"self": self}
            self.locals["def_p_interval"] = _locals

            def _G_or_540():
                self._trace("", (9046, 9051), self.input.position)
                _G_apply_541, lastError = self._apply(self.rule_p_pos, "p_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_541
                self._trace("", (9057, 9061), self.input.position)
                _G_exactly_542, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9061, 9067), self.input.position)
                _G_apply_543, lastError = self._apply(self.rule_p_pos, "p_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_543
                _G_python_544, lastError = eval(self._G_expr_524, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_544, self.currentError)

            def _G_or_545():
                self._trace("", (9113, 9118), self.input.position)
                _G_apply_546, lastError = self._apply(self.rule_p_pos, "p_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_546
                _G_python_547, lastError = eval(self._G_expr_528, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_547, self.currentError)

            _G_or_548, lastError = self._or([_G_or_540, _G_or_545])
            self.considerError(lastError, "def_p_interval")
            return (_G_or_548, self.currentError)

        def rule_def_r_interval(self):
            _locals = {"self": self}
            self.locals["def_r_interval"] = _locals

            def _G_or_549():
                self._trace("", (9198, 9203), self.input.position)
                _G_apply_550, lastError = self._apply(self.rule_r_pos, "r_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_550
                self._trace("", (9209, 9213), self.input.position)
                _G_exactly_551, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9213, 9219), self.input.position)
                _G_apply_552, lastError = self._apply(self.rule_r_pos, "r_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_552
                _G_python_553, lastError = eval(self._G_expr_524, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_553, self.currentError)

            def _G_or_554():
                self._trace("", (9265, 9270), self.input.position)
                _G_apply_555, lastError = self._apply(self.rule_r_pos, "r_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_555
                _G_python_556, lastError = eval(self._G_expr_528, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_556, self.currentError)

            _G_or_557, lastError = self._or([_G_or_549, _G_or_554])
            self.considerError(lastError, "def_r_interval")
            return (_G_or_557, self.currentError)

        def rule_def_c_interval(self):
            _locals = {"self": self}
            self.locals["def_c_interval"] = _locals

            def _G_or_558():
                self._trace("", (9350, 9355), self.input.position)
                _G_apply_559, lastError = self._apply(self.rule_c_pos, "c_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_559
                self._trace("", (9361, 9365), self.input.position)
                _G_exactly_560, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9365, 9371), self.input.position)
                _G_apply_561, lastError = self._apply(self.rule_c_pos, "c_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_561
                _G_python_563, lastError = eval(self._G_expr_562, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_563, self.currentError)

            def _G_or_564():
                self._trace("", (9427, 9432), self.input.position)
                _G_apply_565, lastError = self._apply(self.rule_c_pos, "c_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_565
                _G_python_567, lastError = eval(self._G_expr_566, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_567, self.currentError)

            _G_or_568, lastError = self._or([_G_or_558, _G_or_564])
            self.considerError(lastError, "def_c_interval")
            return (_G_or_568, self.currentError)

        def rule_def_n_interval(self):
            _locals = {"self": self}
            self.locals["def_n_interval"] = _locals

            def _G_or_569():
                self._trace("", (9522, 9527), self.input.position)
                _G_apply_570, lastError = self._apply(self.rule_n_pos, "n_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_570
                self._trace("", (9533, 9537), self.input.position)
                _G_exactly_571, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9537, 9543), self.input.position)
                _G_apply_572, lastError = self._apply(self.rule_n_pos, "n_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_572
                _G_python_573, lastError = eval(self._G_expr_562, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_573, self.currentError)

            def _G_or_574():
                self._trace("", (9599, 9604), self.input.position)
                _G_apply_575, lastError = self._apply(self.rule_n_pos, "n_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_575
                _G_python_576, lastError = eval(self._G_expr_566, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_576, self.currentError)

            _G_or_577, lastError = self._or([_G_or_569, _G_or_574])
            self.considerError(lastError, "def_n_interval")
            return (_G_or_577, self.currentError)

        def rule_c_pos(self):
            _locals = {"self": self}
            self.locals["c_pos"] = _locals
            self._trace("", (9696, 9706), self.input.position)
            _G_apply_578, lastError = self._apply(self.rule_def_c_pos, "def_c_pos", [])
            self.considerError(lastError, "c_pos")
            return (_G_apply_578, self.currentError)

        def rule_g_pos(self):
            _locals = {"self": self}
            self.locals["g_pos"] = _locals
            self._trace("", (9763, 9773), self.input.position)
            _G_apply_579, lastError = self._apply(self.rule_def_g_pos, "def_g_pos", [])
            self.considerError(lastError, "g_pos")
            return (_G_apply_579, self.currentError)

        def rule_m_pos(self):
            _locals = {"self": self}
            self.locals["m_pos"] = _locals
            self._trace("", (9830, 9840), self.input.position)
            _G_apply_580, lastError = self._apply(self.rule_def_m_pos, "def_m_pos", [])
            self.considerError(lastError, "m_pos")
            return (_G_apply_580, self.currentError)

        def rule_n_pos(self):
            _locals = {"self": self}
            self.locals["n_pos"] = _locals
            self._trace("", (9897, 9907), self.input.position)
            _G_apply_581, lastError = self._apply(self.rule_def_n_pos, "def_n_pos", [])
            self.considerError(lastError, "n_pos")
            return (_G_apply_581, self.currentError)

        def rule_p_pos(self):
            _locals = {"self": self}
            self.locals["p_pos"] = _locals
            self._trace("", (9964, 9974), self.input.position)
            _G_apply_582, lastError = self._apply(self.rule_def_p_pos, "def_p_pos", [])
            self.considerError(lastError, "p_pos")
            return (_G_apply_582, self.currentError)

        def rule_r_pos(self):
            _locals = {"self": self}
            self.locals["r_pos"] = _locals
            self._trace("", (10031, 10041), self.input.position)
            _G_apply_583, lastError = self._apply(self.rule_def_r_pos, "def_r_pos", [])
            self.considerError(lastError, "r_pos")
            return (_G_apply_583, self.currentError)

        def rule_def_c_pos(self):
            _locals = {"self": self}
            self.locals["def_c_pos"] = _locals

            def _G_or_584():
                self._trace("", (10124, 10129), self.input.position)
                _G_apply_585, lastError = self._apply(self.rule_base, "base", [])
                self.considerError(lastError, None)
                _locals["b"] = _G_apply_585
                self._trace("", (10131, 10138), self.input.position)
                _G_apply_586, lastError = self._apply(self.rule_offset, "offset", [])
                self.considerError(lastError, None)
                _locals["o"] = _G_apply_586
                _G_python_588, lastError = eval(self._G_expr_587, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_588, self.currentError)

            def _G_or_589():
                self._trace("", (10223, 10227), self.input.position)
                _G_exactly_590, lastError = self.exactly("*")
                self.considerError(lastError, None)
                self._trace("", (10227, 10231), self.input.position)
                _G_apply_591, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                _locals["b"] = _G_apply_591
                self._trace("", (10233, 10240), self.input.position)
                _G_apply_592, lastError = self._apply(self.rule_offset, "offset", [])
                self.considerError(lastError, None)
                _locals["o"] = _G_apply_592
                _G_python_594, lastError = eval(self._G_expr_593, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_594, self.currentError)

            _G_or_595, lastError = self._or([_G_or_584, _G_or_589])
            self.considerError(lastError, "def_c_pos")
            return (_G_or_595, self.currentError)

        def rule_def_g_pos(self):
            _locals = {"self": self}
            self.locals["def_g_pos"] = _locals

            def _G_or_596():
                self._trace("", (10328, 10331), self.input.position)
                _G_apply_597, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_597, self.currentError)

            def _G_or_598():
                self._trace("", (10332, 10335), self.input.position)
                _G_exactly_599, lastError = self.exactly("?")
                self.considerError(lastError, None)
                _G_python_600, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_600, self.currentError)

            _G_or_601, lastError = self._or([_G_or_596, _G_or_598])
            self.considerError(lastError, "def_g_pos")
            _locals["pos"] = _G_or_601
            _G_python_603, lastError = eval(self._G_expr_602, self.globals, _locals), None
            self.considerError(lastError, "def_g_pos")
            return (_G_python_603, self.currentError)

        def rule_def_m_pos(self):
            _locals = {"self": self}
            self.locals["def_m_pos"] = _locals

            def _G_or_604():
                self._trace("", (10397, 10400), self.input.position)
                _G_apply_605, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_605, self.currentError)

            def _G_or_606():
                self._trace("", (10401, 10404), self.input.position)
                _G_exactly_607, lastError = self.exactly("?")
                self.considerError(lastError, None)
                _G_python_608, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_608, self.currentError)

            _G_or_609, lastError = self._or([_G_or_604, _G_or_606])
            self.considerError(lastError, "def_m_pos")
            _locals["pos"] = _G_or_609
            _G_python_610, lastError = eval(self._G_expr_602, self.globals, _locals), None
            self.considerError(lastError, "def_m_pos")
            return (_G_python_610, self.currentError)

        def rule_def_n_pos(self):
            _locals = {"self": self}
            self.locals["def_n_pos"] = _locals
            self._trace("", (10464, 10469), self.input.position)
            _G_apply_611, lastError = self._apply(self.rule_base, "base", [])
            self.considerError(lastError, "def_n_pos")
            _locals["b"] = _G_apply_611
            self._trace("", (10471, 10478), self.input.position)
            _G_apply_612, lastError = self._apply(self.rule_offset, "offset", [])
            self.considerError(lastError, "def_n_pos")
            _locals["o"] = _G_apply_612
            _G_python_614, lastError = eval(self._G_expr_613, self.globals, _locals), None
            self.considerError(lastError, "def_n_pos")
            return (_G_python_614, self.currentError)

        def rule_def_p_pos(self):
            _locals = {"self": self}
            self.locals["def_p_pos"] = _locals

            def _G_or_615():
                self._trace("", (10568, 10574), self.input.position)
                _G_apply_616, lastError = self._apply(self.rule_term13, "term13", [])
                self.considerError(lastError, None)
                return (_G_apply_616, self.currentError)

            def _G_or_617():
                self._trace("", (10575, 10579), self.input.position)
                _G_apply_618, lastError = self._apply(self.rule_aa13, "aa13", [])
                self.considerError(lastError, None)
                return (_G_apply_618, self.currentError)

            _G_or_619, lastError = self._or([_G_or_615, _G_or_617])
            self.considerError(lastError, "def_p_pos")
            _locals["aa"] = _G_or_619
            self._trace("", (10583, 10587), self.input.position)
            _G_apply_620, lastError = self._apply(self.rule_num, "num", [])
            self.considerError(lastError, "def_p_pos")
            _locals["pos"] = _G_apply_620
            _G_python_622, lastError = eval(self._G_expr_621, self.globals, _locals), None
            self.considerError(lastError, "def_p_pos")
            return (_G_python_622, self.currentError)

        def rule_def_r_pos(self):
            _locals = {"self": self}
            self.locals["def_r_pos"] = _locals
            self._trace("", (10669, 10674), self.input.position)
            _G_apply_623, lastError = self._apply(self.rule_base, "base", [])
            self.considerError(lastError, "def_r_pos")
            _locals["b"] = _G_apply_623
            self._trace("", (10676, 10683), self.input.position)
            _G_apply_624, lastError = self._apply(self.rule_offset, "offset", [])
            self.considerError(lastError, "def_r_pos")
            _locals["o"] = _G_apply_624
            _G_python_625, lastError = eval(self._G_expr_613, self.globals, _locals), None
            self.considerError(lastError, "def_r_pos")
            return (_G_python_625, self.currentError)

        def rule_fs(self):
            _locals = {"self": self}
            self.locals["fs"] = _locals
            self._trace("", (11087, 11092), self.input.position)
            _G_exactly_626, lastError = self.exactly("fs")
            self.considerError(lastError, "fs")

            def _G_or_627():
                self._trace("", (11094, 11101), self.input.position)
                _G_apply_628, lastError = self._apply(self.rule_aa13_fs, "aa13_fs", [])
                self.considerError(lastError, None)
                return (_G_apply_628, self.currentError)

            def _G_or_629():
                _G_python_630, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_630, self.currentError)

            _G_or_631, lastError = self._or([_G_or_627, _G_or_629])
            self.considerError(lastError, "fs")
            _locals["n"] = _G_or_631
            _G_python_633, lastError = eval(self._G_expr_632, self.globals, _locals), None
            self.considerError(lastError, "fs")
            return (_G_python_633, self.currentError)

        def rule_ext(self):
            _locals = {"self": self}
            self.locals["ext"] = _locals
            self._trace("", (11125, 11131), self.input.position)
            _G_exactly_634, lastError = self.exactly("ext")
            self.considerError(lastError, "ext")

            def _G_or_635():
                self._trace("", (11133, 11141), self.input.position)
                _G_apply_636, lastError = self._apply(self.rule_aa13_ext, "aa13_ext", [])
                self.considerError(lastError, None)
                return (_G_apply_636, self.currentError)

            def _G_or_637():
                _G_python_638, lastError = ((None, None)), None
                self.considerError(lastError, None)
                return (_G_python_638, self.currentError)

            _G_or_639, lastError = self._or([_G_or_635, _G_or_637])
            self.considerError(lastError, "ext")
            _locals["aat"] = _G_or_639[0]
            _locals["n"] = _G_or_639[1]
            _G_python_641, lastError = eval(self._G_expr_640, self.globals, _locals), None
            self.considerError(lastError, "ext")
            return (_G_python_641, self.currentError)

        def rule_aa13_fs(self):
            _locals = {"self": self}
            self.locals["aa13_fs"] = _locals
            self._trace("", (11191, 11198), self.input.position)
            _G_apply_642, lastError = self._apply(self.rule_term13, "term13", [])
            self.considerError(lastError, "aa13_fs")
            self._trace("", (11198, 11211), self.input.position)
            _G_apply_643, lastError = self._apply(self.rule_fsext_offset, "fsext_offset", [])
            self.considerError(lastError, "aa13_fs")
            _locals["n"] = _G_apply_643
            _G_python_644, lastError = eval(self._G_expr_632, self.globals, _locals), None
            self.considerError(lastError, "aa13_fs")
            return (_G_python_644, self.currentError)

        def rule_aa13_ext(self):
            _locals = {"self": self}
            self.locals["aa13_ext"] = _locals

            def _G_or_645():
                self._trace("", (11229, 11236), self.input.position)
                _G_apply_646, lastError = self._apply(self.rule_term13, "term13", [])
                self.considerError(lastError, None)
                _locals["aat"] = _G_apply_646
                self._trace("", (11240, 11253), self.input.position)
                _G_apply_647, lastError = self._apply(self.rule_fsext_offset, "fsext_offset", [])
                self.considerError(lastError, None)
                _locals["n"] = _G_apply_647
                _G_python_648, lastError = eval(self._G_expr_640, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_648, self.currentError)

            def _G_or_649():
                def _G_or_650():
                    self._trace("", (11280, 11284), self.input.position)
                    _G_apply_651, lastError = self._apply(self.rule_aa13, "aa13", [])
                    self.considerError(lastError, None)
                    return (_G_apply_651, self.currentError)

                def _G_or_652():
                    _G_python_653, lastError = (None), None
                    self.considerError(lastError, None)
                    return (_G_python_653, self.currentError)

                _G_or_654, lastError = self._or([_G_or_650, _G_or_652])
                self.considerError(lastError, None)
                _locals["aat"] = _G_or_654
                self._trace("", (11301, 11306), self.input.position)
                _G_apply_655, lastError = self._apply(self.rule_nnum, "nnum", [])
                self.considerError(lastError, None)
                _locals["n"] = _G_apply_655
                _G_python_656, lastError = eval(self._G_expr_640, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_656, self.currentError)

            _G_or_657, lastError = self._or([_G_or_645, _G_or_649])
            self.considerError(lastError, "aa13_ext")
            return (_G_or_657, self.currentError)

        def rule_fsext_offset(self):
            _locals = {"self": self}
            self.locals["fsext_offset"] = _locals

            def _G_or_658():
                self._trace("", (11335, 11339), self.input.position)
                _G_apply_659, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_659, self.currentError)

            def _G_or_660():
                self._trace("", (11340, 11343), self.input.position)
                _G_exactly_661, lastError = self.exactly("?")
                self.considerError(lastError, None)
                return (_G_exactly_661, self.currentError)

            def _G_or_662():
                _G_python_663, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_663, self.currentError)

            _G_or_664, lastError = self._or([_G_or_658, _G_or_660, _G_or_662])
            self.considerError(lastError, "fsext_offset")
            return (_G_or_664, self.currentError)

        def rule_dna_seq(self):
            _locals = {"self": self}
            self.locals["dna_seq"] = _locals

            def _G_consumedby_665():
                def _G_many1_666():
                    self._trace("", (11388, 11391), self.input.position)
                    _G_apply_667, lastError = self._apply(self.rule_dna, "dna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_667, self.currentError)

                _G_many1_668, lastError = self.many(_G_many1_666, _G_many1_666())
                self.considerError(lastError, None)
                return (_G_many1_668, self.currentError)

            _G_consumedby_669, lastError = self.consumedby(_G_consumedby_665)
            self.considerError(lastError, "dna_seq")
            return (_G_consumedby_669, self.currentError)

        def rule_rna_seq(self):
            _locals = {"self": self}
            self.locals["rna_seq"] = _locals

            def _G_consumedby_670():
                def _G_many1_671():
                    self._trace("", (11405, 11408), self.input.position)
                    _G_apply_672, lastError = self._apply(self.rule_rna, "rna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_672, self.currentError)

                _G_many1_673, lastError = self.many(_G_many1_671, _G_many1_671())
                self.considerError(lastError, None)
                return (_G_many1_673, self.currentError)

            _G_consumedby_674, lastError = self.consumedby(_G_consumedby_670)
            self.considerError(lastError, "rna_seq")
            return (_G_consumedby_674, self.currentError)

        def rule_aat13_seq(self):
            _locals = {"self": self}
            self.locals["aat13_seq"] = _locals

            def _G_or_675():
                def _G_consumedby_676():
                    self._trace("", (11424, 11432), self.input.position)
                    _G_apply_677, lastError = self._apply(self.rule_aat3_seq, "aat3_seq", [])
                    self.considerError(lastError, None)
                    return (_G_apply_677, self.currentError)

                _G_consumedby_678, lastError = self.consumedby(_G_consumedby_676)
                self.considerError(lastError, None)
                return (_G_consumedby_678, self.currentError)

            def _G_or_679():
                def _G_consumedby_680():
                    self._trace("", (11437, 11445), self.input.position)
                    _G_apply_681, lastError = self._apply(self.rule_aat1_seq, "aat1_seq", [])
                    self.considerError(lastError, None)
                    return (_G_apply_681, self.currentError)

                _G_consumedby_682, lastError = self.consumedby(_G_consumedby_680)
                self.considerError(lastError, None)
                return (_G_consumedby_682, self.currentError)

            _G_or_683, lastError = self._or([_G_or_675, _G_or_679])
            self.considerError(lastError, "aat13_seq")
            return (_G_or_683, self.currentError)

        def rule_aat1_seq(self):
            _locals = {"self": self}
            self.locals["aat1_seq"] = _locals

            def _G_or_684():
                def _G_consumedby_685():
                    self._trace("", (11459, 11464), self.input.position)
                    _G_apply_686, lastError = self._apply(self.rule_term1, "term1", [])
                    self.considerError(lastError, None)
                    return (_G_apply_686, self.currentError)

                _G_consumedby_687, lastError = self.consumedby(_G_consumedby_685)
                self.considerError(lastError, None)
                return (_G_consumedby_687, self.currentError)

            def _G_or_688():
                def _G_consumedby_689():
                    def _G_many1_690():
                        self._trace("", (11469, 11472), self.input.position)
                        _G_apply_691, lastError = self._apply(self.rule_aa1, "aa1", [])
                        self.considerError(lastError, None)
                        return (_G_apply_691, self.currentError)

                    _G_many1_692, lastError = self.many(_G_many1_690, _G_many1_690())
                    self.considerError(lastError, None)

                    def _G_optional_693():
                        self._trace("", (11473, 11479), self.input.position)
                        _G_apply_694, lastError = self._apply(self.rule_term1, "term1", [])
                        self.considerError(lastError, None)
                        return (_G_apply_694, self.currentError)

                    def _G_optional_695():
                        return (None, self.input.nullError())

                    _G_or_696, lastError = self._or([_G_optional_693, _G_optional_695])
                    self.considerError(lastError, None)
                    return (_G_or_696, self.currentError)

                _G_consumedby_697, lastError = self.consumedby(_G_consumedby_689)
                self.considerError(lastError, None)
                return (_G_consumedby_697, self.currentError)

            _G_or_698, lastError = self._or([_G_or_684, _G_or_688])
            self.considerError(lastError, "aat1_seq")
            return (_G_or_698, self.currentError)

        def rule_aat3_seq(self):
            _locals = {"self": self}
            self.locals["aat3_seq"] = _locals

            def _G_or_699():
                def _G_consumedby_700():
                    self._trace("", (11494, 11499), self.input.position)
                    _G_apply_701, lastError = self._apply(self.rule_term3, "term3", [])
                    self.considerError(lastError, None)
                    return (_G_apply_701, self.currentError)

                _G_consumedby_702, lastError = self.consumedby(_G_consumedby_700)
                self.considerError(lastError, None)
                return (_G_consumedby_702, self.currentError)

            def _G_or_703():
                def _G_consumedby_704():
                    def _G_many1_705():
                        self._trace("", (11504, 11507), self.input.position)
                        _G_apply_706, lastError = self._apply(self.rule_aa3, "aa3", [])
                        self.considerError(lastError, None)
                        return (_G_apply_706, self.currentError)

                    _G_many1_707, lastError = self.many(_G_many1_705, _G_many1_705())
                    self.considerError(lastError, None)

                    def _G_optional_708():
                        self._trace("", (11508, 11514), self.input.position)
                        _G_apply_709, lastError = self._apply(self.rule_term3, "term3", [])
                        self.considerError(lastError, None)
                        return (_G_apply_709, self.currentError)

                    def _G_optional_710():
                        return (None, self.input.nullError())

                    _G_or_711, lastError = self._or([_G_optional_708, _G_optional_710])
                    self.considerError(lastError, None)
                    return (_G_or_711, self.currentError)

                _G_consumedby_712, lastError = self.consumedby(_G_consumedby_704)
                self.considerError(lastError, None)
                return (_G_consumedby_712, self.currentError)

            _G_or_713, lastError = self._or([_G_or_699, _G_or_703])
            self.considerError(lastError, "aat3_seq")
            return (_G_or_713, self.currentError)

        def rule_aa13_seq(self):
            _locals = {"self": self}
            self.locals["aa13_seq"] = _locals

            def _G_or_714():
                def _G_consumedby_715():
                    self._trace("", (11529, 11536), self.input.position)
                    _G_apply_716, lastError = self._apply(self.rule_aa3_seq, "aa3_seq", [])
                    self.considerError(lastError, None)
                    return (_G_apply_716, self.currentError)

                _G_consumedby_717, lastError = self.consumedby(_G_consumedby_715)
                self.considerError(lastError, None)
                return (_G_consumedby_717, self.currentError)

            def _G_or_718():
                def _G_consumedby_719():
                    self._trace("", (11541, 11548), self.input.position)
                    _G_apply_720, lastError = self._apply(self.rule_aa1_seq, "aa1_seq", [])
                    self.considerError(lastError, None)
                    return (_G_apply_720, self.currentError)

                _G_consumedby_721, lastError = self.consumedby(_G_consumedby_719)
                self.considerError(lastError, None)
                return (_G_consumedby_721, self.currentError)

            _G_or_722, lastError = self._or([_G_or_714, _G_or_718])
            self.considerError(lastError, "aa13_seq")
            return (_G_or_722, self.currentError)

        def rule_aa1_seq(self):
            _locals = {"self": self}
            self.locals["aa1_seq"] = _locals

            def _G_consumedby_723():
                def _G_many1_724():
                    self._trace("", (11561, 11564), self.input.position)
                    _G_apply_725, lastError = self._apply(self.rule_aa1, "aa1", [])
                    self.considerError(lastError, None)
                    return (_G_apply_725, self.currentError)

                _G_many1_726, lastError = self.many(_G_many1_724, _G_many1_724())
                self.considerError(lastError, None)
                return (_G_many1_726, self.currentError)

            _G_consumedby_727, lastError = self.consumedby(_G_consumedby_723)
            self.considerError(lastError, "aa1_seq")
            return (_G_consumedby_727, self.currentError)

        def rule_aa3_seq(self):
            _locals = {"self": self}
            self.locals["aa3_seq"] = _locals

            def _G_consumedby_728():
                def _G_many1_729():
                    self._trace("", (11578, 11581), self.input.position)
                    _G_apply_730, lastError = self._apply(self.rule_aa3, "aa3", [])
                    self.considerError(lastError, None)
                    return (_G_apply_730, self.currentError)

                _G_many1_731, lastError = self.many(_G_many1_729, _G_many1_729())
                self.considerError(lastError, None)
                return (_G_many1_731, self.currentError)

            _G_consumedby_732, lastError = self.consumedby(_G_consumedby_728)
            self.considerError(lastError, "aa3_seq")
            return (_G_consumedby_732, self.currentError)

        def rule_aa1(self):
            _locals = {"self": self}
            self.locals["aa1"] = _locals
            _G_apply_733, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError, "aa1")
            _locals["x"] = _G_apply_733

            def _G_pred_734():
                _G_python_736, lastError = eval(self._G_expr_735, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_736, self.currentError)

            _G_pred_737, lastError = self.pred(_G_pred_734)
            self.considerError(lastError, "aa1")
            _G_python_739, lastError = eval(self._G_expr_738, self.globals, _locals), None
            self.considerError(lastError, "aa1")
            return (_G_python_739, self.currentError)

        def rule_aa13(self):
            _locals = {"self": self}
            self.locals["aa13"] = _locals

            def _G_or_740():
                self._trace("", (11662, 11666), self.input.position)
                _G_apply_741, lastError = self._apply(self.rule_aa3, "aa3", [])
                self.considerError(lastError, None)
                return (_G_apply_741, self.currentError)

            def _G_or_742():
                self._trace("", (11668, 11672), self.input.position)
                _G_apply_743, lastError = self._apply(self.rule_aa1, "aa1", [])
                self.considerError(lastError, None)
                return (_G_apply_743, self.currentError)

            _G_or_744, lastError = self._or([_G_or_740, _G_or_742])
            self.considerError(lastError, "aa13")
            return (_G_or_744, self.currentError)

        def rule_aa3(self):
            _locals = {"self": self}
            self.locals["aa3"] = _locals

            def _G_or_745():
                self._trace("", (11678, 11684), self.input.position)
                _G_exactly_746, lastError = self.exactly("Ala")
                self.considerError(lastError, None)
                return (_G_exactly_746, self.currentError)

            def _G_or_747():
                self._trace("", (11685, 11690), self.input.position)
                _G_exactly_748, lastError = self.exactly("Cys")
                self.considerError(lastError, None)
                return (_G_exactly_748, self.currentError)

            def _G_or_749():
                self._trace("", (11691, 11696), self.input.position)
                _G_exactly_750, lastError = self.exactly("Asp")
                self.considerError(lastError, None)
                return (_G_exactly_750, self.currentError)

            def _G_or_751():
                self._trace("", (11697, 11702), self.input.position)
                _G_exactly_752, lastError = self.exactly("Glu")
                self.considerError(lastError, None)
                return (_G_exactly_752, self.currentError)

            def _G_or_753():
                self._trace("", (11703, 11708), self.input.position)
                _G_exactly_754, lastError = self.exactly("Phe")
                self.considerError(lastError, None)
                return (_G_exactly_754, self.currentError)

            def _G_or_755():
                self._trace("", (11709, 11714), self.input.position)
                _G_exactly_756, lastError = self.exactly("Gly")
                self.considerError(lastError, None)
                return (_G_exactly_756, self.currentError)

            def _G_or_757():
                self._trace("", (11715, 11720), self.input.position)
                _G_exactly_758, lastError = self.exactly("His")
                self.considerError(lastError, None)
                return (_G_exactly_758, self.currentError)

            def _G_or_759():
                self._trace("", (11721, 11726), self.input.position)
                _G_exactly_760, lastError = self.exactly("Ile")
                self.considerError(lastError, None)
                return (_G_exactly_760, self.currentError)

            def _G_or_761():
                self._trace("", (11727, 11732), self.input.position)
                _G_exactly_762, lastError = self.exactly("Lys")
                self.considerError(lastError, None)
                return (_G_exactly_762, self.currentError)

            def _G_or_763():
                self._trace("", (11733, 11738), self.input.position)
                _G_exactly_764, lastError = self.exactly("Leu")
                self.considerError(lastError, None)
                return (_G_exactly_764, self.currentError)

            def _G_or_765():
                self._trace("", (11739, 11744), self.input.position)
                _G_exactly_766, lastError = self.exactly("Met")
                self.considerError(lastError, None)
                return (_G_exactly_766, self.currentError)

            def _G_or_767():
                self._trace("", (11745, 11750), self.input.position)
                _G_exactly_768, lastError = self.exactly("Asn")
                self.considerError(lastError, None)
                return (_G_exactly_768, self.currentError)

            def _G_or_769():
                self._trace("", (11751, 11756), self.input.position)
                _G_exactly_770, lastError = self.exactly("Pro")
                self.considerError(lastError, None)
                return (_G_exactly_770, self.currentError)

            def _G_or_771():
                self._trace("", (11757, 11762), self.input.position)
                _G_exactly_772, lastError = self.exactly("Gln")
                self.considerError(lastError, None)
                return (_G_exactly_772, self.currentError)

            def _G_or_773():
                self._trace("", (11763, 11768), self.input.position)
                _G_exactly_774, lastError = self.exactly("Arg")
                self.considerError(lastError, None)
                return (_G_exactly_774, self.currentError)

            def _G_or_775():
                self._trace("", (11769, 11774), self.input.position)
                _G_exactly_776, lastError = self.exactly("Ser")
                self.considerError(lastError, None)
                return (_G_exactly_776, self.currentError)

            def _G_or_777():
                self._trace("", (11775, 11780), self.input.position)
                _G_exactly_778, lastError = self.exactly("Thr")
                self.considerError(lastError, None)
                return (_G_exactly_778, self.currentError)

            def _G_or_779():
                self._trace("", (11781, 11786), self.input.position)
                _G_exactly_780, lastError = self.exactly("Val")
                self.considerError(lastError, None)
                return (_G_exactly_780, self.currentError)

            def _G_or_781():
                self._trace("", (11787, 11792), self.input.position)
                _G_exactly_782, lastError = self.exactly("Trp")
                self.considerError(lastError, None)
                return (_G_exactly_782, self.currentError)

            def _G_or_783():
                self._trace("", (11793, 11798), self.input.position)
                _G_exactly_784, lastError = self.exactly("Tyr")
                self.considerError(lastError, None)
                return (_G_exactly_784, self.currentError)

            def _G_or_785():
                self._trace("", (11800, 11806), self.input.position)
                _G_exactly_786, lastError = self.exactly("Asx")
                self.considerError(lastError, None)
                return (_G_exactly_786, self.currentError)

            def _G_or_787():
                self._trace("", (11808, 11814), self.input.position)
                _G_exactly_788, lastError = self.exactly("Glx")
                self.considerError(lastError, None)
                return (_G_exactly_788, self.currentError)

            def _G_or_789():
                self._trace("", (11816, 11822), self.input.position)
                _G_exactly_790, lastError = self.exactly("Xaa")
                self.considerError(lastError, None)
                return (_G_exactly_790, self.currentError)

            def _G_or_791():
                self._trace("", (11824, 11830), self.input.position)
                _G_exactly_792, lastError = self.exactly("Sec")
                self.considerError(lastError, None)
                return (_G_exactly_792, self.currentError)

            _G_or_793, lastError = self._or(
                [
                    _G_or_745,
                    _G_or_747,
                    _G_or_749,
                    _G_or_751,
                    _G_or_753,
                    _G_or_755,
                    _G_or_757,
                    _G_or_759,
                    _G_or_761,
                    _G_or_763,
                    _G_or_765,
                    _G_or_767,
                    _G_or_769,
                    _G_or_771,
                    _G_or_773,
                    _G_or_775,
                    _G_or_777,
                    _G_or_779,
                    _G_or_781,
                    _G_or_783,
                    _G_or_785,
                    _G_or_787,
                    _G_or_789,
                    _G_or_791,
                ]
            )
            self.considerError(lastError, "aa3")
            return (_G_or_793, self.currentError)

        def rule_aat1(self):
            _locals = {"self": self}
            self.locals["aat1"] = _locals

            def _G_or_794():
                self._trace("", (11837, 11843), self.input.position)
                _G_apply_795, lastError = self._apply(self.rule_term1, "term1", [])
                self.considerError(lastError, None)
                return (_G_apply_795, self.currentError)

            def _G_or_796():
                self._trace("", (11845, 11849), self.input.position)
                _G_apply_797, lastError = self._apply(self.rule_aa1, "aa1", [])
                self.considerError(lastError, None)
                return (_G_apply_797, self.currentError)

            _G_or_798, lastError = self._or([_G_or_794, _G_or_796])
            self.considerError(lastError, "aat1")
            return (_G_or_798, self.currentError)

        def rule_aat13(self):
            _locals = {"self": self}
            self.locals["aat13"] = _locals

            def _G_or_799():
                self._trace("", (11857, 11862), self.input.position)
                _G_apply_800, lastError = self._apply(self.rule_aat3, "aat3", [])
                self.considerError(lastError, None)
                return (_G_apply_800, self.currentError)

            def _G_or_801():
                self._trace("", (11864, 11869), self.input.position)
                _G_apply_802, lastError = self._apply(self.rule_aat1, "aat1", [])
                self.considerError(lastError, None)
                return (_G_apply_802, self.currentError)

            _G_or_803, lastError = self._or([_G_or_799, _G_or_801])
            self.considerError(lastError, "aat13")
            return (_G_or_803, self.currentError)

        def rule_aat3(self):
            _locals = {"self": self}
            self.locals["aat3"] = _locals

            def _G_or_804():
                self._trace("", (11876, 11882), self.input.position)
                _G_apply_805, lastError = self._apply(self.rule_term3, "term3", [])
                self.considerError(lastError, None)
                return (_G_apply_805, self.currentError)

            def _G_or_806():
                self._trace("", (11884, 11888), self.input.position)
                _G_apply_807, lastError = self._apply(self.rule_aa3, "aa3", [])
                self.considerError(lastError, None)
                return (_G_apply_807, self.currentError)

            _G_or_808, lastError = self._or([_G_or_804, _G_or_806])
            self.considerError(lastError, "aat3")
            return (_G_or_808, self.currentError)

        def rule_dna(self):
            _locals = {"self": self}
            self.locals["dna"] = _locals
            self._trace("", (11894, 11904), self.input.position)
            _G_apply_809, lastError = self._apply(self.rule_dna_iupac, "dna_iupac", [])
            self.considerError(lastError, "dna")
            return (_G_apply_809, self.currentError)

        def rule_dna_iupac(self):
            _locals = {"self": self}
            self.locals["dna_iupac"] = _locals
            _G_apply_810, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError, "dna_iupac")
            _locals["x"] = _G_apply_810

            def _G_pred_811():
                _G_python_813, lastError = eval(self._G_expr_812, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_813, self.currentError)

            _G_pred_814, lastError = self.pred(_G_pred_811)
            self.considerError(lastError, "dna_iupac")
            _G_python_815, lastError = eval(self._G_expr_738, self.globals, _locals), None
            self.considerError(lastError, "dna_iupac")
            return (_G_python_815, self.currentError)

        def rule_na_iupac(self):
            _locals = {"self": self}
            self.locals["na_iupac"] = _locals
            _G_apply_816, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError, "na_iupac")
            _locals["x"] = _G_apply_816

            def _G_pred_817():
                _G_python_819, lastError = eval(self._G_expr_818, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_819, self.currentError)

            _G_pred_820, lastError = self.pred(_G_pred_817)
            self.considerError(lastError, "na_iupac")
            _G_python_821, lastError = eval(self._G_expr_738, self.globals, _locals), None
            self.considerError(lastError, "na_iupac")
            return (_G_python_821, self.currentError)

        def rule_rna(self):
            _locals = {"self": self}
            self.locals["rna"] = _locals
            self._trace("", (12033, 12043), self.input.position)
            _G_apply_822, lastError = self._apply(self.rule_rna_iupac, "rna_iupac", [])
            self.considerError(lastError, "rna")
            return (_G_apply_822, self.currentError)

        def rule_rna_iupac(self):
            _locals = {"self": self}
            self.locals["rna_iupac"] = _locals
            _G_apply_823, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError, "rna_iupac")
            _locals["x"] = _G_apply_823

            def _G_pred_824():
                _G_python_826, lastError = eval(self._G_expr_825, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_826, self.currentError)

            _G_pred_827, lastError = self.pred(_G_pred_824)
            self.considerError(lastError, "rna_iupac")
            _G_python_828, lastError = eval(self._G_expr_738, self.globals, _locals), None
            self.considerError(lastError, "rna_iupac")
            return (_G_python_828, self.currentError)

        def rule_term1(self):
            _locals = {"self": self}
            self.locals["term1"] = _locals
            _G_apply_829, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError, "term1")
            _locals["x"] = _G_apply_829

            def _G_pred_830():
                _G_python_832, lastError = eval(self._G_expr_831, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_832, self.currentError)

            _G_pred_833, lastError = self.pred(_G_pred_830)
            self.considerError(lastError, "term1")
            _G_python_834, lastError = eval(self._G_expr_738, self.globals, _locals), None
            self.considerError(lastError, "term1")
            return (_G_python_834, self.currentError)

        def rule_term13(self):
            _locals = {"self": self}
            self.locals["term13"] = _locals

            def _G_or_835():
                self._trace("", (12142, 12148), self.input.position)
                _G_apply_836, lastError = self._apply(self.rule_term3, "term3", [])
                self.considerError(lastError, None)
                return (_G_apply_836, self.currentError)

            def _G_or_837():
                self._trace("", (12150, 12156), self.input.position)
                _G_apply_838, lastError = self._apply(self.rule_term1, "term1", [])
                self.considerError(lastError, None)
                return (_G_apply_838, self.currentError)

            _G_or_839, lastError = self._or([_G_or_835, _G_or_837])
            self.considerError(lastError, "term13")
            return (_G_or_839, self.currentError)

        def rule_term3(self):
            _locals = {"self": self}
            self.locals["term3"] = _locals
            self._trace("", (12164, 12170), self.input.position)
            _G_exactly_840, lastError = self.exactly("Ter")
            self.considerError(lastError, "term3")
            return (_G_exactly_840, self.currentError)

        def rule_base(self):
            _locals = {"self": self}
            self.locals["base"] = _locals
            self._trace("", (12254, 12259), self.input.position)
            _G_apply_841, lastError = self._apply(self.rule_snum, "snum", [])
            self.considerError(lastError, "base")
            return (_G_apply_841, self.currentError)

        def rule_nnum(self):
            _locals = {"self": self}
            self.locals["nnum"] = _locals

            def _G_consumedby_842():
                self._trace("", (12268, 12271), self.input.position)
                _G_exactly_843, lastError = self.exactly("-")
                self.considerError(lastError, None)
                self._trace("", (12271, 12275), self.input.position)
                _G_apply_844, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_844, self.currentError)

            _G_consumedby_845, lastError = self.consumedby(_G_consumedby_842)
            self.considerError(lastError, "nnum")
            _locals["x"] = _G_consumedby_845
            _G_python_847, lastError = eval(self._G_expr_846, self.globals, _locals), None
            self.considerError(lastError, "nnum")
            return (_G_python_847, self.currentError)

        def rule_num(self):
            _locals = {"self": self}
            self.locals["num"] = _locals

            def _G_consumedby_848():
                def _G_many1_849():
                    self._trace("", (12296, 12301), self.input.position)
                    _G_apply_850, lastError = self._apply(self.rule_digit, "digit", [])
                    self.considerError(lastError, None)
                    return (_G_apply_850, self.currentError)

                _G_many1_851, lastError = self.many(_G_many1_849, _G_many1_849())
                self.considerError(lastError, None)
                return (_G_many1_851, self.currentError)

            _G_consumedby_852, lastError = self.consumedby(_G_consumedby_848)
            self.considerError(lastError, "num")
            _locals["x"] = _G_consumedby_852
            _G_python_853, lastError = eval(self._G_expr_846, self.globals, _locals), None
            self.considerError(lastError, "num")
            return (_G_python_853, self.currentError)

        def rule_offset(self):
            _locals = {"self": self}
            self.locals["offset"] = _locals

            def _G_or_854():
                self._trace("", (12324, 12329), self.input.position)
                _G_apply_855, lastError = self._apply(self.rule_snum, "snum", [])
                self.considerError(lastError, None)
                return (_G_apply_855, self.currentError)

            def _G_or_856():
                _G_python_857, lastError = (0), None
                self.considerError(lastError, None)
                return (_G_python_857, self.currentError)

            _G_or_858, lastError = self._or([_G_or_854, _G_or_856])
            self.considerError(lastError, "offset")
            return (_G_or_858, self.currentError)

        def rule_pm(self):
            _locals = {"self": self}
            self.locals["pm"] = _locals
            _G_apply_859, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError, "pm")
            _locals["x"] = _G_apply_859

            def _G_pred_860():
                _G_python_862, lastError = eval(self._G_expr_861, self.globals, _locals), None
                self.considerError(lastError, None)
                return (_G_python_862, self.currentError)

            _G_pred_863, lastError = self.pred(_G_pred_860)
            self.considerError(lastError, "pm")
            _G_python_864, lastError = eval(self._G_expr_738, self.globals, _locals), None
            self.considerError(lastError, "pm")
            return (_G_python_864, self.currentError)

        def rule_snum(self):
            _locals = {"self": self}
            self.locals["snum"] = _locals

            def _G_consumedby_865():
                def _G_optional_866():
                    self._trace("", (12373, 12375), self.input.position)
                    _G_apply_867, lastError = self._apply(self.rule_pm, "pm", [])
                    self.considerError(lastError, None)
                    return (_G_apply_867, self.currentError)

                def _G_optional_868():
                    return (None, self.input.nullError())

                _G_or_869, lastError = self._or([_G_optional_866, _G_optional_868])
                self.considerError(lastError, None)
                self._trace("", (12376, 12380), self.input.position)
                _G_apply_870, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_870, self.currentError)

            _G_consumedby_871, lastError = self.consumedby(_G_consumedby_865)
            self.considerError(lastError, "snum")
            _locals["x"] = _G_consumedby_871
            _G_python_872, lastError = eval(self._G_expr_846, self.globals, _locals), None
            self.considerError(lastError, "snum")
            return (_G_python_872, self.currentError)

        def rule_accn(self):
            _locals = {"self": self}
            self.locals["accn"] = _locals

            def _G_consumedby_873():
                self._trace("", (12484, 12490), self.input.position)
                _G_apply_874, lastError = self._apply(self.rule_letter, "letter", [])
                self.considerError(lastError, None)

                def _G_optional_875():
                    def _G_many1_876():
                        def _G_or_877():
                            self._trace("", (12493, 12506), self.input.position)
                            _G_apply_878, lastError = self._apply(
                                self.rule_letterOrDigit, "letterOrDigit", []
                            )
                            self.considerError(lastError, None)
                            return (_G_apply_878, self.currentError)

                        def _G_or_879():
                            def _G_or_880():
                                self._trace("", (12510, 12513), self.input.position)
                                _G_exactly_881, lastError = self.exactly("-")
                                self.considerError(lastError, None)
                                return (_G_exactly_881, self.currentError)

                            def _G_or_882():
                                self._trace("", (12514, 12517), self.input.position)
                                _G_exactly_883, lastError = self.exactly("_")
                                self.considerError(lastError, None)
                                return (_G_exactly_883, self.currentError)

                            _G_or_884, lastError = self._or([_G_or_880, _G_or_882])
                            self.considerError(lastError, None)

                            def _G_lookahead_885():
                                self._trace("", (12521, 12534), self.input.position)
                                _G_apply_886, lastError = self._apply(
                                    self.rule_letterOrDigit, "letterOrDigit", []
                                )
                                self.considerError(lastError, None)
                                return (_G_apply_886, self.currentError)

                            _G_lookahead_887, lastError = self.lookahead(_G_lookahead_885)
                            self.considerError(lastError, None)
                            return (_G_lookahead_887, self.currentError)

                        _G_or_888, lastError = self._or([_G_or_877, _G_or_879])
                        self.considerError(lastError, None)
                        return (_G_or_888, self.currentError)

                    _G_many1_889, lastError = self.many(_G_many1_876, _G_many1_876())
                    self.considerError(lastError, None)
                    return (_G_many1_889, self.currentError)

                def _G_optional_890():
                    return (None, self.input.nullError())

                _G_or_891, lastError = self._or([_G_optional_875, _G_optional_890])
                self.considerError(lastError, None)

                def _G_optional_892():
                    self._trace("", (12540, 12543), self.input.position)
                    _G_exactly_893, lastError = self.exactly(".")
                    self.considerError(lastError, None)

                    def _G_many1_894():
                        self._trace("", (12543, 12549), self.input.position)
                        _G_apply_895, lastError = self._apply(self.rule_digit, "digit", [])
                        self.considerError(lastError, None)
                        return (_G_apply_895, self.currentError)

                    _G_many1_896, lastError = self.many(_G_many1_894, _G_many1_894())
                    self.considerError(lastError, None)
                    return (_G_many1_896, self.currentError)

                def _G_optional_897():
                    return (None, self.input.nullError())

                _G_or_898, lastError = self._or([_G_optional_892, _G_optional_897])
                self.considerError(lastError, None)
                return (_G_or_898, self.currentError)

            _G_consumedby_899, lastError = self.consumedby(_G_consumedby_873)
            self.considerError(lastError, "accn")
            return (_G_consumedby_899, self.currentError)

        def rule_opt_gene_expr(self):
            _locals = {"self": self}
            self.locals["opt_gene_expr"] = _locals

            def _G_or_900():
                self._trace("", (12571, 12581), self.input.position)
                _G_apply_901, lastError = self._apply(self.rule_paren_gene, "paren_gene", [])
                self.considerError(lastError, None)
                return (_G_apply_901, self.currentError)

            def _G_or_902():
                _G_python_903, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_903, self.currentError)

            _G_or_904, lastError = self._or([_G_or_900, _G_or_902])
            self.considerError(lastError, "opt_gene_expr")
            _locals["gene"] = _G_or_904
            _G_python_906, lastError = eval(self._G_expr_905, self.globals, _locals), None
            self.considerError(lastError, "opt_gene_expr")
            return (_G_python_906, self.currentError)

        def rule_paren_gene(self):
            _locals = {"self": self}
            self.locals["paren_gene"] = _locals
            self._trace("", (12617, 12621), self.input.position)
            _G_exactly_907, lastError = self.exactly("(")
            self.considerError(lastError, "paren_gene")
            self._trace("", (12621, 12633), self.input.position)
            _G_apply_908, lastError = self._apply(self.rule_gene_symbol, "gene_symbol", [])
            self.considerError(lastError, "paren_gene")
            _locals["symbol"] = _G_apply_908
            self._trace("", (12640, 12644), self.input.position)
            _G_exactly_909, lastError = self.exactly(")")
            self.considerError(lastError, "paren_gene")
            _G_python_911, lastError = eval(self._G_expr_910, self.globals, _locals), None
            self.considerError(lastError, "paren_gene")
            return (_G_python_911, self.currentError)

        def rule_gene_symbol(self):
            _locals = {"self": self}
            self.locals["gene_symbol"] = _locals

            def _G_consumedby_912():
                self._trace("", (12670, 12676), self.input.position)
                _G_apply_913, lastError = self._apply(self.rule_letter, "letter", [])
                self.considerError(lastError, None)

                def _G_many1_914():
                    def _G_or_915():
                        self._trace("", (12678, 12691), self.input.position)
                        _G_apply_916, lastError = self._apply(
                            self.rule_letterOrDigit, "letterOrDigit", []
                        )
                        self.considerError(lastError, None)
                        return (_G_apply_916, self.currentError)

                    def _G_or_917():
                        def _G_or_918():
                            self._trace("", (12695, 12698), self.input.position)
                            _G_exactly_919, lastError = self.exactly("-")
                            self.considerError(lastError, None)
                            return (_G_exactly_919, self.currentError)

                        def _G_or_920():
                            self._trace("", (12699, 12702), self.input.position)
                            _G_exactly_921, lastError = self.exactly("_")
                            self.considerError(lastError, None)
                            return (_G_exactly_921, self.currentError)

                        _G_or_922, lastError = self._or([_G_or_918, _G_or_920])
                        self.considerError(lastError, None)

                        def _G_lookahead_923():
                            self._trace("", (12706, 12719), self.input.position)
                            _G_apply_924, lastError = self._apply(
                                self.rule_letterOrDigit, "letterOrDigit", []
                            )
                            self.considerError(lastError, None)
                            return (_G_apply_924, self.currentError)

                        _G_lookahead_925, lastError = self.lookahead(_G_lookahead_923)
                        self.considerError(lastError, None)
                        return (_G_lookahead_925, self.currentError)

                    _G_or_926, lastError = self._or([_G_or_915, _G_or_917])
                    self.considerError(lastError, None)
                    return (_G_or_926, self.currentError)

                _G_many1_927, lastError = self.many(_G_many1_914, _G_many1_914())
                self.considerError(lastError, None)
                return (_G_many1_927, self.currentError)

            _G_consumedby_928, lastError = self.consumedby(_G_consumedby_912)
            self.considerError(lastError, "gene_symbol")
            return (_G_consumedby_928, self.currentError)

        _G_expr_20 = compile(
            "hgvs.sequencevariant.SequenceVariant(ac=ac, gene=gene, type=type, posedit=posedit)",
            "<string>",
            "eval",
        )
        _G_expr_76 = compile(
            "hgvs.hgvsposition.HGVSPosition(ac=ac, gene=gene, type=type, pos=pos)",
            "<string>",
            "eval",
        )
        _G_expr_116 = compile(
            "hgvs.sequencevariant.SequenceVariant(None,type,posedit)", "<string>", "eval"
        )
        _G_expr_140 = compile("hgvs.posedit.PosEdit(pos=pos,edit=edit)", "<string>", "eval")
        _G_expr_160 = compile(
            "hgvs.posedit.PosEdit(pos=pos,edit=edit, uncertain=True)", "<string>", "eval"
        )
        _G_expr_178 = compile(
            "hgvs.posedit.PosEdit(pos=None,edit=x,uncertain=False)", "<string>", "eval"
        )
        _G_expr_184 = compile(
            "hgvs.posedit.PosEdit(pos=None,edit=x,uncertain=True)", "<string>", "eval"
        )
        _G_expr_203 = compile("edit._set_uncertain()", "<string>", "eval")
        _G_expr_231 = compile("hgvs.edit.NARefAlt(ref=ref,alt=ref)", "<string>", "eval")
        _G_expr_236 = compile("hgvs.edit.NARefAlt(ref=ref,alt=alt)", "<string>", "eval")
        _G_expr_269 = compile("hgvs.edit.NARefAlt(ref=ref,alt=None)", "<string>", "eval")
        _G_expr_277 = compile("hgvs.edit.NARefAlt(ref=None,alt=alt)", "<string>", "eval")
        _G_expr_285 = compile("hgvs.edit.Dup(ref=ref)", "<string>", "eval")
        _G_expr_299 = compile("hgvs.edit.Inv(ref=None)", "<string>", "eval")
        _G_expr_303 = compile(
            "hgvs.edit.Conv(from_ac=pos.ac, from_type=pos.type, from_pos=pos.pos)",
            "<string>",
            "eval",
        )
        _G_expr_307 = compile("hgvs.edit.NACopy(copy=n)", "<string>", "eval")
        _G_expr_437 = compile("hgvs.edit.AASub(ref='',alt=alt)", "<string>", "eval")
        _G_expr_441 = compile("hgvs.edit.AARefAlt(ref='',alt=alt)", "<string>", "eval")
        _G_expr_444 = compile("hgvs.edit.AARefAlt(ref='',alt=None)", "<string>", "eval")
        _G_expr_448 = compile("hgvs.edit.AARefAlt(ref=None,alt=alt)", "<string>", "eval")
        _G_expr_451 = compile("hgvs.edit.Dup(ref='')", "<string>", "eval")
        _G_expr_459 = compile("hgvs.edit.AAFs(ref='', alt=alt, length=length)", "<string>", "eval")
        _G_expr_466 = compile(
            "hgvs.edit.AAExt(ref='', alt=alt, aaterm=aaterm, length=length)", "<string>", "eval"
        )
        _G_expr_469 = compile("hgvs.edit.AARefAlt(ref='',alt='')", "<string>", "eval")
        _G_expr_477 = compile("iv._set_uncertain()", "<string>", "eval")
        _G_expr_524 = compile("hgvs.location.Interval(start,end)", "<string>", "eval")
        _G_expr_528 = compile(
            "hgvs.location.Interval(start,copy.deepcopy(start))", "<string>", "eval"
        )
        _G_expr_562 = compile("hgvs.location.BaseOffsetInterval(start,end)", "<string>", "eval")
        _G_expr_566 = compile(
            "hgvs.location.BaseOffsetInterval(start,copy.deepcopy(start))", "<string>", "eval"
        )
        _G_expr_587 = compile(
            "hgvs.location.BaseOffsetPosition(b,o,datum=hgvs.enums.Datum.CDS_START)",
            "<string>",
            "eval",
        )
        _G_expr_593 = compile(
            "hgvs.location.BaseOffsetPosition(b,o,datum=hgvs.enums.Datum.CDS_END)",
            "<string>",
            "eval",
        )
        _G_expr_602 = compile("hgvs.location.SimplePosition(pos)", "<string>", "eval")
        _G_expr_613 = compile(
            "hgvs.location.BaseOffsetPosition(b,o,datum=hgvs.enums.Datum.SEQ_START)",
            "<string>",
            "eval",
        )
        _G_expr_621 = compile(
            "hgvs.location.AAPosition(pos,bioutils.sequences.aa_to_aa1(aa))", "<string>", "eval"
        )
        _G_expr_632 = compile("n", "<string>", "eval")
        _G_expr_640 = compile("(aat, n)", "<string>", "eval")
        _G_expr_735 = compile("x in 'ACDEFGHIKLMNPQRSTVWYBZXU'", "<string>", "eval")
        _G_expr_738 = compile("x", "<string>", "eval")
        _G_expr_812 = compile("x in 'ACGTRYMKWSBDHVNacgtrymkwsbdhvn'", "<string>", "eval")
        _G_expr_818 = compile("x in 'ACGTURYMKWSBDHVNacgturymkwsbdhvn'", "<string>", "eval")
        _G_expr_825 = compile("x in 'ACGURYMKWSBDHVNacgurymkwsbdhvn'", "<string>", "eval")
        _G_expr_831 = compile("x in 'X*'", "<string>", "eval")
        _G_expr_846 = compile("int(x)", "<string>", "eval")
        _G_expr_861 = compile("x in '-+'", "<string>", "eval")
        _G_expr_905 = compile("gene", "<string>", "eval")
        _G_expr_910 = compile("symbol", "<string>", "eval")

    if Grammar.globals is not None:
        Grammar.globals = Grammar.globals.copy()
        Grammar.globals.update(ruleGlobals)
    else:
        Grammar.globals = ruleGlobals
    return Grammar
