# --------------------------------------------------
# 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: 328ee7eeb36c4280cedde699f3ea3ab5
# Parsley version: 1.3
#  Python version: 3.13.3 (main, Apr  8 2025, 13:54:08) [Clang 16.0.0 (clang-1600.0.26.6)]
# --------------------------------------------------


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("", (1919, 1935), 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("", (1937, 1953), 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("", (1955, 1971), 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("", (1973, 1989), 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("", (1991, 2007), 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("", (2009, 2025), 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("", (2044, 2049), 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("", (2052, 2066), 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("", (2071, 2075), self.input.position)
            _G_exactly_72, lastError = self.exactly(":")
            self.considerError(lastError, "c_hgvs_position")
            self._trace("", (2075, 2079), self.input.position)
            _G_exactly_73, lastError = self.exactly("c")
            self.considerError(lastError, "c_hgvs_position")
            _locals["type"] = _G_exactly_73
            self._trace("", (2084, 2088), self.input.position)
            _G_exactly_74, lastError = self.exactly(".")
            self.considerError(lastError, "c_hgvs_position")
            self._trace("", (2088, 2099), 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("", (2193, 2198), 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("", (2201, 2215), 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("", (2220, 2224), self.input.position)
            _G_exactly_80, lastError = self.exactly(":")
            self.considerError(lastError, "g_hgvs_position")
            self._trace("", (2224, 2228), self.input.position)
            _G_exactly_81, lastError = self.exactly("g")
            self.considerError(lastError, "g_hgvs_position")
            _locals["type"] = _G_exactly_81
            self._trace("", (2233, 2237), self.input.position)
            _G_exactly_82, lastError = self.exactly(".")
            self.considerError(lastError, "g_hgvs_position")
            self._trace("", (2237, 2248), 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("", (2342, 2347), 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("", (2350, 2364), 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("", (2369, 2373), self.input.position)
            _G_exactly_87, lastError = self.exactly(":")
            self.considerError(lastError, "m_hgvs_position")
            self._trace("", (2373, 2377), self.input.position)
            _G_exactly_88, lastError = self.exactly("m")
            self.considerError(lastError, "m_hgvs_position")
            _locals["type"] = _G_exactly_88
            self._trace("", (2382, 2386), self.input.position)
            _G_exactly_89, lastError = self.exactly(".")
            self.considerError(lastError, "m_hgvs_position")
            self._trace("", (2386, 2397), 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("", (2491, 2496), 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("", (2499, 2513), 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("", (2518, 2522), self.input.position)
            _G_exactly_94, lastError = self.exactly(":")
            self.considerError(lastError, "n_hgvs_position")
            self._trace("", (2522, 2526), self.input.position)
            _G_exactly_95, lastError = self.exactly("n")
            self.considerError(lastError, "n_hgvs_position")
            _locals["type"] = _G_exactly_95
            self._trace("", (2531, 2535), self.input.position)
            _G_exactly_96, lastError = self.exactly(".")
            self.considerError(lastError, "n_hgvs_position")
            self._trace("", (2535, 2546), 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("", (2640, 2645), 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("", (2648, 2662), 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("", (2667, 2671), self.input.position)
            _G_exactly_101, lastError = self.exactly(":")
            self.considerError(lastError, "p_hgvs_position")
            self._trace("", (2671, 2675), self.input.position)
            _G_exactly_102, lastError = self.exactly("p")
            self.considerError(lastError, "p_hgvs_position")
            _locals["type"] = _G_exactly_102
            self._trace("", (2680, 2684), self.input.position)
            _G_exactly_103, lastError = self.exactly(".")
            self.considerError(lastError, "p_hgvs_position")
            self._trace("", (2684, 2695), 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("", (2789, 2794), 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("", (2797, 2811), 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("", (2816, 2820), self.input.position)
            _G_exactly_108, lastError = self.exactly(":")
            self.considerError(lastError, "r_hgvs_position")
            self._trace("", (2820, 2824), self.input.position)
            _G_exactly_109, lastError = self.exactly("r")
            self.considerError(lastError, "r_hgvs_position")
            _locals["type"] = _G_exactly_109
            self._trace("", (2829, 2833), self.input.position)
            _G_exactly_110, lastError = self.exactly(".")
            self.considerError(lastError, "r_hgvs_position")
            self._trace("", (2833, 2844), 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("", (3248, 3252), self.input.position)
            _G_exactly_113, lastError = self.exactly("c")
            self.considerError(lastError, "c_typed_posedit")
            _locals["type"] = _G_exactly_113
            self._trace("", (3257, 3261), self.input.position)
            _G_exactly_114, lastError = self.exactly(".")
            self.considerError(lastError, "c_typed_posedit")
            self._trace("", (3261, 3271), 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("", (3356, 3360), self.input.position)
            _G_exactly_118, lastError = self.exactly("g")
            self.considerError(lastError, "g_typed_posedit")
            _locals["type"] = _G_exactly_118
            self._trace("", (3365, 3369), self.input.position)
            _G_exactly_119, lastError = self.exactly(".")
            self.considerError(lastError, "g_typed_posedit")
            self._trace("", (3369, 3379), 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("", (3464, 3468), self.input.position)
            _G_exactly_122, lastError = self.exactly("m")
            self.considerError(lastError, "m_typed_posedit")
            _locals["type"] = _G_exactly_122
            self._trace("", (3473, 3477), self.input.position)
            _G_exactly_123, lastError = self.exactly(".")
            self.considerError(lastError, "m_typed_posedit")
            self._trace("", (3477, 3487), 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("", (3572, 3576), self.input.position)
            _G_exactly_126, lastError = self.exactly("n")
            self.considerError(lastError, "n_typed_posedit")
            _locals["type"] = _G_exactly_126
            self._trace("", (3581, 3585), self.input.position)
            _G_exactly_127, lastError = self.exactly(".")
            self.considerError(lastError, "n_typed_posedit")
            self._trace("", (3585, 3595), 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("", (3680, 3684), self.input.position)
            _G_exactly_130, lastError = self.exactly("p")
            self.considerError(lastError, "p_typed_posedit")
            _locals["type"] = _G_exactly_130
            self._trace("", (3689, 3693), self.input.position)
            _G_exactly_131, lastError = self.exactly(".")
            self.considerError(lastError, "p_typed_posedit")
            self._trace("", (3693, 3703), 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("", (3788, 3792), self.input.position)
            _G_exactly_134, lastError = self.exactly("r")
            self.considerError(lastError, "r_typed_posedit")
            _locals["type"] = _G_exactly_134
            self._trace("", (3797, 3801), self.input.position)
            _G_exactly_135, lastError = self.exactly(".")
            self.considerError(lastError, "r_typed_posedit")
            self._trace("", (3801, 3811), 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("", (4009, 4020), 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("", (4024, 4033), 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("", (4093, 4104), 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("", (4108, 4117), 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("", (4177, 4188), 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("", (4192, 4201), 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("", (4261, 4272), 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("", (4276, 4285), 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("", (4347, 4357), 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("", (4361, 4370), 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("", (4426, 4429), self.input.position)
                _G_exactly_156, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (4429, 4440), 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("", (4444, 4453), 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("", (4458, 4462), 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("", (4539, 4549), 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("", (4553, 4562), 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("", (4618, 4621), self.input.position)
                _G_exactly_168, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (4621, 4632), 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("", (4636, 4645), 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("", (4650, 4654), 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("", (4719, 4737), 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("", (4757, 4767), 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("", (4829, 4833), self.input.position)
                _G_exactly_181, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (4833, 4837), self.input.position)
                _G_exactly_182, lastError = self.exactly("=")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_182
                self._trace("", (4839, 4843), 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("", (4902, 4906), self.input.position)
                _G_exactly_187, lastError = self.exactly("0")
                self.considerError(lastError, None)
                _locals["x"] = _G_exactly_187
                self._trace("", (4908, 4912), 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("", (4971, 4975), 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("", (5037, 5041), 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("", (5392, 5401), 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("", (5403, 5407), self.input.position)
                _G_exactly_200, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (5407, 5416), 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("", (5421, 5425), 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("", (5463, 5473), 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("", (5475, 5485), 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("", (5487, 5498), 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("", (5500, 5508), 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("", (5510, 5518), 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("", (5520, 5528), 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("", (5530, 5538), 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("", (5540, 5548), 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("", (5550, 5559), 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("", (5574, 5577), 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("", (5583, 5587), 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("", (5649, 5653), 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("", (5657, 5661), self.input.position)
            _G_exactly_234, lastError = self.exactly(">")
            self.considerError(lastError, "dna_subst")
            self._trace("", (5661, 5665), 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("", (5726, 5732), 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("", (5735, 5738), 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("", (5741, 5744), 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("", (5751, 5757), 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("", (5759, 5762), 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("", (5821, 5827), 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("", (5830, 5833), 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("", (5836, 5839), 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("", (5899, 5905), 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("", (5907, 5910), 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("", (5977, 5983), 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("", (5985, 5988), 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("", (6041, 6047), 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("", (6050, 6053), 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("", (6056, 6059), 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("", (6106, 6112), self.input.position)
            _G_exactly_301, lastError = self.exactly("con")
            self.considerError(lastError, "dna_con")
            self._trace("", (6112, 6126), 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("", (6216, 6223), self.input.position)
            _G_exactly_305, lastError = self.exactly("copy")
            self.considerError(lastError, "dna_copy")
            self._trace("", (6223, 6227), 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("", (6272, 6281), 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("", (6283, 6287), self.input.position)
                _G_exactly_312, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (6287, 6296), 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("", (6301, 6305), 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("", (6343, 6353), 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("", (6355, 6365), 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("", (6367, 6378), 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("", (6380, 6388), 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("", (6390, 6398), 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("", (6400, 6408), 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("", (6410, 6418), 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("", (6420, 6428), 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("", (6443, 6446), 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("", (6452, 6456), 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("", (6525, 6529), 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("", (6533, 6537), self.input.position)
            _G_exactly_342, lastError = self.exactly(">")
            self.considerError(lastError, "rna_subst")
            self._trace("", (6537, 6541), 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("", (6609, 6615), 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("", (6618, 6621), 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("", (6624, 6627), 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("", (6634, 6640), 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("", (6642, 6645), 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("", (6704, 6710), 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("", (6713, 6716), 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("", (6719, 6722), 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("", (6789, 6795), 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("", (6797, 6800), 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("", (6874, 6880), 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("", (6882, 6885), 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("", (6945, 6951), 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("", (6954, 6957), 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("", (6960, 6963), 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("", (7017, 7023), self.input.position)
            _G_exactly_404, lastError = self.exactly("con")
            self.considerError(lastError, "rna_con")
            self._trace("", (7023, 7037), 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("", (7136, 7145), 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("", (7147, 7151), self.input.position)
                _G_exactly_410, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (7151, 7160), 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("", (7165, 7169), 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("", (7207, 7214), 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("", (7216, 7224), 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("", (7226, 7236), 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("", (7238, 7249), 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("", (7251, 7259), 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("", (7261, 7269), 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("", (7271, 7279), 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("", (7281, 7291), 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("", (7306, 7311), 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("", (7312, 7315), 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("", (7384, 7393), self.input.position)
            _G_exactly_439, lastError = self.exactly("delins")
            self.considerError(lastError, "pro_delins")
            self._trace("", (7393, 7403), 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("", (7467, 7473), 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("", (7551, 7557), self.input.position)
            _G_exactly_446, lastError = self.exactly("ins")
            self.considerError(lastError, "pro_ins")
            self._trace("", (7557, 7567), 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("", (7636, 7642), 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("", (7708, 7713), 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("", (7728, 7731), 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("", (7801, 7807), 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("", (7812, 7816), 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("", (7912, 7916), 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("", (8238, 8253), 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("", (8255, 8259), self.input.position)
                _G_exactly_474, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8259, 8274), 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("", (8277, 8281), 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("", (8317, 8338), self.input.position)
                _G_apply_481, lastError = self._apply(
                    self.rule_uncertain_g_interval, "uncertain_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_481
                return (_G_apply_481, self.currentError)

            def _G_or_482():
                self._trace("", (8343, 8359), self.input.position)
                _G_apply_483, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_483, self.currentError)

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

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

            def _G_or_485():
                self._trace("", (8372, 8387), self.input.position)
                _G_apply_486, lastError = self._apply(
                    self.rule_def_m_interval, "def_m_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_486, self.currentError)

            def _G_or_487():
                self._trace("", (8389, 8393), self.input.position)
                _G_exactly_488, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8393, 8408), self.input.position)
                _G_apply_489, lastError = self._apply(
                    self.rule_def_m_interval, "def_m_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_489
                self._trace("", (8411, 8415), self.input.position)
                _G_exactly_490, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_491, lastError = (
                    eval(self._G_expr_477, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_491, self.currentError)

            _G_or_492, lastError = self._or([_G_or_485, _G_or_487])
            self.considerError(lastError, "m_interval")
            return (_G_or_492, self.currentError)

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

            def _G_or_493():
                self._trace("", (8451, 8466), self.input.position)
                _G_apply_494, lastError = self._apply(
                    self.rule_def_n_interval, "def_n_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_494, self.currentError)

            def _G_or_495():
                self._trace("", (8468, 8472), self.input.position)
                _G_exactly_496, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8472, 8487), self.input.position)
                _G_apply_497, lastError = self._apply(
                    self.rule_def_n_interval, "def_n_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_497
                self._trace("", (8490, 8494), self.input.position)
                _G_exactly_498, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_499, lastError = (
                    eval(self._G_expr_477, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_499, self.currentError)

            _G_or_500, lastError = self._or([_G_or_493, _G_or_495])
            self.considerError(lastError, "n_interval")
            return (_G_or_500, self.currentError)

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

            def _G_or_501():
                self._trace("", (8530, 8545), self.input.position)
                _G_apply_502, lastError = self._apply(
                    self.rule_def_p_interval, "def_p_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_502, self.currentError)

            def _G_or_503():
                self._trace("", (8547, 8551), self.input.position)
                _G_exactly_504, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8551, 8566), self.input.position)
                _G_apply_505, lastError = self._apply(
                    self.rule_def_p_interval, "def_p_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_505
                self._trace("", (8569, 8573), self.input.position)
                _G_exactly_506, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_507, lastError = (
                    eval(self._G_expr_477, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_507, self.currentError)

            _G_or_508, lastError = self._or([_G_or_501, _G_or_503])
            self.considerError(lastError, "p_interval")
            return (_G_or_508, self.currentError)

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

            def _G_or_509():
                self._trace("", (8609, 8624), self.input.position)
                _G_apply_510, lastError = self._apply(
                    self.rule_def_r_interval, "def_r_interval", []
                )
                self.considerError(lastError, None)
                return (_G_apply_510, self.currentError)

            def _G_or_511():
                self._trace("", (8626, 8630), self.input.position)
                _G_exactly_512, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (8630, 8645), self.input.position)
                _G_apply_513, lastError = self._apply(
                    self.rule_def_r_interval, "def_r_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_513
                self._trace("", (8648, 8652), self.input.position)
                _G_exactly_514, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_515, lastError = (
                    eval(self._G_expr_477, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_515, self.currentError)

            _G_or_516, lastError = self._or([_G_or_509, _G_or_511])
            self.considerError(lastError, "r_interval")
            return (_G_or_516, self.currentError)

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

            def _G_or_517():
                self._trace("", (8716, 8721), self.input.position)
                _G_apply_518, lastError = self._apply(self.rule_g_pos, "g_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_518
                self._trace("", (8727, 8731), self.input.position)
                _G_exactly_519, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (8731, 8737), self.input.position)
                _G_apply_520, lastError = self._apply(self.rule_g_pos, "g_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_520
                _G_python_522, lastError = (
                    eval(self._G_expr_521, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_522, self.currentError)

            def _G_or_523():
                self._trace("", (8783, 8788), self.input.position)
                _G_apply_524, lastError = self._apply(self.rule_g_pos, "g_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_524
                _G_python_526, lastError = (
                    eval(self._G_expr_525, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_526, self.currentError)

            _G_or_527, lastError = self._or([_G_or_517, _G_or_523])
            self.considerError(lastError, "def_g_interval")
            return (_G_or_527, self.currentError)

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

            def _G_or_528():
                self._trace("", (8852, 8857), self.input.position)
                _G_apply_529, lastError = self._apply(self.rule_m_pos, "m_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_529
                self._trace("", (8863, 8867), self.input.position)
                _G_exactly_530, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (8867, 8873), self.input.position)
                _G_apply_531, lastError = self._apply(self.rule_m_pos, "m_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_531
                _G_python_532, lastError = (
                    eval(self._G_expr_521, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_532, self.currentError)

            def _G_or_533():
                self._trace("", (8919, 8924), self.input.position)
                _G_apply_534, lastError = self._apply(self.rule_m_pos, "m_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_534
                _G_python_535, lastError = (
                    eval(self._G_expr_525, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_535, self.currentError)

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

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

            def _G_or_537():
                self._trace("", (8988, 8993), self.input.position)
                _G_apply_538, lastError = self._apply(self.rule_p_pos, "p_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_538
                self._trace("", (8999, 9003), self.input.position)
                _G_exactly_539, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9003, 9009), self.input.position)
                _G_apply_540, lastError = self._apply(self.rule_p_pos, "p_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_540
                _G_python_541, lastError = (
                    eval(self._G_expr_521, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_541, self.currentError)

            def _G_or_542():
                self._trace("", (9055, 9060), self.input.position)
                _G_apply_543, lastError = self._apply(self.rule_p_pos, "p_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_543
                _G_python_544, lastError = (
                    eval(self._G_expr_525, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_544, self.currentError)

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

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

            def _G_or_546():
                self._trace("", (9124, 9129), self.input.position)
                _G_apply_547, lastError = self._apply(self.rule_r_pos, "r_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_547
                self._trace("", (9135, 9139), self.input.position)
                _G_exactly_548, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9139, 9145), self.input.position)
                _G_apply_549, lastError = self._apply(self.rule_r_pos, "r_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_549
                _G_python_550, lastError = (
                    eval(self._G_expr_521, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_550, self.currentError)

            def _G_or_551():
                self._trace("", (9191, 9196), self.input.position)
                _G_apply_552, lastError = self._apply(self.rule_r_pos, "r_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_552
                _G_python_553, lastError = (
                    eval(self._G_expr_525, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_553, self.currentError)

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

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

            def _G_or_555():
                self._trace("", (9260, 9265), self.input.position)
                _G_apply_556, lastError = self._apply(self.rule_c_pos, "c_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_556
                self._trace("", (9271, 9275), self.input.position)
                _G_exactly_557, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9275, 9281), self.input.position)
                _G_apply_558, lastError = self._apply(self.rule_c_pos, "c_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_558
                _G_python_560, lastError = (
                    eval(self._G_expr_559, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_560, self.currentError)

            def _G_or_561():
                self._trace("", (9337, 9342), self.input.position)
                _G_apply_562, lastError = self._apply(self.rule_c_pos, "c_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_562
                _G_python_564, lastError = (
                    eval(self._G_expr_563, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_564, self.currentError)

            _G_or_565, lastError = self._or([_G_or_555, _G_or_561])
            self.considerError(lastError, "def_c_interval")
            return (_G_or_565, self.currentError)

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

            def _G_or_566():
                self._trace("", (9416, 9421), self.input.position)
                _G_apply_567, lastError = self._apply(self.rule_n_pos, "n_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_567
                self._trace("", (9427, 9431), self.input.position)
                _G_exactly_568, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9431, 9437), self.input.position)
                _G_apply_569, lastError = self._apply(self.rule_n_pos, "n_pos", [])
                self.considerError(lastError, None)
                _locals["end"] = _G_apply_569
                _G_python_570, lastError = (
                    eval(self._G_expr_559, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_570, self.currentError)

            def _G_or_571():
                self._trace("", (9493, 9498), self.input.position)
                _G_apply_572, lastError = self._apply(self.rule_n_pos, "n_pos", [])
                self.considerError(lastError, None)
                _locals["start"] = _G_apply_572
                _G_python_573, lastError = (
                    eval(self._G_expr_563, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_573, self.currentError)

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

        def rule_uncertain_g_interval(self):
            _locals = {"self": self}
            self.locals["uncertain_g_interval"] = _locals

            def _G_or_575():
                self._trace("", (9597, 9601), self.input.position)
                _G_exactly_576, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (9601, 9616), self.input.position)
                _G_apply_577, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv_start"] = _G_apply_577
                self._trace("", (9625, 9629), self.input.position)
                _G_exactly_578, lastError = self.exactly(")")
                self.considerError(lastError, None)
                self._trace("", (9629, 9633), self.input.position)
                _G_exactly_579, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9633, 9637), self.input.position)
                _G_exactly_580, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (9637, 9652), self.input.position)
                _G_apply_581, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv_end"] = _G_apply_581
                self._trace("", (9659, 9663), self.input.position)
                _G_exactly_582, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_584, lastError = (
                    eval(self._G_expr_583, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_584, self.currentError)

            def _G_or_585():
                self._trace("", (9777, 9792), self.input.position)
                _G_apply_586, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv_start"] = _G_apply_586
                self._trace("", (9801, 9805), self.input.position)
                _G_exactly_587, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9805, 9809), self.input.position)
                _G_exactly_588, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (9809, 9824), self.input.position)
                _G_apply_589, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv_end"] = _G_apply_589
                self._trace("", (9831, 9835), self.input.position)
                _G_exactly_590, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_592, lastError = (
                    eval(self._G_expr_591, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_592, self.currentError)

            def _G_or_593():
                self._trace("", (9932, 9936), self.input.position)
                _G_exactly_594, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (9936, 9951), self.input.position)
                _G_apply_595, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv_start"] = _G_apply_595
                self._trace("", (9960, 9964), self.input.position)
                _G_exactly_596, lastError = self.exactly(")")
                self.considerError(lastError, None)
                self._trace("", (9964, 9968), self.input.position)
                _G_exactly_597, lastError = self.exactly("_")
                self.considerError(lastError, None)
                self._trace("", (9968, 9983), self.input.position)
                _G_apply_598, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv_end"] = _G_apply_598
                _G_python_600, lastError = (
                    eval(self._G_expr_599, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_600, self.currentError)

            def _G_or_601():
                self._trace("", (10089, 10092), self.input.position)
                _G_exactly_602, lastError = self.exactly("(")
                self.considerError(lastError, None)
                self._trace("", (10092, 10107), self.input.position)
                _G_apply_603, lastError = self._apply(
                    self.rule_def_g_interval, "def_g_interval", []
                )
                self.considerError(lastError, None)
                _locals["iv"] = _G_apply_603
                self._trace("", (10110, 10114), self.input.position)
                _G_exactly_604, lastError = self.exactly(")")
                self.considerError(lastError, None)
                _G_python_605, lastError = (
                    eval(self._G_expr_477, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_605, self.currentError)

            _G_or_606, lastError = self._or(
                [_G_or_575, _G_or_585, _G_or_593, _G_or_601]
            )
            self.considerError(lastError, "uncertain_g_interval")
            return (_G_or_606, self.currentError)

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

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

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

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

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

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

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

            def _G_or_613():
                self._trace("", (10589, 10594), self.input.position)
                _G_apply_614, lastError = self._apply(self.rule_base, "base", [])
                self.considerError(lastError, None)
                _locals["b"] = _G_apply_614
                self._trace("", (10596, 10603), self.input.position)
                _G_apply_615, lastError = self._apply(self.rule_offset, "offset", [])
                self.considerError(lastError, None)
                _locals["o"] = _G_apply_615
                _G_python_617, lastError = (
                    eval(self._G_expr_616, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_617, self.currentError)

            def _G_or_618():
                self._trace("", (10688, 10692), self.input.position)
                _G_exactly_619, lastError = self.exactly("*")
                self.considerError(lastError, None)
                self._trace("", (10692, 10696), self.input.position)
                _G_apply_620, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                _locals["b"] = _G_apply_620
                self._trace("", (10698, 10705), self.input.position)
                _G_apply_621, lastError = self._apply(self.rule_offset, "offset", [])
                self.considerError(lastError, None)
                _locals["o"] = _G_apply_621
                _G_python_623, lastError = (
                    eval(self._G_expr_622, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_623, self.currentError)

            _G_or_624, lastError = self._or([_G_or_613, _G_or_618])
            self.considerError(lastError, "def_c_pos")
            return (_G_or_624, self.currentError)

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

            def _G_or_625():
                self._trace("", (10793, 10796), self.input.position)
                _G_apply_626, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_626, self.currentError)

            def _G_or_627():
                self._trace("", (10797, 10800), self.input.position)
                _G_exactly_628, lastError = self.exactly("?")
                self.considerError(lastError, None)
                _G_python_629, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_629, self.currentError)

            _G_or_630, lastError = self._or([_G_or_625, _G_or_627])
            self.considerError(lastError, "def_g_pos")
            _locals["pos"] = _G_or_630
            _G_python_632, lastError = (
                eval(self._G_expr_631, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "def_g_pos")
            return (_G_python_632, self.currentError)

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

            def _G_or_633():
                self._trace("", (10862, 10865), self.input.position)
                _G_apply_634, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_634, self.currentError)

            def _G_or_635():
                self._trace("", (10866, 10869), self.input.position)
                _G_exactly_636, lastError = self.exactly("?")
                self.considerError(lastError, None)
                _G_python_637, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_637, self.currentError)

            _G_or_638, lastError = self._or([_G_or_633, _G_or_635])
            self.considerError(lastError, "def_m_pos")
            _locals["pos"] = _G_or_638
            _G_python_639, lastError = (
                eval(self._G_expr_631, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "def_m_pos")
            return (_G_python_639, self.currentError)

        def rule_def_n_pos(self):
            _locals = {"self": self}
            self.locals["def_n_pos"] = _locals
            self._trace("", (10929, 10934), self.input.position)
            _G_apply_640, lastError = self._apply(self.rule_base, "base", [])
            self.considerError(lastError, "def_n_pos")
            _locals["b"] = _G_apply_640
            self._trace("", (10936, 10943), self.input.position)
            _G_apply_641, lastError = self._apply(self.rule_offset, "offset", [])
            self.considerError(lastError, "def_n_pos")
            _locals["o"] = _G_apply_641
            _G_python_643, lastError = (
                eval(self._G_expr_642, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "def_n_pos")
            return (_G_python_643, self.currentError)

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

            def _G_or_644():
                self._trace("", (11033, 11039), self.input.position)
                _G_apply_645, lastError = self._apply(self.rule_term13, "term13", [])
                self.considerError(lastError, None)
                return (_G_apply_645, self.currentError)

            def _G_or_646():
                self._trace("", (11040, 11044), self.input.position)
                _G_apply_647, lastError = self._apply(self.rule_aa13, "aa13", [])
                self.considerError(lastError, None)
                return (_G_apply_647, self.currentError)

            _G_or_648, lastError = self._or([_G_or_644, _G_or_646])
            self.considerError(lastError, "def_p_pos")
            _locals["aa"] = _G_or_648
            self._trace("", (11048, 11052), self.input.position)
            _G_apply_649, lastError = self._apply(self.rule_num, "num", [])
            self.considerError(lastError, "def_p_pos")
            _locals["pos"] = _G_apply_649
            _G_python_651, lastError = (
                eval(self._G_expr_650, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "def_p_pos")
            return (_G_python_651, self.currentError)

        def rule_def_r_pos(self):
            _locals = {"self": self}
            self.locals["def_r_pos"] = _locals
            self._trace("", (11134, 11139), self.input.position)
            _G_apply_652, lastError = self._apply(self.rule_base, "base", [])
            self.considerError(lastError, "def_r_pos")
            _locals["b"] = _G_apply_652
            self._trace("", (11141, 11148), self.input.position)
            _G_apply_653, lastError = self._apply(self.rule_offset, "offset", [])
            self.considerError(lastError, "def_r_pos")
            _locals["o"] = _G_apply_653
            _G_python_654, lastError = (
                eval(self._G_expr_642, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "def_r_pos")
            return (_G_python_654, self.currentError)

        def rule_fs(self):
            _locals = {"self": self}
            self.locals["fs"] = _locals
            self._trace("", (11552, 11557), self.input.position)
            _G_exactly_655, lastError = self.exactly("fs")
            self.considerError(lastError, "fs")

            def _G_or_656():
                self._trace("", (11559, 11566), self.input.position)
                _G_apply_657, lastError = self._apply(self.rule_aa13_fs, "aa13_fs", [])
                self.considerError(lastError, None)
                return (_G_apply_657, self.currentError)

            def _G_or_658():
                _G_python_659, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_659, self.currentError)

            _G_or_660, lastError = self._or([_G_or_656, _G_or_658])
            self.considerError(lastError, "fs")
            _locals["n"] = _G_or_660
            _G_python_662, lastError = (
                eval(self._G_expr_661, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "fs")
            return (_G_python_662, self.currentError)

        def rule_ext(self):
            _locals = {"self": self}
            self.locals["ext"] = _locals
            self._trace("", (11590, 11596), self.input.position)
            _G_exactly_663, lastError = self.exactly("ext")
            self.considerError(lastError, "ext")

            def _G_or_664():
                self._trace("", (11598, 11606), self.input.position)
                _G_apply_665, lastError = self._apply(
                    self.rule_aa13_ext, "aa13_ext", []
                )
                self.considerError(lastError, None)
                return (_G_apply_665, self.currentError)

            def _G_or_666():
                _G_python_667, lastError = ((None, None)), None
                self.considerError(lastError, None)
                return (_G_python_667, self.currentError)

            _G_or_668, lastError = self._or([_G_or_664, _G_or_666])
            self.considerError(lastError, "ext")
            _locals["aat"] = _G_or_668[0]
            _locals["n"] = _G_or_668[1]
            _G_python_670, lastError = (
                eval(self._G_expr_669, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "ext")
            return (_G_python_670, self.currentError)

        def rule_aa13_fs(self):
            _locals = {"self": self}
            self.locals["aa13_fs"] = _locals
            self._trace("", (11656, 11663), self.input.position)
            _G_apply_671, lastError = self._apply(self.rule_term13, "term13", [])
            self.considerError(lastError, "aa13_fs")
            self._trace("", (11663, 11676), self.input.position)
            _G_apply_672, lastError = self._apply(
                self.rule_fsext_offset, "fsext_offset", []
            )
            self.considerError(lastError, "aa13_fs")
            _locals["n"] = _G_apply_672
            _G_python_673, lastError = (
                eval(self._G_expr_661, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "aa13_fs")
            return (_G_python_673, self.currentError)

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

            def _G_or_674():
                self._trace("", (11694, 11701), self.input.position)
                _G_apply_675, lastError = self._apply(self.rule_term13, "term13", [])
                self.considerError(lastError, None)
                _locals["aat"] = _G_apply_675
                self._trace("", (11705, 11718), self.input.position)
                _G_apply_676, lastError = self._apply(
                    self.rule_fsext_offset, "fsext_offset", []
                )
                self.considerError(lastError, None)
                _locals["n"] = _G_apply_676
                _G_python_677, lastError = (
                    eval(self._G_expr_669, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_677, self.currentError)

            def _G_or_678():
                def _G_or_679():
                    self._trace("", (11745, 11749), self.input.position)
                    _G_apply_680, lastError = self._apply(self.rule_aa13, "aa13", [])
                    self.considerError(lastError, None)
                    return (_G_apply_680, self.currentError)

                def _G_or_681():
                    _G_python_682, lastError = (None), None
                    self.considerError(lastError, None)
                    return (_G_python_682, self.currentError)

                _G_or_683, lastError = self._or([_G_or_679, _G_or_681])
                self.considerError(lastError, None)
                _locals["aat"] = _G_or_683
                self._trace("", (11766, 11771), self.input.position)
                _G_apply_684, lastError = self._apply(self.rule_nnum, "nnum", [])
                self.considerError(lastError, None)
                _locals["n"] = _G_apply_684
                _G_python_685, lastError = (
                    eval(self._G_expr_669, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_685, self.currentError)

            _G_or_686, lastError = self._or([_G_or_674, _G_or_678])
            self.considerError(lastError, "aa13_ext")
            return (_G_or_686, self.currentError)

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

            def _G_or_687():
                self._trace("", (11800, 11804), self.input.position)
                _G_apply_688, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_688, self.currentError)

            def _G_or_689():
                self._trace("", (11805, 11808), self.input.position)
                _G_exactly_690, lastError = self.exactly("?")
                self.considerError(lastError, None)
                return (_G_exactly_690, self.currentError)

            def _G_or_691():
                _G_python_692, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_692, self.currentError)

            _G_or_693, lastError = self._or([_G_or_687, _G_or_689, _G_or_691])
            self.considerError(lastError, "fsext_offset")
            return (_G_or_693, self.currentError)

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

            def _G_consumedby_694():
                def _G_many1_695():
                    self._trace("", (11853, 11856), self.input.position)
                    _G_apply_696, lastError = self._apply(self.rule_dna, "dna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_696, self.currentError)

                _G_many1_697, lastError = self.many(_G_many1_695, _G_many1_695())
                self.considerError(lastError, None)
                return (_G_many1_697, self.currentError)

            _G_consumedby_698, lastError = self.consumedby(_G_consumedby_694)
            self.considerError(lastError, "dna_seq")
            return (_G_consumedby_698, self.currentError)

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

            def _G_consumedby_699():
                def _G_many1_700():
                    self._trace("", (11870, 11873), self.input.position)
                    _G_apply_701, lastError = self._apply(self.rule_rna, "rna", [])
                    self.considerError(lastError, None)
                    return (_G_apply_701, self.currentError)

                _G_many1_702, lastError = self.many(_G_many1_700, _G_many1_700())
                self.considerError(lastError, None)
                return (_G_many1_702, self.currentError)

            _G_consumedby_703, lastError = self.consumedby(_G_consumedby_699)
            self.considerError(lastError, "rna_seq")
            return (_G_consumedby_703, self.currentError)

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

            def _G_or_704():
                def _G_consumedby_705():
                    self._trace("", (11889, 11897), self.input.position)
                    _G_apply_706, lastError = self._apply(
                        self.rule_aat3_seq, "aat3_seq", []
                    )
                    self.considerError(lastError, None)
                    return (_G_apply_706, self.currentError)

                _G_consumedby_707, lastError = self.consumedby(_G_consumedby_705)
                self.considerError(lastError, None)
                return (_G_consumedby_707, self.currentError)

            def _G_or_708():
                def _G_consumedby_709():
                    self._trace("", (11902, 11910), self.input.position)
                    _G_apply_710, lastError = self._apply(
                        self.rule_aat1_seq, "aat1_seq", []
                    )
                    self.considerError(lastError, None)
                    return (_G_apply_710, self.currentError)

                _G_consumedby_711, lastError = self.consumedby(_G_consumedby_709)
                self.considerError(lastError, None)
                return (_G_consumedby_711, self.currentError)

            _G_or_712, lastError = self._or([_G_or_704, _G_or_708])
            self.considerError(lastError, "aat13_seq")
            return (_G_or_712, self.currentError)

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

            def _G_or_713():
                def _G_consumedby_714():
                    self._trace("", (11924, 11929), self.input.position)
                    _G_apply_715, lastError = self._apply(self.rule_term1, "term1", [])
                    self.considerError(lastError, None)
                    return (_G_apply_715, self.currentError)

                _G_consumedby_716, lastError = self.consumedby(_G_consumedby_714)
                self.considerError(lastError, None)
                return (_G_consumedby_716, self.currentError)

            def _G_or_717():
                def _G_consumedby_718():
                    def _G_many1_719():
                        self._trace("", (11934, 11937), self.input.position)
                        _G_apply_720, lastError = self._apply(self.rule_aa1, "aa1", [])
                        self.considerError(lastError, None)
                        return (_G_apply_720, self.currentError)

                    _G_many1_721, lastError = self.many(_G_many1_719, _G_many1_719())
                    self.considerError(lastError, None)

                    def _G_optional_722():
                        self._trace("", (11938, 11944), self.input.position)
                        _G_apply_723, lastError = self._apply(
                            self.rule_term1, "term1", []
                        )
                        self.considerError(lastError, None)
                        return (_G_apply_723, self.currentError)

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

                    _G_or_725, lastError = self._or([_G_optional_722, _G_optional_724])
                    self.considerError(lastError, None)
                    return (_G_or_725, self.currentError)

                _G_consumedby_726, lastError = self.consumedby(_G_consumedby_718)
                self.considerError(lastError, None)
                return (_G_consumedby_726, self.currentError)

            _G_or_727, lastError = self._or([_G_or_713, _G_or_717])
            self.considerError(lastError, "aat1_seq")
            return (_G_or_727, self.currentError)

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

            def _G_or_728():
                def _G_consumedby_729():
                    self._trace("", (11959, 11964), self.input.position)
                    _G_apply_730, lastError = self._apply(self.rule_term3, "term3", [])
                    self.considerError(lastError, None)
                    return (_G_apply_730, self.currentError)

                _G_consumedby_731, lastError = self.consumedby(_G_consumedby_729)
                self.considerError(lastError, None)
                return (_G_consumedby_731, self.currentError)

            def _G_or_732():
                def _G_consumedby_733():
                    def _G_many1_734():
                        self._trace("", (11969, 11972), self.input.position)
                        _G_apply_735, lastError = self._apply(self.rule_aa3, "aa3", [])
                        self.considerError(lastError, None)
                        return (_G_apply_735, self.currentError)

                    _G_many1_736, lastError = self.many(_G_many1_734, _G_many1_734())
                    self.considerError(lastError, None)

                    def _G_optional_737():
                        self._trace("", (11973, 11979), self.input.position)
                        _G_apply_738, lastError = self._apply(
                            self.rule_term3, "term3", []
                        )
                        self.considerError(lastError, None)
                        return (_G_apply_738, self.currentError)

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

                    _G_or_740, lastError = self._or([_G_optional_737, _G_optional_739])
                    self.considerError(lastError, None)
                    return (_G_or_740, self.currentError)

                _G_consumedby_741, lastError = self.consumedby(_G_consumedby_733)
                self.considerError(lastError, None)
                return (_G_consumedby_741, self.currentError)

            _G_or_742, lastError = self._or([_G_or_728, _G_or_732])
            self.considerError(lastError, "aat3_seq")
            return (_G_or_742, self.currentError)

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

            def _G_or_743():
                def _G_consumedby_744():
                    self._trace("", (11994, 12001), self.input.position)
                    _G_apply_745, lastError = self._apply(
                        self.rule_aa3_seq, "aa3_seq", []
                    )
                    self.considerError(lastError, None)
                    return (_G_apply_745, self.currentError)

                _G_consumedby_746, lastError = self.consumedby(_G_consumedby_744)
                self.considerError(lastError, None)
                return (_G_consumedby_746, self.currentError)

            def _G_or_747():
                def _G_consumedby_748():
                    self._trace("", (12006, 12013), self.input.position)
                    _G_apply_749, lastError = self._apply(
                        self.rule_aa1_seq, "aa1_seq", []
                    )
                    self.considerError(lastError, None)
                    return (_G_apply_749, self.currentError)

                _G_consumedby_750, lastError = self.consumedby(_G_consumedby_748)
                self.considerError(lastError, None)
                return (_G_consumedby_750, self.currentError)

            _G_or_751, lastError = self._or([_G_or_743, _G_or_747])
            self.considerError(lastError, "aa13_seq")
            return (_G_or_751, self.currentError)

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

            def _G_consumedby_752():
                def _G_many1_753():
                    self._trace("", (12026, 12029), self.input.position)
                    _G_apply_754, lastError = self._apply(self.rule_aa1, "aa1", [])
                    self.considerError(lastError, None)
                    return (_G_apply_754, self.currentError)

                _G_many1_755, lastError = self.many(_G_many1_753, _G_many1_753())
                self.considerError(lastError, None)
                return (_G_many1_755, self.currentError)

            _G_consumedby_756, lastError = self.consumedby(_G_consumedby_752)
            self.considerError(lastError, "aa1_seq")
            return (_G_consumedby_756, self.currentError)

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

            def _G_consumedby_757():
                def _G_many1_758():
                    self._trace("", (12043, 12046), self.input.position)
                    _G_apply_759, lastError = self._apply(self.rule_aa3, "aa3", [])
                    self.considerError(lastError, None)
                    return (_G_apply_759, self.currentError)

                _G_many1_760, lastError = self.many(_G_many1_758, _G_many1_758())
                self.considerError(lastError, None)
                return (_G_many1_760, self.currentError)

            _G_consumedby_761, lastError = self.consumedby(_G_consumedby_757)
            self.considerError(lastError, "aa3_seq")
            return (_G_consumedby_761, self.currentError)

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

            def _G_pred_763():
                _G_python_765, lastError = (
                    eval(self._G_expr_764, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_765, self.currentError)

            _G_pred_766, lastError = self.pred(_G_pred_763)
            self.considerError(lastError, "aa1")
            _G_python_768, lastError = (
                eval(self._G_expr_767, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "aa1")
            return (_G_python_768, self.currentError)

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

            def _G_or_769():
                self._trace("", (12127, 12131), self.input.position)
                _G_apply_770, lastError = self._apply(self.rule_aa3, "aa3", [])
                self.considerError(lastError, None)
                return (_G_apply_770, self.currentError)

            def _G_or_771():
                self._trace("", (12133, 12137), self.input.position)
                _G_apply_772, lastError = self._apply(self.rule_aa1, "aa1", [])
                self.considerError(lastError, None)
                return (_G_apply_772, self.currentError)

            _G_or_773, lastError = self._or([_G_or_769, _G_or_771])
            self.considerError(lastError, "aa13")
            return (_G_or_773, self.currentError)

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

            def _G_or_774():
                self._trace("", (12143, 12149), self.input.position)
                _G_exactly_775, lastError = self.exactly("Ala")
                self.considerError(lastError, None)
                return (_G_exactly_775, self.currentError)

            def _G_or_776():
                self._trace("", (12150, 12155), self.input.position)
                _G_exactly_777, lastError = self.exactly("Cys")
                self.considerError(lastError, None)
                return (_G_exactly_777, self.currentError)

            def _G_or_778():
                self._trace("", (12156, 12161), self.input.position)
                _G_exactly_779, lastError = self.exactly("Asp")
                self.considerError(lastError, None)
                return (_G_exactly_779, self.currentError)

            def _G_or_780():
                self._trace("", (12162, 12167), self.input.position)
                _G_exactly_781, lastError = self.exactly("Glu")
                self.considerError(lastError, None)
                return (_G_exactly_781, self.currentError)

            def _G_or_782():
                self._trace("", (12168, 12173), self.input.position)
                _G_exactly_783, lastError = self.exactly("Phe")
                self.considerError(lastError, None)
                return (_G_exactly_783, self.currentError)

            def _G_or_784():
                self._trace("", (12174, 12179), self.input.position)
                _G_exactly_785, lastError = self.exactly("Gly")
                self.considerError(lastError, None)
                return (_G_exactly_785, self.currentError)

            def _G_or_786():
                self._trace("", (12180, 12185), self.input.position)
                _G_exactly_787, lastError = self.exactly("His")
                self.considerError(lastError, None)
                return (_G_exactly_787, self.currentError)

            def _G_or_788():
                self._trace("", (12186, 12191), self.input.position)
                _G_exactly_789, lastError = self.exactly("Ile")
                self.considerError(lastError, None)
                return (_G_exactly_789, self.currentError)

            def _G_or_790():
                self._trace("", (12192, 12197), self.input.position)
                _G_exactly_791, lastError = self.exactly("Lys")
                self.considerError(lastError, None)
                return (_G_exactly_791, self.currentError)

            def _G_or_792():
                self._trace("", (12198, 12203), self.input.position)
                _G_exactly_793, lastError = self.exactly("Leu")
                self.considerError(lastError, None)
                return (_G_exactly_793, self.currentError)

            def _G_or_794():
                self._trace("", (12204, 12209), self.input.position)
                _G_exactly_795, lastError = self.exactly("Met")
                self.considerError(lastError, None)
                return (_G_exactly_795, self.currentError)

            def _G_or_796():
                self._trace("", (12210, 12215), self.input.position)
                _G_exactly_797, lastError = self.exactly("Asn")
                self.considerError(lastError, None)
                return (_G_exactly_797, self.currentError)

            def _G_or_798():
                self._trace("", (12216, 12221), self.input.position)
                _G_exactly_799, lastError = self.exactly("Pro")
                self.considerError(lastError, None)
                return (_G_exactly_799, self.currentError)

            def _G_or_800():
                self._trace("", (12222, 12227), self.input.position)
                _G_exactly_801, lastError = self.exactly("Gln")
                self.considerError(lastError, None)
                return (_G_exactly_801, self.currentError)

            def _G_or_802():
                self._trace("", (12228, 12233), self.input.position)
                _G_exactly_803, lastError = self.exactly("Arg")
                self.considerError(lastError, None)
                return (_G_exactly_803, self.currentError)

            def _G_or_804():
                self._trace("", (12234, 12239), self.input.position)
                _G_exactly_805, lastError = self.exactly("Ser")
                self.considerError(lastError, None)
                return (_G_exactly_805, self.currentError)

            def _G_or_806():
                self._trace("", (12240, 12245), self.input.position)
                _G_exactly_807, lastError = self.exactly("Thr")
                self.considerError(lastError, None)
                return (_G_exactly_807, self.currentError)

            def _G_or_808():
                self._trace("", (12246, 12251), self.input.position)
                _G_exactly_809, lastError = self.exactly("Val")
                self.considerError(lastError, None)
                return (_G_exactly_809, self.currentError)

            def _G_or_810():
                self._trace("", (12252, 12257), self.input.position)
                _G_exactly_811, lastError = self.exactly("Trp")
                self.considerError(lastError, None)
                return (_G_exactly_811, self.currentError)

            def _G_or_812():
                self._trace("", (12258, 12263), self.input.position)
                _G_exactly_813, lastError = self.exactly("Tyr")
                self.considerError(lastError, None)
                return (_G_exactly_813, self.currentError)

            def _G_or_814():
                self._trace("", (12265, 12271), self.input.position)
                _G_exactly_815, lastError = self.exactly("Asx")
                self.considerError(lastError, None)
                return (_G_exactly_815, self.currentError)

            def _G_or_816():
                self._trace("", (12273, 12279), self.input.position)
                _G_exactly_817, lastError = self.exactly("Glx")
                self.considerError(lastError, None)
                return (_G_exactly_817, self.currentError)

            def _G_or_818():
                self._trace("", (12281, 12287), self.input.position)
                _G_exactly_819, lastError = self.exactly("Xaa")
                self.considerError(lastError, None)
                return (_G_exactly_819, self.currentError)

            def _G_or_820():
                self._trace("", (12289, 12295), self.input.position)
                _G_exactly_821, lastError = self.exactly("Sec")
                self.considerError(lastError, None)
                return (_G_exactly_821, self.currentError)

            _G_or_822, lastError = self._or(
                [
                    _G_or_774,
                    _G_or_776,
                    _G_or_778,
                    _G_or_780,
                    _G_or_782,
                    _G_or_784,
                    _G_or_786,
                    _G_or_788,
                    _G_or_790,
                    _G_or_792,
                    _G_or_794,
                    _G_or_796,
                    _G_or_798,
                    _G_or_800,
                    _G_or_802,
                    _G_or_804,
                    _G_or_806,
                    _G_or_808,
                    _G_or_810,
                    _G_or_812,
                    _G_or_814,
                    _G_or_816,
                    _G_or_818,
                    _G_or_820,
                ]
            )
            self.considerError(lastError, "aa3")
            return (_G_or_822, self.currentError)

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

            def _G_or_823():
                self._trace("", (12302, 12308), self.input.position)
                _G_apply_824, lastError = self._apply(self.rule_term1, "term1", [])
                self.considerError(lastError, None)
                return (_G_apply_824, self.currentError)

            def _G_or_825():
                self._trace("", (12310, 12314), self.input.position)
                _G_apply_826, lastError = self._apply(self.rule_aa1, "aa1", [])
                self.considerError(lastError, None)
                return (_G_apply_826, self.currentError)

            _G_or_827, lastError = self._or([_G_or_823, _G_or_825])
            self.considerError(lastError, "aat1")
            return (_G_or_827, self.currentError)

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

            def _G_or_828():
                self._trace("", (12322, 12327), self.input.position)
                _G_apply_829, lastError = self._apply(self.rule_aat3, "aat3", [])
                self.considerError(lastError, None)
                return (_G_apply_829, self.currentError)

            def _G_or_830():
                self._trace("", (12329, 12334), self.input.position)
                _G_apply_831, lastError = self._apply(self.rule_aat1, "aat1", [])
                self.considerError(lastError, None)
                return (_G_apply_831, self.currentError)

            _G_or_832, lastError = self._or([_G_or_828, _G_or_830])
            self.considerError(lastError, "aat13")
            return (_G_or_832, self.currentError)

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

            def _G_or_833():
                self._trace("", (12341, 12347), self.input.position)
                _G_apply_834, lastError = self._apply(self.rule_term3, "term3", [])
                self.considerError(lastError, None)
                return (_G_apply_834, self.currentError)

            def _G_or_835():
                self._trace("", (12349, 12353), self.input.position)
                _G_apply_836, lastError = self._apply(self.rule_aa3, "aa3", [])
                self.considerError(lastError, None)
                return (_G_apply_836, self.currentError)

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

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

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

            def _G_pred_840():
                _G_python_842, lastError = (
                    eval(self._G_expr_841, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_842, self.currentError)

            _G_pred_843, lastError = self.pred(_G_pred_840)
            self.considerError(lastError, "dna_iupac")
            _G_python_844, lastError = (
                eval(self._G_expr_767, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "dna_iupac")
            return (_G_python_844, self.currentError)

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

            def _G_pred_846():
                _G_python_848, lastError = (
                    eval(self._G_expr_847, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_848, self.currentError)

            _G_pred_849, lastError = self.pred(_G_pred_846)
            self.considerError(lastError, "na_iupac")
            _G_python_850, lastError = (
                eval(self._G_expr_767, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "na_iupac")
            return (_G_python_850, self.currentError)

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

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

            def _G_pred_853():
                _G_python_855, lastError = (
                    eval(self._G_expr_854, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_855, self.currentError)

            _G_pred_856, lastError = self.pred(_G_pred_853)
            self.considerError(lastError, "rna_iupac")
            _G_python_857, lastError = (
                eval(self._G_expr_767, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "rna_iupac")
            return (_G_python_857, self.currentError)

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

            def _G_pred_859():
                _G_python_861, lastError = (
                    eval(self._G_expr_860, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_861, self.currentError)

            _G_pred_862, lastError = self.pred(_G_pred_859)
            self.considerError(lastError, "term1")
            _G_python_863, lastError = (
                eval(self._G_expr_767, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "term1")
            return (_G_python_863, self.currentError)

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

            def _G_or_864():
                self._trace("", (12607, 12613), self.input.position)
                _G_apply_865, lastError = self._apply(self.rule_term3, "term3", [])
                self.considerError(lastError, None)
                return (_G_apply_865, self.currentError)

            def _G_or_866():
                self._trace("", (12615, 12621), self.input.position)
                _G_apply_867, lastError = self._apply(self.rule_term1, "term1", [])
                self.considerError(lastError, None)
                return (_G_apply_867, self.currentError)

            _G_or_868, lastError = self._or([_G_or_864, _G_or_866])
            self.considerError(lastError, "term13")
            return (_G_or_868, self.currentError)

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

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

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

            def _G_consumedby_871():
                self._trace("", (12733, 12736), self.input.position)
                _G_exactly_872, lastError = self.exactly("-")
                self.considerError(lastError, None)
                self._trace("", (12736, 12740), self.input.position)
                _G_apply_873, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_873, self.currentError)

            _G_consumedby_874, lastError = self.consumedby(_G_consumedby_871)
            self.considerError(lastError, "nnum")
            _locals["x"] = _G_consumedby_874
            _G_python_876, lastError = (
                eval(self._G_expr_875, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "nnum")
            return (_G_python_876, self.currentError)

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

            def _G_consumedby_877():
                def _G_many1_878():
                    self._trace("", (12761, 12766), self.input.position)
                    _G_apply_879, lastError = self._apply(self.rule_digit, "digit", [])
                    self.considerError(lastError, None)
                    return (_G_apply_879, self.currentError)

                _G_many1_880, lastError = self.many(_G_many1_878, _G_many1_878())
                self.considerError(lastError, None)
                return (_G_many1_880, self.currentError)

            _G_consumedby_881, lastError = self.consumedby(_G_consumedby_877)
            self.considerError(lastError, "num")
            _locals["x"] = _G_consumedby_881
            _G_python_882, lastError = (
                eval(self._G_expr_875, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "num")
            return (_G_python_882, self.currentError)

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

            def _G_or_883():
                self._trace("", (12789, 12794), self.input.position)
                _G_apply_884, lastError = self._apply(self.rule_snum, "snum", [])
                self.considerError(lastError, None)
                return (_G_apply_884, self.currentError)

            def _G_or_885():
                _G_python_886, lastError = (0), None
                self.considerError(lastError, None)
                return (_G_python_886, self.currentError)

            _G_or_887, lastError = self._or([_G_or_883, _G_or_885])
            self.considerError(lastError, "offset")
            return (_G_or_887, self.currentError)

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

            def _G_pred_889():
                _G_python_891, lastError = (
                    eval(self._G_expr_890, self.globals, _locals),
                    None,
                )
                self.considerError(lastError, None)
                return (_G_python_891, self.currentError)

            _G_pred_892, lastError = self.pred(_G_pred_889)
            self.considerError(lastError, "pm")
            _G_python_893, lastError = (
                eval(self._G_expr_767, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "pm")
            return (_G_python_893, self.currentError)

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

            def _G_consumedby_894():
                def _G_optional_895():
                    self._trace("", (12838, 12840), self.input.position)
                    _G_apply_896, lastError = self._apply(self.rule_pm, "pm", [])
                    self.considerError(lastError, None)
                    return (_G_apply_896, self.currentError)

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

                _G_or_898, lastError = self._or([_G_optional_895, _G_optional_897])
                self.considerError(lastError, None)
                self._trace("", (12841, 12845), self.input.position)
                _G_apply_899, lastError = self._apply(self.rule_num, "num", [])
                self.considerError(lastError, None)
                return (_G_apply_899, self.currentError)

            _G_consumedby_900, lastError = self.consumedby(_G_consumedby_894)
            self.considerError(lastError, "snum")
            _locals["x"] = _G_consumedby_900
            _G_python_901, lastError = (
                eval(self._G_expr_875, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "snum")
            return (_G_python_901, self.currentError)

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

            def _G_consumedby_902():
                self._trace("", (12949, 12955), self.input.position)
                _G_apply_903, lastError = self._apply(self.rule_letter, "letter", [])
                self.considerError(lastError, None)

                def _G_optional_904():
                    def _G_many1_905():
                        def _G_or_906():
                            self._trace("", (12958, 12971), self.input.position)
                            _G_apply_907, lastError = self._apply(
                                self.rule_letterOrDigit, "letterOrDigit", []
                            )
                            self.considerError(lastError, None)
                            return (_G_apply_907, self.currentError)

                        def _G_or_908():
                            def _G_or_909():
                                self._trace("", (12975, 12978), self.input.position)
                                _G_exactly_910, lastError = self.exactly("-")
                                self.considerError(lastError, None)
                                return (_G_exactly_910, self.currentError)

                            def _G_or_911():
                                self._trace("", (12979, 12982), self.input.position)
                                _G_exactly_912, lastError = self.exactly("_")
                                self.considerError(lastError, None)
                                return (_G_exactly_912, self.currentError)

                            _G_or_913, lastError = self._or([_G_or_909, _G_or_911])
                            self.considerError(lastError, None)

                            def _G_lookahead_914():
                                self._trace("", (12986, 12999), self.input.position)
                                _G_apply_915, lastError = self._apply(
                                    self.rule_letterOrDigit, "letterOrDigit", []
                                )
                                self.considerError(lastError, None)
                                return (_G_apply_915, self.currentError)

                            _G_lookahead_916, lastError = self.lookahead(
                                _G_lookahead_914
                            )
                            self.considerError(lastError, None)
                            return (_G_lookahead_916, self.currentError)

                        _G_or_917, lastError = self._or([_G_or_906, _G_or_908])
                        self.considerError(lastError, None)
                        return (_G_or_917, self.currentError)

                    _G_many1_918, lastError = self.many(_G_many1_905, _G_many1_905())
                    self.considerError(lastError, None)
                    return (_G_many1_918, self.currentError)

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

                _G_or_920, lastError = self._or([_G_optional_904, _G_optional_919])
                self.considerError(lastError, None)

                def _G_optional_921():
                    self._trace("", (13005, 13008), self.input.position)
                    _G_exactly_922, lastError = self.exactly(".")
                    self.considerError(lastError, None)

                    def _G_many1_923():
                        self._trace("", (13008, 13014), self.input.position)
                        _G_apply_924, lastError = self._apply(
                            self.rule_digit, "digit", []
                        )
                        self.considerError(lastError, None)
                        return (_G_apply_924, self.currentError)

                    _G_many1_925, lastError = self.many(_G_many1_923, _G_many1_923())
                    self.considerError(lastError, None)
                    return (_G_many1_925, self.currentError)

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

                _G_or_927, lastError = self._or([_G_optional_921, _G_optional_926])
                self.considerError(lastError, None)
                return (_G_or_927, self.currentError)

            _G_consumedby_928, lastError = self.consumedby(_G_consumedby_902)
            self.considerError(lastError, "accn")
            return (_G_consumedby_928, self.currentError)

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

            def _G_or_929():
                self._trace("", (13036, 13046), self.input.position)
                _G_apply_930, lastError = self._apply(
                    self.rule_paren_gene, "paren_gene", []
                )
                self.considerError(lastError, None)
                return (_G_apply_930, self.currentError)

            def _G_or_931():
                _G_python_932, lastError = (None), None
                self.considerError(lastError, None)
                return (_G_python_932, self.currentError)

            _G_or_933, lastError = self._or([_G_or_929, _G_or_931])
            self.considerError(lastError, "opt_gene_expr")
            _locals["gene"] = _G_or_933
            _G_python_935, lastError = (
                eval(self._G_expr_934, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "opt_gene_expr")
            return (_G_python_935, self.currentError)

        def rule_paren_gene(self):
            _locals = {"self": self}
            self.locals["paren_gene"] = _locals
            self._trace("", (13082, 13086), self.input.position)
            _G_exactly_936, lastError = self.exactly("(")
            self.considerError(lastError, "paren_gene")
            self._trace("", (13086, 13098), self.input.position)
            _G_apply_937, lastError = self._apply(
                self.rule_gene_symbol, "gene_symbol", []
            )
            self.considerError(lastError, "paren_gene")
            _locals["symbol"] = _G_apply_937
            self._trace("", (13105, 13109), self.input.position)
            _G_exactly_938, lastError = self.exactly(")")
            self.considerError(lastError, "paren_gene")
            _G_python_940, lastError = (
                eval(self._G_expr_939, self.globals, _locals),
                None,
            )
            self.considerError(lastError, "paren_gene")
            return (_G_python_940, self.currentError)

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

            def _G_consumedby_941():
                self._trace("", (13135, 13141), self.input.position)
                _G_apply_942, lastError = self._apply(self.rule_letter, "letter", [])
                self.considerError(lastError, None)

                def _G_many1_943():
                    def _G_or_944():
                        self._trace("", (13143, 13156), self.input.position)
                        _G_apply_945, lastError = self._apply(
                            self.rule_letterOrDigit, "letterOrDigit", []
                        )
                        self.considerError(lastError, None)
                        return (_G_apply_945, self.currentError)

                    def _G_or_946():
                        def _G_or_947():
                            self._trace("", (13160, 13163), self.input.position)
                            _G_exactly_948, lastError = self.exactly("-")
                            self.considerError(lastError, None)
                            return (_G_exactly_948, self.currentError)

                        def _G_or_949():
                            self._trace("", (13164, 13167), self.input.position)
                            _G_exactly_950, lastError = self.exactly("_")
                            self.considerError(lastError, None)
                            return (_G_exactly_950, self.currentError)

                        _G_or_951, lastError = self._or([_G_or_947, _G_or_949])
                        self.considerError(lastError, None)

                        def _G_lookahead_952():
                            self._trace("", (13171, 13184), self.input.position)
                            _G_apply_953, lastError = self._apply(
                                self.rule_letterOrDigit, "letterOrDigit", []
                            )
                            self.considerError(lastError, None)
                            return (_G_apply_953, self.currentError)

                        _G_lookahead_954, lastError = self.lookahead(_G_lookahead_952)
                        self.considerError(lastError, None)
                        return (_G_lookahead_954, self.currentError)

                    _G_or_955, lastError = self._or([_G_or_944, _G_or_946])
                    self.considerError(lastError, None)
                    return (_G_or_955, self.currentError)

                _G_many1_956, lastError = self.many(_G_many1_943, _G_many1_943())
                self.considerError(lastError, None)
                return (_G_many1_956, self.currentError)

            _G_consumedby_957, lastError = self.consumedby(_G_consumedby_941)
            self.considerError(lastError, "gene_symbol")
            return (_G_consumedby_957, 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_521 = compile("hgvs.location.Interval(start,end)", "<string>", "eval")
        _G_expr_525 = compile("hgvs.location.Interval(start,None)", "<string>", "eval")
        _G_expr_559 = compile(
            "hgvs.location.BaseOffsetInterval(start,end)", "<string>", "eval"
        )
        _G_expr_563 = compile(
            "hgvs.location.BaseOffsetInterval(start,None)", "<string>", "eval"
        )
        _G_expr_583 = compile(
            "hgvs.location.Interval(start=iv_start._set_uncertain(), end=iv_end._set_uncertain())",
            "<string>",
            "eval",
        )
        _G_expr_591 = compile(
            "hgvs.location.Interval(start=iv_start, end=iv_end._set_uncertain())",
            "<string>",
            "eval",
        )
        _G_expr_599 = compile(
            "hgvs.location.Interval(start=iv_start._set_uncertain(), end=iv_end)",
            "<string>",
            "eval",
        )
        _G_expr_616 = compile(
            "hgvs.location.BaseOffsetPosition(b,o,datum=hgvs.enums.Datum.CDS_START)",
            "<string>",
            "eval",
        )
        _G_expr_622 = compile(
            "hgvs.location.BaseOffsetPosition(b,o,datum=hgvs.enums.Datum.CDS_END)",
            "<string>",
            "eval",
        )
        _G_expr_631 = compile("hgvs.location.SimplePosition(pos)", "<string>", "eval")
        _G_expr_642 = compile(
            "hgvs.location.BaseOffsetPosition(b,o,datum=hgvs.enums.Datum.SEQ_START)",
            "<string>",
            "eval",
        )
        _G_expr_650 = compile(
            "hgvs.location.AAPosition(pos,bioutils.sequences.aa_to_aa1(aa))",
            "<string>",
            "eval",
        )
        _G_expr_661 = compile("n", "<string>", "eval")
        _G_expr_669 = compile("(aat, n)", "<string>", "eval")
        _G_expr_764 = compile("x in 'ACDEFGHIKLMNPQRSTVWYBZXU'", "<string>", "eval")
        _G_expr_767 = compile("x", "<string>", "eval")
        _G_expr_841 = compile(
            "x in 'ACGTRYMKWSBDHVNacgtrymkwsbdhvn'", "<string>", "eval"
        )
        _G_expr_847 = compile(
            "x in 'ACGTURYMKWSBDHVNacgturymkwsbdhvn'", "<string>", "eval"
        )
        _G_expr_854 = compile(
            "x in 'ACGURYMKWSBDHVNacgurymkwsbdhvn'", "<string>", "eval"
        )
        _G_expr_860 = compile("x in 'X*'", "<string>", "eval")
        _G_expr_875 = compile("int(x)", "<string>", "eval")
        _G_expr_890 = compile("x in '-+'", "<string>", "eval")
        _G_expr_934 = compile("gene", "<string>", "eval")
        _G_expr_939 = 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
