diff --git a/Lib/test/test_peg_generator/test_c_generator.py b/Lib/test/test_peg_generator/test_c_generator.py
index 6d5cad8618bb1b..e4dea3280b46fe 100644
--- a/Lib/test/test_peg_generator/test_c_generator.py
+++ b/Lib/test/test_peg_generator/test_c_generator.py
@@ -1,4 +1,5 @@
 import io
+import token
 import textwrap
 import unittest
 from pathlib import Path, PurePath
@@ -30,6 +31,10 @@ def emit_parser(self, parser):
         CParserEmitter(parser, output).emit()
         return output.getvalue()
 
+    def prepare_rules(self, source):
+        parser = self.make_generator(source).prepare(PurePath("example.gram"))
+        return {rule.signature.name: rule for rule in parser.rules}
+
     def test_rule_types_distinguish_implicit_and_explicit_void_pointer(self):
         generator = self.make_generator("""
             start: &implicit implicit explicit
@@ -289,6 +294,106 @@ def test_keywords_are_numbered_once(self):
         self.assertEqual(generator.keywords, {"if": 500, "else": 501, "pass": 502})
         self.assertEqual(generator.soft_keywords, {"soft"})
 
+    def test_first_set_dispatch(self):
+        rules = self.prepare_rules("""
+            start: NAME | '(' NAME | 'if' NAME | "match" NUMBER
+        """)
+        self.assertEqual(
+            rules["start"].first_set_dispatch,
+            (
+                frozenset({token.NAME}),
+                frozenset({token.LPAR}),
+                # Keyword types are numbered from 500.
+                frozenset({500}),
+                # Soft keywords are NAME tokens.
+                frozenset({token.NAME}),
+            ),
+        )
+
+    def test_first_set_dispatch_ignores_second_pass_alternatives(self):
+        rules = self.prepare_rules("""
+            start: NAME | invalid_start | NUMBER
+            single: NAME | invalid_start
+            invalid_start: STRING
+        """)
+        self.assertEqual(
+            rules["start"].first_set_dispatch,
+            (frozenset({token.NAME}), frozenset(), frozenset({token.NUMBER})),
+        )
+        self.assertIsNone(rules["single"].first_set_dispatch)
+
+    def test_no_first_set_dispatch(self):
+        cases = {
+            "single": "NAME",
+            "same_sets": "NAME '+' NAME | NAME",
+            "unknown": "~ NAME | [NUMBER]",
+        }
+        rules = self.prepare_rules(
+            "start: " + " | ".join(cases) + "\n"
+            + "".join(f"{name}: {rhs}\n" for name, rhs in cases.items())
+        )
+        for name in cases:
+            with self.subTest(name):
+                self.assertIsNone(rules[name].first_set_dispatch)
+
+    def test_first_set_dispatch_in_second_pass_rules(self):
+        rules = self.prepare_rules("""
+            start: NAME | invalid_start
+            invalid_start: (NAME | NUMBER) helper
+            helper: NAME | NUMBER
+        """)
+        self.assertEqual(
+            rules["helper"].first_set_dispatch,
+            (frozenset({token.NAME}), frozenset({token.NUMBER})),
+        )
+
+    def test_first_set_dispatch_emission(self):
+        generator = self.make_generator("""
+            start: disjoint | overlapping
+            disjoint: NAME | NUMBER
+            overlapping: NAME '+' NAME | NUMBER | ~ STRING
+        """)
+        source = self.emit_parser(generator.prepare(PurePath("example.gram")))
+        disjoint = source[source.index("\ndisjoint_rule(") : source.index("\noverlapping_rule(")]
+        self.assertIn(f"case {token.NAME}:\n                goto _first_set_alt_0;", disjoint)
+        self.assertNotIn("_first_set_mask", disjoint)
+        overlapping = source[source.index("\noverlapping_rule(") :]
+        # The alternative with an unknown first set is tried for every token.
+        self.assertIn(
+            f"case {token.NAME}:\n                _first_set_mask = 0x5ULL;", overlapping
+        )
+        self.assertIn("default:\n                _first_set_mask = 0x4ULL;", overlapping)
+
+    def test_loop_first_set_check(self):
+        rules = self.prepare_rules("""
+            start: element+ keyword* NAME* large*
+            element: NAME | NUMBER
+            keyword: 'if' NAME
+            large: tstring_end NAME
+            tstring_end: TSTRING_END
+        """)
+        checks = {}
+        for name, rule in rules.items():
+            if rule.signature.kind in {RuleKind.LOOP0, RuleKind.LOOP1}:
+                alt, = rule.alternatives
+                first = alt.calls[0]
+                if first.function == "_PyPegen_next_token_in":
+                    checks[str(alt.text)] = first.arguments
+                else:
+                    checks[str(alt.text)] = None
+        self.assertEqual(
+            checks,
+            {
+                "element": ("p", f"0x{1 << token.NAME | 1 << token.NUMBER:x}ULL", "0x0ULL"),
+                # Keyword types are numbered from 500.
+                "keyword": ("p", "0x0ULL", "0x1ULL"),
+                # Matching the token costs no more than checking it.
+                "NAME": None,
+                # The mask has no bit for a token type above 63.
+                "large": None,
+            },
+        )
+
 
 class TestIncludedCFiles(unittest.TestCase):
     def setUp(self):
diff --git a/Lib/test/test_peg_generator/test_first_sets.py b/Lib/test/test_peg_generator/test_first_sets.py
index d6f8322f034f74..3d2caabaa5966f 100644
--- a/Lib/test/test_peg_generator/test_first_sets.py
+++ b/Lib/test/test_peg_generator/test_first_sets.py
@@ -7,14 +7,18 @@
 with test_tools.imports_under_tool("peg_generator"):
     from pegen.grammar_parser import GeneratedParser as GrammarParser
     from pegen.testutil import parse_string
-    from pegen.first_sets import FirstSetCalculator
+    from pegen.grammar_analysis import FirstSetVisitor
     from pegen.grammar import Grammar
 
 
 class TestFirstSets(unittest.TestCase):
-    def calculate_first_sets(self, grammar_source: str) -> Dict[str, Set[str]]:
+    def calculate_first_sets(self, grammar_source: str) -> Dict[str, Set[str] | None]:
         grammar: Grammar = parse_string(grammar_source, GrammarParser)
-        return FirstSetCalculator(grammar.rules).calculate()
+        first_sets = FirstSetVisitor(grammar.rules).first_sets
+        return {
+            name: None if first is None else set(first)
+            for name, first in first_sets.items()
+        }
 
     def test_alternatives(self) -> None:
         grammar = """
@@ -178,10 +182,12 @@ def test_negative_lookahead(self) -> None:
         """
         self.assertEqual(
             self.calculate_first_sets(grammar),
+            # A negative lookahead doesn't narrow the first set, but its own
+            # first set is included for the effects it may have.
             {
                 "opt": {"'b'", "'a'", "'c'"},
-                "expr": {"'b'", "'c'"},
-                "start": {"'b'", "'c'"},
+                "expr": {"'a'", "'b'", "'c'"},
+                "start": {"'a'", "'b'", "'c'"},
             },
         )
 
@@ -213,7 +219,8 @@ def test_advance_left_recursion(self) -> None:
         """
         self.assertEqual(
             self.calculate_first_sets(grammar),
-            {"sign": {"'-'", ""}, "start": {"'-'", "NUMBER"}},
+            # sign may match whatever the next token is.
+            {"sign": None, "start": None},
         )
 
     def test_mutual_left_recursion(self) -> None:
@@ -226,13 +233,12 @@ def test_mutual_left_recursion(self) -> None:
             self.calculate_first_sets(grammar),
             {
                 "foo": {"'D'", "'B'"},
-                "bar": {"'D'"},
+                "bar": {"'D'", "'B'"},
                 "start": {"'D'", "'B'"},
             },
         )
 
     def test_nasty_left_recursion(self) -> None:
-        # TODO: Validate this
         grammar = """
         start: target '='
         target: maybe '+' | NAME
@@ -240,7 +246,7 @@ def test_nasty_left_recursion(self) -> None:
         """
         self.assertEqual(
             self.calculate_first_sets(grammar),
-            {"maybe": set(), "target": {"NAME"}, "start": {"NAME"}},
+            {"maybe": {"NAME"}, "target": {"NAME"}, "start": {"NAME"}},
         )
 
     def test_nullable_rule(self) -> None:
@@ -252,9 +258,9 @@ def test_nullable_rule(self) -> None:
         self.assertEqual(
             self.calculate_first_sets(grammar),
             {
-                "sign": {"", "'-'"},
+                "sign": None,
                 "thing": {"NUMBER"},
-                "start": {"NUMBER", "'-'"},
+                "start": None,
             },
         )
 
@@ -277,10 +283,60 @@ def test_multiple_nullable_rules(self) -> None:
         self.assertEqual(
             self.calculate_first_sets(grammar),
             {
-                "sign": {"", "'-'"},
-                "thing": {"'+'", ""},
-                "start": {"'+'", "'-'", "'*'"},
+                "sign": None,
+                "thing": None,
+                "start": None,
                 "other": {"'*'"},
                 "another": {"'/'"},
             },
         )
+
+    def test_keywords_and_exact_tokens(self) -> None:
+        grammar = """
+        start: 'if' NAME | '(' NAME ')'
+        """
+        self.assertEqual(self.calculate_first_sets(grammar), {"start": {"'if'", "'('"}})
+
+    def test_soft_keywords(self) -> None:
+        grammar = """
+        start: "match" NAME | SOFT_KEYWORD NUMBER
+        """
+        self.assertEqual(self.calculate_first_sets(grammar), {"start": {"NAME"}})
+
+    def test_leading_cut(self) -> None:
+        grammar = """
+        start: choice NEWLINE
+        choice: ~ NAME | NUMBER
+        """
+        self.assertEqual(
+            self.calculate_first_sets(grammar), {"choice": None, "start": None}
+        )
+
+    def test_forced(self) -> None:
+        grammar = """
+        start: choice NEWLINE
+        choice: &&'+' | NAME &&':' NUMBER
+        """
+        self.assertEqual(
+            self.calculate_first_sets(grammar), {"choice": None, "start": None}
+        )
+        grammar = """
+        start: NAME &&':' NUMBER
+        """
+        self.assertEqual(self.calculate_first_sets(grammar), {"start": {"NAME"}})
+
+    def test_negative_lookahead_effects(self) -> None:
+        grammar = """
+        start: !guard NAME
+        guard: NUMBER
+        """
+        self.assertEqual(
+            self.calculate_first_sets(grammar),
+            {"guard": {"NUMBER"}, "start": {"NAME", "NUMBER"}},
+        )
+
+    def test_positive_lookahead_alone(self) -> None:
+        grammar = """
+        start: &NUMBER
+        """
+        self.assertEqual(self.calculate_first_sets(grammar), {"start": {"NUMBER"}})
diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst b/Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst
new file mode 100644
index 00000000000000..6e51be84536bce
--- /dev/null
+++ b/Misc/NEWS.d/next/Core_and_Builtins/2026-10-23-18-07-52.gh-issue-153568.Y6LTe5.rst
@@ -0,0 +1,3 @@
+Speed up the parser by computing the first set of each rule and skipping
+alternatives that cannot start with the next token based on those first
+sets.
diff --git a/Parser/parser.c b/Parser/parser.c
index 76ff308cfc9394..dee54fdf166c2f 100644
--- a/Parser/parser.c
+++ b/Parser/parser.c
@@ -1160,6 +1160,66 @@ statement_rule(Parser *p)
     }
     asdl_stmt_seq* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 49:
+            case 512:
+            case 513:
+            case 514:
+            case 515:
+            case 516:
+            case 517:
+            case 518:
+            case 519:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 500:
+            case 501:
+            case 502:
+            case 503:
+            case 504:
+            case 505:
+            case 506:
+            case 507:
+            case 508:
+            case 509:
+            case 510:
+            case 511:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // compound_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1184,6 +1244,7 @@ statement_rule(Parser *p)
         D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // simple_stmts
         if (p->error_indicator) {
             p->level--;
@@ -1279,6 +1340,67 @@ statement_newline_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 49:
+            case 512:
+            case 513:
+            case 514:
+            case 515:
+            case 516:
+            case 517:
+            case 518:
+            case 519:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 500:
+            case 501:
+            case 502:
+            case 503:
+            case 504:
+            case 505:
+            case 506:
+            case 507:
+            case 508:
+            case 509:
+            case 510:
+            case 511:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3ULL;
+                break;
+            case 4:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 0:
+                _first_set_mask = 0x8ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // single_compound_stmt NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -1306,6 +1428,7 @@ statement_newline_rule(Parser *p)
         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_compound_stmt NEWLINE"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // simple_stmts
         if (p->error_indicator) {
             p->level--;
@@ -1325,6 +1448,7 @@ statement_newline_rule(Parser *p)
         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -1358,6 +1482,7 @@ statement_newline_rule(Parser *p)
         D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // $
         if (p->error_indicator) {
             p->level--;
@@ -1507,6 +1632,72 @@ simple_stmt_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 500:
+            case 501:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x9ULL;
+                break;
+            case 1:
+                _first_set_mask = 0xfULL;
+                break;
+            case 502:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 503:
+                _first_set_mask = 0x20ULL;
+                break;
+            case 504:
+                _first_set_mask = 0x49ULL;
+                break;
+            case 505:
+                _first_set_mask = 0x80ULL;
+                break;
+            case 506:
+                _first_set_mask = 0x101ULL;
+                break;
+            case 507:
+                _first_set_mask = 0x200ULL;
+                break;
+            case 508:
+                _first_set_mask = 0x409ULL;
+                break;
+            case 509:
+                _first_set_mask = 0x809ULL;
+                break;
+            case 510:
+                _first_set_mask = 0x1000ULL;
+                break;
+            case 511:
+                _first_set_mask = 0x2000ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // assignment
         if (p->error_indicator) {
             p->level--;
@@ -1526,6 +1717,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // &"type" type_alias
         if (p->error_indicator) {
             p->level--;
@@ -1547,6 +1739,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&\"type\" type_alias"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // &('import' | 'from' | "lazy") import_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1568,6 +1761,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from' | \"lazy\") import_stmt"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // star_expressions
         if (p->error_indicator) {
             p->level--;
@@ -1601,6 +1795,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // &'return' return_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1622,6 +1817,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // &'raise' raise_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1643,6 +1839,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // &'pass' pass_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1664,6 +1861,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'pass' pass_stmt"));
     }
+    if (_first_set_mask & 0x80ULL)
     { // &'del' del_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1685,6 +1883,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt"));
     }
+    if (_first_set_mask & 0x100ULL)
     { // &'yield' yield_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1706,6 +1905,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt"));
     }
+    if (_first_set_mask & 0x200ULL)
     { // &'assert' assert_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1727,6 +1927,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt"));
     }
+    if (_first_set_mask & 0x400ULL)
     { // &'break' break_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1748,6 +1949,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'break' break_stmt"));
     }
+    if (_first_set_mask & 0x800ULL)
     { // &'continue' continue_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1769,6 +1971,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'continue' continue_stmt"));
     }
+    if (_first_set_mask & 0x1000ULL)
     { // &'global' global_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1790,6 +1993,7 @@ simple_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt"));
     }
+    if (_first_set_mask & 0x2000ULL)
     { // &'nonlocal' nonlocal_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1839,6 +2043,50 @@ compound_stmt_rule(Parser *p)
     }
     stmt_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 512:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 514:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 515:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 49:
+                _first_set_mask = 0x5ULL;
+                break;
+            case 516:
+                _first_set_mask = 0x8ULL;
+                break;
+            case 517:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 513:
+                _first_set_mask = 0x19ULL;
+                break;
+            case 518:
+                _first_set_mask = 0x20ULL;
+                break;
+            case 519:
+                _first_set_mask = 0x40ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x80ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // &('def' | '@' | 'async') function_def
         if (p->error_indicator) {
             p->level--;
@@ -1860,6 +2108,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('def' | '@' | 'async') function_def"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // &'if' if_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1881,6 +2130,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // &('class' | '@') class_def
         if (p->error_indicator) {
             p->level--;
@@ -1902,6 +2152,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // &('with' | 'async') with_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1923,6 +2174,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('with' | 'async') with_stmt"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // &('for' | 'async') for_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1944,6 +2196,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('for' | 'async') for_stmt"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // &'try' try_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1965,6 +2218,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // &'while' while_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1986,6 +2240,7 @@ compound_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt"));
     }
+    if (_first_set_mask & 0x80ULL)
     { // match_stmt
         if (p->error_indicator) {
             p->level--;
@@ -2038,6 +2293,34 @@ assignment_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 25:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                _first_set_mask = 0xeULL;
+                break;
+            case 1:
+                _first_set_mask = 0xfULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // NAME ':' expression ['=' annotated_rhs]
         if (p->error_indicator) {
             p->level--;
@@ -2080,6 +2363,7 @@ assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // ('(' single_target ')' | attribute_or_subscript_target) ':' expression ['=' annotated_rhs]
         if (p->error_indicator) {
             p->level--;
@@ -2122,6 +2406,7 @@ assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | attribute_or_subscript_target) ':' expression ['=' annotated_rhs]"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // ((star_targets '='))+ annotated_rhs !'=' TYPE_COMMENT?
         if (p->error_indicator) {
             p->level--;
@@ -2163,6 +2448,7 @@ assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ annotated_rhs !'=' TYPE_COMMENT?"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // single_target augassign ~ annotated_rhs
         if (p->error_indicator) {
             p->level--;
@@ -2209,6 +2495,7 @@ assignment_rule(Parser *p)
             return NULL;
         }
     }
+    if (_first_set_mask & 0x10ULL)
     if (p->call_invalid_rules) { // invalid_assignment
         if (p->error_indicator) {
             p->level--;
@@ -2247,6 +2534,44 @@ annotated_rhs_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 506:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // yield_expr
         if (p->error_indicator) {
             p->level--;
@@ -2266,6 +2591,10 @@ annotated_rhs_rule(Parser *p)
         D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // star_expressions
         if (p->error_indicator) {
             p->level--;
@@ -2285,6 +2614,11 @@ annotated_rhs_rule(Parser *p)
         D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -2317,6 +2651,45 @@ augassign_rule(Parser *p)
     }
     AugOperator* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 36:
+                goto _first_set_alt_0;
+            case 37:
+                goto _first_set_alt_1;
+            case 38:
+                goto _first_set_alt_2;
+            case 50:
+                goto _first_set_alt_3;
+            case 39:
+                goto _first_set_alt_4;
+            case 40:
+                goto _first_set_alt_5;
+            case 41:
+                goto _first_set_alt_6;
+            case 42:
+                goto _first_set_alt_7;
+            case 43:
+                goto _first_set_alt_8;
+            case 44:
+                goto _first_set_alt_9;
+            case 45:
+                goto _first_set_alt_10;
+            case 46:
+                goto _first_set_alt_11;
+            case 48:
+                goto _first_set_alt_12;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '+='
         if (p->error_indicator) {
             p->level--;
@@ -2341,6 +2714,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '-='
         if (p->error_indicator) {
             p->level--;
@@ -2365,6 +2742,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '*='
         if (p->error_indicator) {
             p->level--;
@@ -2389,6 +2770,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // '@='
         if (p->error_indicator) {
             p->level--;
@@ -2413,6 +2798,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_4:
     { // '/='
         if (p->error_indicator) {
             p->level--;
@@ -2437,6 +2826,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_5:
     { // '%='
         if (p->error_indicator) {
             p->level--;
@@ -2461,6 +2854,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_6:
     { // '&='
         if (p->error_indicator) {
             p->level--;
@@ -2485,6 +2882,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_7:
     { // '|='
         if (p->error_indicator) {
             p->level--;
@@ -2509,6 +2910,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_8:
     { // '^='
         if (p->error_indicator) {
             p->level--;
@@ -2533,6 +2938,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_9:
     { // '<<='
         if (p->error_indicator) {
             p->level--;
@@ -2557,6 +2966,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_10:
     { // '>>='
         if (p->error_indicator) {
             p->level--;
@@ -2581,6 +2994,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_11:
     { // '**='
         if (p->error_indicator) {
             p->level--;
@@ -2605,6 +3022,10 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_12:
     { // '//='
         if (p->error_indicator) {
             p->level--;
@@ -2629,6 +3050,11 @@ augassign_rule(Parser *p)
         D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -3421,6 +3847,29 @@ import_stmt_rule(Parser *p)
         return _res;
     }
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 500:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 501:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x6ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     if (p->call_invalid_rules) { // invalid_import
         if (p->error_indicator) {
             p->level--;
@@ -3440,6 +3889,7 @@ import_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // import_name
         if (p->error_indicator) {
             p->level--;
@@ -3459,6 +3909,7 @@ import_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // import_from
         if (p->error_indicator) {
             p->level--;
@@ -3721,6 +4172,20 @@ import_from_targets_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+                goto _first_set_alt_0;
+            case 1:
+                goto _first_set_alt_1;
+            case 16:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '(' import_from_as_names ','? ')'
         if (p->error_indicator) {
             p->level--;
@@ -3755,6 +4220,10 @@ import_from_targets_rule(Parser *p)
         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' import_from_as_names ','? ')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // import_from_as_names !','
         if (p->error_indicator) {
             p->level--;
@@ -3776,6 +4245,10 @@ import_from_targets_rule(Parser *p)
         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names !','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '*'
         if (p->error_indicator) {
             p->level--;
@@ -3809,6 +4282,9 @@ import_from_targets_rule(Parser *p)
         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_import_from_targets
         if (p->error_indicator) {
             p->level--;
@@ -3828,6 +4304,11 @@ import_from_targets_rule(Parser *p)
         D(fprintf(stderr, "%*c%s import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_import_from_targets"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -4209,6 +4690,53 @@ block_rule(Parser *p)
         return _res;
     }
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 4:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 500:
+            case 501:
+            case 502:
+            case 503:
+            case 504:
+            case 505:
+            case 506:
+            case 507:
+            case 508:
+            case 509:
+            case 510:
+            case 511:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // NEWLINE INDENT statements DEDENT
         if (p->error_indicator) {
             p->level--;
@@ -4242,6 +4770,10 @@ block_rule(Parser *p)
         D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // simple_stmts
         if (p->error_indicator) {
             p->level--;
@@ -4261,6 +4793,9 @@ block_rule(Parser *p)
         D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmts"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_block
         if (p->error_indicator) {
             p->level--;
@@ -4280,6 +4815,11 @@ block_rule(Parser *p)
         D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, block_type, _res);
@@ -4343,6 +4883,23 @@ class_def_rule(Parser *p)
     }
     stmt_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 49:
+                goto _first_set_alt_0;
+            case 515:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // decorators class_def_raw
         if (p->error_indicator) {
             p->level--;
@@ -4370,6 +4927,10 @@ class_def_rule(Parser *p)
         D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators class_def_raw"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // class_def_raw
         if (p->error_indicator) {
             p->level--;
@@ -4389,6 +4950,11 @@ class_def_rule(Parser *p)
         D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -4505,6 +5071,24 @@ function_def_rule(Parser *p)
     }
     stmt_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 49:
+                goto _first_set_alt_0;
+            case 512:
+            case 513:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // decorators function_def_raw
         if (p->error_indicator) {
             p->level--;
@@ -4532,6 +5116,10 @@ function_def_rule(Parser *p)
         D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "decorators function_def_raw"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // function_def_raw
         if (p->error_indicator) {
             p->level--;
@@ -4551,6 +5139,11 @@ function_def_rule(Parser *p)
         D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -4582,6 +5175,17 @@ function_def_raw_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 512:
+                goto _first_set_alt_1;
+            case 513:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
     if (p->call_invalid_rules) { // invalid_def_raw
         if (p->error_indicator) {
             p->level--;
@@ -4601,6 +5205,10 @@ function_def_raw_rule(Parser *p)
         D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_def_raw"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
         if (p->error_indicator) {
             p->level--;
@@ -4661,6 +5269,10 @@ function_def_raw_rule(Parser *p)
         D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // 'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block
         if (p->error_indicator) {
             p->level--;
@@ -4724,6 +5336,11 @@ function_def_raw_rule(Parser *p)
         D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'def' NAME type_params? '(' params? ')' ['->' expression] ':' func_type_comment? block"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -4805,6 +5422,27 @@ parameters_rule(Parser *p)
     }
     arguments_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                _first_set_mask = 0xfULL;
+                break;
+            case 16:
+            case 35:
+                _first_set_mask = 0x10ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // slash_no_default param_no_default* param_with_default* star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -4838,6 +5476,7 @@ parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // slash_with_default param_with_default* star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -4868,6 +5507,7 @@ parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // param_no_default+ param_with_default* star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -4898,6 +5538,7 @@ parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // param_with_default+ star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -4925,6 +5566,7 @@ parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+ star_etc?"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // star_etc
         if (p->error_indicator) {
             p->level--;
@@ -5137,6 +5779,26 @@ star_etc_rule(Parser *p)
     }
     StarEtc* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0xeULL;
+                break;
+            case 35:
+                _first_set_mask = 0x10ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     if (p->call_invalid_rules) { // invalid_star_etc
         if (p->error_indicator) {
             p->level--;
@@ -5156,6 +5818,7 @@ star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // '*' param_no_default param_maybe_default* kwds?
         if (p->error_indicator) {
             p->level--;
@@ -5189,6 +5852,7 @@ star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // '*' param_no_default_star_annotation param_maybe_default* kwds?
         if (p->error_indicator) {
             p->level--;
@@ -5222,6 +5886,7 @@ star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' param_no_default_star_annotation param_maybe_default* kwds?"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // '*' ',' param_maybe_default+ kwds?
         if (p->error_indicator) {
             p->level--;
@@ -5255,6 +5920,7 @@ star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // kwds
         if (p->error_indicator) {
             p->level--;
@@ -6429,6 +7095,17 @@ for_stmt_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 517:
+                goto _first_set_alt_1;
+            case 513:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
     if (p->call_invalid_rules) { // invalid_for_stmt
         if (p->error_indicator) {
             p->level--;
@@ -6448,6 +7125,10 @@ for_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_stmt"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
         if (p->error_indicator) {
             p->level--;
@@ -6509,6 +7190,10 @@ for_stmt_rule(Parser *p)
             return NULL;
         }
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // 'async' 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
         if (p->error_indicator) {
             p->level--;
@@ -6573,6 +7258,9 @@ for_stmt_rule(Parser *p)
             return NULL;
         }
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_for_target
         if (p->error_indicator) {
             p->level--;
@@ -6592,6 +7280,11 @@ for_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -6626,6 +7319,21 @@ with_stmt_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 516:
+                _first_set_mask = 0x6ULL;
+                break;
+            case 513:
+                _first_set_mask = 0x18ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     if (p->call_invalid_rules) { // invalid_with_stmt_indent
         if (p->error_indicator) {
             p->level--;
@@ -6645,6 +7353,7 @@ with_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_stmt_indent"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // 'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block
         if (p->error_indicator) {
             p->level--;
@@ -6700,6 +7409,7 @@ with_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' TYPE_COMMENT? block"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // 'with' ','.with_item+ ':' TYPE_COMMENT? block
         if (p->error_indicator) {
             p->level--;
@@ -6745,6 +7455,7 @@ with_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // 'async' 'with' '(' ','.with_item+ ','? ')' ':' block
         if (p->error_indicator) {
             p->level--;
@@ -6800,6 +7511,7 @@ with_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'with' '(' ','.with_item+ ','? ')' ':' block"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // 'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block
         if (p->error_indicator) {
             p->level--;
@@ -6848,6 +7560,7 @@ with_stmt_rule(Parser *p)
         D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async' 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
     }
+    if (_first_set_mask & 0x20ULL)
     if (p->call_invalid_rules) { // invalid_with_stmt
         if (p->error_indicator) {
             p->level--;
@@ -7804,6 +8517,41 @@ subject_expr_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // star_named_expression ',' star_named_expressions?
         if (p->error_indicator) {
             p->level--;
@@ -7843,6 +8591,7 @@ subject_expr_rule(Parser *p)
         D(fprintf(stderr, "%*c%s subject_expr[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // named_expression
         if (p->error_indicator) {
             p->level--;
@@ -8010,6 +8759,33 @@ patterns_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // open_sequence_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8043,6 +8819,7 @@ patterns_rule(Parser *p)
         D(fprintf(stderr, "%*c%s patterns[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "open_sequence_pattern"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // pattern
         if (p->error_indicator) {
             p->level--;
@@ -8297,6 +9074,43 @@ closed_pattern_rule(Parser *p)
         return _res;
     }
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 14:
+            case 15:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 9:
+                _first_set_mask = 0x20ULL;
+                break;
+            case 7:
+                _first_set_mask = 0x30ULL;
+                break;
+            case 25:
+                _first_set_mask = 0x40ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x8eULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // literal_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8316,6 +9130,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_pattern"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // capture_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8335,6 +9150,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "capture_pattern"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // wildcard_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8354,6 +9170,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "wildcard_pattern"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // value_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8373,6 +9190,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "value_pattern"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // group_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8392,6 +9210,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group_pattern"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // sequence_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8411,6 +9230,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sequence_pattern"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // mapping_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8430,6 +9250,7 @@ closed_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s closed_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "mapping_pattern"));
     }
+    if (_first_set_mask & 0x80ULL)
     { // class_pattern
         if (p->error_indicator) {
             p->level--;
@@ -8484,6 +9305,34 @@ literal_pattern_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 14:
+            case 15:
+                _first_set_mask = 0x3ULL;
+                break;
+            case 3:
+            case 59:
+            case 62:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 526:
+                _first_set_mask = 0x8ULL;
+                break;
+            case 527:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 528:
+                _first_set_mask = 0x20ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // signed_number !('+' | '-')
         if (p->error_indicator) {
             p->level--;
@@ -8519,6 +9368,7 @@ literal_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // complex_number
         if (p->error_indicator) {
             p->level--;
@@ -8552,6 +9402,7 @@ literal_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // strings
         if (p->error_indicator) {
             p->level--;
@@ -8585,6 +9436,7 @@ literal_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "strings"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // 'None'
         if (p->error_indicator) {
             p->level--;
@@ -8618,6 +9470,7 @@ literal_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // 'True'
         if (p->error_indicator) {
             p->level--;
@@ -8651,6 +9504,7 @@ literal_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // 'False'
         if (p->error_indicator) {
             p->level--;
@@ -8718,6 +9572,34 @@ literal_expr_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 14:
+            case 15:
+                _first_set_mask = 0x3ULL;
+                break;
+            case 3:
+            case 59:
+            case 62:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 526:
+                _first_set_mask = 0x8ULL;
+                break;
+            case 527:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 528:
+                _first_set_mask = 0x20ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // signed_number !('+' | '-')
         if (p->error_indicator) {
             p->level--;
@@ -8739,6 +9621,7 @@ literal_expr_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "signed_number !('+' | '-')"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // complex_number
         if (p->error_indicator) {
             p->level--;
@@ -8758,6 +9641,7 @@ literal_expr_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "complex_number"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // &(STRING | FSTRING_START | TSTRING_START) strings
         if (p->error_indicator) {
             p->level--;
@@ -8779,6 +9663,7 @@ literal_expr_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // 'None'
         if (p->error_indicator) {
             p->level--;
@@ -8812,6 +9697,7 @@ literal_expr_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // 'True'
         if (p->error_indicator) {
             p->level--;
@@ -8845,6 +9731,7 @@ literal_expr_rule(Parser *p)
         D(fprintf(stderr, "%*c%s literal_expr[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // 'False'
         if (p->error_indicator) {
             p->level--;
@@ -9014,6 +9901,20 @@ signed_number_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+                goto _first_set_alt_0;
+            case 14:
+                goto _first_set_alt_1;
+            case 15:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // NUMBER
         if (p->error_indicator) {
             p->level--;
@@ -9033,6 +9934,10 @@ signed_number_rule(Parser *p)
         D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '+' NUMBER
         if (p->error_indicator) {
             p->level--;
@@ -9069,6 +9974,10 @@ signed_number_rule(Parser *p)
         D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' NUMBER"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '-' NUMBER
         if (p->error_indicator) {
             p->level--;
@@ -9105,6 +10014,11 @@ signed_number_rule(Parser *p)
         D(fprintf(stderr, "%*c%s signed_number[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' NUMBER"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9133,6 +10047,20 @@ signed_real_number_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+                goto _first_set_alt_0;
+            case 14:
+                goto _first_set_alt_1;
+            case 15:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // real_number
         if (p->error_indicator) {
             p->level--;
@@ -9152,6 +10080,10 @@ signed_real_number_rule(Parser *p)
         D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "real_number"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '+' real_number
         if (p->error_indicator) {
             p->level--;
@@ -9188,6 +10120,10 @@ signed_real_number_rule(Parser *p)
         D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' real_number"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '-' real_number
         if (p->error_indicator) {
             p->level--;
@@ -9224,6 +10160,11 @@ signed_real_number_rule(Parser *p)
         D(fprintf(stderr, "%*c%s signed_real_number[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' real_number"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9782,6 +10723,18 @@ sequence_pattern_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 9:
+                goto _first_set_alt_0;
+            case 7:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '[' maybe_sequence_pattern? ']'
         if (p->error_indicator) {
             p->level--;
@@ -9821,6 +10774,10 @@ sequence_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' maybe_sequence_pattern? ']'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '(' open_sequence_pattern? ')'
         if (p->error_indicator) {
             p->level--;
@@ -9860,6 +10817,11 @@ sequence_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s sequence_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' open_sequence_pattern? ')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9975,6 +10937,35 @@ maybe_star_pattern_rule(Parser *p)
     }
     pattern_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // star_pattern
         if (p->error_indicator) {
             p->level--;
@@ -9994,6 +10985,10 @@ maybe_star_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_pattern"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // pattern
         if (p->error_indicator) {
             p->level--;
@@ -10013,6 +11008,11 @@ maybe_star_pattern_rule(Parser *p)
         D(fprintf(stderr, "%*c%s maybe_star_pattern[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pattern"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -11063,6 +12063,20 @@ type_param_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_0;
+            case 16:
+                goto _first_set_alt_2;
+            case 35:
+                goto _first_set_alt_3;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // NAME type_param_bound? type_param_default?
         if (p->error_indicator) {
             p->level--;
@@ -11102,6 +12116,9 @@ type_param_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME type_param_bound? type_param_default?"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_type_param
         if (p->error_indicator) {
             p->level--;
@@ -11121,6 +12138,10 @@ type_param_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_type_param"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '*' NAME type_param_starred_default?
         if (p->error_indicator) {
             p->level--;
@@ -11160,6 +12181,10 @@ type_param_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' NAME type_param_starred_default?"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // '**' NAME type_param_default?
         if (p->error_indicator) {
             p->level--;
@@ -11199,6 +12224,11 @@ type_param_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_param[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' NAME type_param_default?"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, type_param_type, _res);
@@ -11492,6 +12522,42 @@ expression_rule(Parser *p)
         return _res;
     }
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+                _first_set_mask = 0x18ULL;
+                break;
+            case 534:
+                _first_set_mask = 0x20ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     if (p->call_invalid_rules) { // invalid_if_expression
         if (p->error_indicator) {
             p->level--;
@@ -11511,6 +12577,7 @@ expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_if_expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     if (p->call_invalid_rules) { // invalid_expression
         if (p->error_indicator) {
             p->level--;
@@ -11530,6 +12597,7 @@ expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_expression"));
     }
+    if (_first_set_mask & 0x4ULL)
     if (p->call_invalid_rules) { // invalid_legacy_expression
         if (p->error_indicator) {
             p->level--;
@@ -11549,6 +12617,7 @@ expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_legacy_expression"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // if_expression
         if (p->error_indicator) {
             p->level--;
@@ -11568,6 +12637,7 @@ expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "if_expression"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // disjunction
         if (p->error_indicator) {
             p->level--;
@@ -11587,6 +12657,7 @@ expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // lambdef
         if (p->error_indicator) {
             p->level--;
@@ -11943,6 +13014,38 @@ star_expression_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '*' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -11979,6 +13082,10 @@ star_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // expression
         if (p->error_indicator) {
             p->level--;
@@ -11998,6 +13105,11 @@ star_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, star_expression_type, _res);
@@ -12074,6 +13186,38 @@ star_named_expression_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '*' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12110,6 +13254,10 @@ star_named_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // named_expression
         if (p->error_indicator) {
             p->level--;
@@ -12129,6 +13277,11 @@ star_named_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12222,6 +13375,45 @@ named_expression_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x5ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // assignment_expression
         if (p->error_indicator) {
             p->level--;
@@ -12241,6 +13433,7 @@ named_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     if (p->call_invalid_rules) { // invalid_named_expression
         if (p->error_indicator) {
             p->level--;
@@ -12260,6 +13453,7 @@ named_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // expression !':='
         if (p->error_indicator) {
             p->level--;
@@ -12493,6 +13687,33 @@ inversion_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 531:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 533:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'not' inversion
         if (p->error_indicator) {
             p->level--;
@@ -12529,6 +13750,10 @@ inversion_rule(Parser *p)
         D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // comparison
         if (p->error_indicator) {
             p->level--;
@@ -12548,6 +13773,11 @@ inversion_rule(Parser *p)
         D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, inversion_type, _res);
@@ -12664,6 +13894,47 @@ compare_op_bitwise_or_pair_rule(Parser *p)
     }
     CmpopExprPair* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 27:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 28:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 29:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 20:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 30:
+                _first_set_mask = 0x20ULL;
+                break;
+            case 21:
+                _first_set_mask = 0x40ULL;
+                break;
+            case 531:
+                _first_set_mask = 0x80ULL;
+                break;
+            case 523:
+                _first_set_mask = 0x100ULL;
+                break;
+            case 532:
+                _first_set_mask = 0x600ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // '==' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12691,6 +13962,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // ('!=') bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12718,6 +13990,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // '<=' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12745,6 +14018,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or"));
     }
+    if (_first_set_mask & 0x8ULL)
     if (p->call_invalid_rules) { // invalid_noteq
         if (p->error_indicator) {
             p->level--;
@@ -12764,6 +14038,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_noteq"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // '<' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12791,6 +14066,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // '>=' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12818,6 +14094,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // '>' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12845,6 +14122,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or"));
     }
+    if (_first_set_mask & 0x80ULL)
     { // 'not' 'in' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12875,6 +14153,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or"));
     }
+    if (_first_set_mask & 0x100ULL)
     { // 'in' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12902,6 +14181,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or"));
     }
+    if (_first_set_mask & 0x200ULL)
     { // 'is' 'not' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -12932,6 +14212,7 @@ compare_op_bitwise_or_pair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or"));
     }
+    if (_first_set_mask & 0x400ULL)
     { // 'is' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -14038,6 +15319,34 @@ factor_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 14:
+                goto _first_set_alt_0;
+            case 15:
+                goto _first_set_alt_1;
+            case 31:
+                goto _first_set_alt_2;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 25:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 533:
+                goto _first_set_alt_3;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '+' factor
         if (p->error_indicator) {
             p->level--;
@@ -14074,6 +15383,10 @@ factor_rule(Parser *p)
         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '-' factor
         if (p->error_indicator) {
             p->level--;
@@ -14110,6 +15423,10 @@ factor_rule(Parser *p)
         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '~' factor
         if (p->error_indicator) {
             p->level--;
@@ -14146,6 +15463,10 @@ factor_rule(Parser *p)
         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // power
         if (p->error_indicator) {
             p->level--;
@@ -14165,6 +15486,9 @@ factor_rule(Parser *p)
         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_factor
         if (p->error_indicator) {
             p->level--;
@@ -14184,6 +15508,11 @@ factor_rule(Parser *p)
         D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_factor"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, factor_type, _res);
@@ -14305,6 +15634,29 @@ await_primary_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 533:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 25:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'await' primary
         if (p->error_indicator) {
             p->level--;
@@ -14341,6 +15693,10 @@ await_primary_rule(Parser *p)
         D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'await' primary"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // primary
         if (p->error_indicator) {
             p->level--;
@@ -14360,6 +15716,11 @@ await_primary_rule(Parser *p)
         D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, await_primary_type, _res);
@@ -14640,6 +16001,42 @@ slices_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 11:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // slice !','
         if (p->error_indicator) {
             p->level--;
@@ -14666,6 +16063,7 @@ slices_rule(Parser *p)
         D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // ','.(slice | starred_expression)+ ','?
         if (p->error_indicator) {
             p->level--;
@@ -14731,6 +16129,41 @@ slice_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 11:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // expression? ':' expression? [':' expression?]
         if (p->error_indicator) {
             p->level--;
@@ -14773,6 +16206,7 @@ slice_rule(Parser *p)
         D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // named_expression
         if (p->error_indicator) {
             p->level--;
@@ -14835,6 +16269,36 @@ atom_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_0;
+            case 527:
+                goto _first_set_alt_1;
+            case 528:
+                goto _first_set_alt_2;
+            case 526:
+                goto _first_set_alt_3;
+            case 3:
+            case 59:
+            case 62:
+                goto _first_set_alt_4;
+            case 2:
+                goto _first_set_alt_5;
+            case 7:
+                goto _first_set_alt_6;
+            case 9:
+                goto _first_set_alt_7;
+            case 25:
+                goto _first_set_alt_8;
+            case 52:
+                goto _first_set_alt_9;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // NAME
         if (p->error_indicator) {
             p->level--;
@@ -14854,6 +16318,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'True'
         if (p->error_indicator) {
             p->level--;
@@ -14887,6 +16355,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // 'False'
         if (p->error_indicator) {
             p->level--;
@@ -14920,6 +16392,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // 'None'
         if (p->error_indicator) {
             p->level--;
@@ -14953,6 +16429,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_4:
     { // &(STRING | FSTRING_START | TSTRING_START) strings
         if (p->error_indicator) {
             p->level--;
@@ -14974,6 +16454,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&(STRING | FSTRING_START | TSTRING_START) strings"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_5:
     { // NUMBER
         if (p->error_indicator) {
             p->level--;
@@ -14993,6 +16477,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_6:
     { // &'(' (genexp | tuple | group)
         if (p->error_indicator) {
             p->level--;
@@ -15014,6 +16502,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (genexp | tuple | group)"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_7:
     { // &'[' (listcomp | list)
         if (p->error_indicator) {
             p->level--;
@@ -15035,6 +16527,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (listcomp | list)"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_8:
     { // &'{' (dictcomp | setcomp | dict | set)
         if (p->error_indicator) {
             p->level--;
@@ -15056,6 +16552,10 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dictcomp | setcomp | dict | set)"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_9:
     { // '...'
         if (p->error_indicator) {
             p->level--;
@@ -15089,6 +16589,11 @@ atom_rule(Parser *p)
         D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -15308,6 +16813,27 @@ lambda_parameters_rule(Parser *p)
     }
     arguments_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                _first_set_mask = 0xfULL;
+                break;
+            case 16:
+            case 35:
+                _first_set_mask = 0x10ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -15341,6 +16867,7 @@ lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -15371,6 +16898,7 @@ lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -15401,6 +16929,7 @@ lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // lambda_param_with_default+ lambda_star_etc?
         if (p->error_indicator) {
             p->level--;
@@ -15428,6 +16957,7 @@ lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // lambda_star_etc
         if (p->error_indicator) {
             p->level--;
@@ -15641,6 +17171,26 @@ lambda_star_etc_rule(Parser *p)
     }
     StarEtc* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x6ULL;
+                break;
+            case 35:
+                _first_set_mask = 0x8ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     if (p->call_invalid_rules) { // invalid_lambda_star_etc
         if (p->error_indicator) {
             p->level--;
@@ -15660,6 +17210,7 @@ lambda_star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_star_etc"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
         if (p->error_indicator) {
             p->level--;
@@ -15693,6 +17244,7 @@ lambda_star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // '*' ',' lambda_param_maybe_default+ lambda_kwds?
         if (p->error_indicator) {
             p->level--;
@@ -15726,6 +17278,7 @@ lambda_star_etc_rule(Parser *p)
         D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // lambda_kwds
         if (p->error_indicator) {
             p->level--;
@@ -16123,6 +17676,23 @@ fstring_middle_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 25:
+                goto _first_set_alt_0;
+            case 60:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // fstring_replacement_field
         if (p->error_indicator) {
             p->level--;
@@ -16142,6 +17712,10 @@ fstring_middle_rule(Parser *p)
         D(fprintf(stderr, "%*c%s fstring_middle[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_replacement_field"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // FSTRING_MIDDLE
         if (p->error_indicator) {
             p->level--;
@@ -16166,6 +17740,11 @@ fstring_middle_rule(Parser *p)
         D(fprintf(stderr, "%*c%s fstring_middle[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -16392,6 +17971,23 @@ fstring_format_spec_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 60:
+                goto _first_set_alt_0;
+            case 25:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // FSTRING_MIDDLE
         if (p->error_indicator) {
             p->level--;
@@ -16416,6 +18012,10 @@ fstring_format_spec_rule(Parser *p)
         D(fprintf(stderr, "%*c%s fstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_MIDDLE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // fstring_replacement_field
         if (p->error_indicator) {
             p->level--;
@@ -16435,6 +18035,11 @@ fstring_format_spec_rule(Parser *p)
         D(fprintf(stderr, "%*c%s fstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring_replacement_field"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -16600,6 +18205,23 @@ tstring_format_spec_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 63:
+                goto _first_set_alt_0;
+            case 25:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // TSTRING_MIDDLE
         if (p->error_indicator) {
             p->level--;
@@ -16624,6 +18246,10 @@ tstring_format_spec_rule(Parser *p)
         D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_MIDDLE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // tstring_format_spec_replacement_field
         if (p->error_indicator) {
             p->level--;
@@ -16643,6 +18269,11 @@ tstring_format_spec_rule(Parser *p)
         D(fprintf(stderr, "%*c%s tstring_format_spec[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_format_spec_replacement_field"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -16823,6 +18454,23 @@ tstring_middle_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 25:
+                goto _first_set_alt_0;
+            case 63:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // tstring_replacement_field
         if (p->error_indicator) {
             p->level--;
@@ -16842,6 +18490,10 @@ tstring_middle_rule(Parser *p)
         D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring_replacement_field"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // TSTRING_MIDDLE
         if (p->error_indicator) {
             p->level--;
@@ -16866,6 +18518,11 @@ tstring_middle_rule(Parser *p)
         D(fprintf(stderr, "%*c%s tstring_middle[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_MIDDLE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -16995,6 +18652,18 @@ strings_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 3:
+            case 59:
+                goto _first_set_alt_1;
+            case 62:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
     if (p->call_invalid_rules) { // invalid_string_tstring_concat
         if (p->error_indicator) {
             p->level--;
@@ -17014,6 +18683,10 @@ strings_rule(Parser *p)
         D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_string_tstring_concat"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ((fstring | string))+
         if (p->error_indicator) {
             p->level--;
@@ -17047,6 +18720,10 @@ strings_rule(Parser *p)
         D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string))+"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // tstring+
         if (p->error_indicator) {
             p->level--;
@@ -17080,6 +18757,11 @@ strings_rule(Parser *p)
         D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring+"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, strings_type, _res);
@@ -17544,6 +19226,43 @@ double_starred_kvpair_rule(Parser *p)
     }
     KeyValuePair* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 35:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '**' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -17571,6 +19290,10 @@ double_starred_kvpair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // kvpair
         if (p->error_indicator) {
             p->level--;
@@ -17590,6 +19313,11 @@ double_starred_kvpair_rule(Parser *p)
         D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -17705,6 +19433,23 @@ for_if_clause_rule(Parser *p)
     }
     comprehension_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 513:
+                goto _first_set_alt_0;
+            case 517:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'async' 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
         if (p->error_indicator) {
             p->level--;
@@ -17751,6 +19496,10 @@ for_if_clause_rule(Parser *p)
             return NULL;
         }
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
         if (p->error_indicator) {
             p->level--;
@@ -17794,6 +19543,9 @@ for_if_clause_rule(Parser *p)
             return NULL;
         }
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_for_if_clause
         if (p->error_indicator) {
             p->level--;
@@ -17813,6 +19565,9 @@ for_if_clause_rule(Parser *p)
         D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_if_clause"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_for_target
         if (p->error_indicator) {
             p->level--;
@@ -17832,6 +19587,11 @@ for_if_clause_rule(Parser *p)
         D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -18319,6 +20079,42 @@ args_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 35:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]
         if (p->error_indicator) {
             p->level--;
@@ -18355,6 +20151,7 @@ args_rule(Parser *p)
         D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs]"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // kwargs
         if (p->error_indicator) {
             p->level--;
@@ -18409,6 +20206,47 @@ kwargs_rule(Parser *p)
     }
     asdl_seq* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 35:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // ','.kwarg_or_starred+ [',' ','.kwarg_or_double_starred+]
         if (p->error_indicator) {
             p->level--;
@@ -18436,6 +20274,7 @@ kwargs_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_starred+ [',' ','.kwarg_or_double_starred+]"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // ','.kwarg_or_double_starred+
         if (p->error_indicator) {
             p->level--;
@@ -18588,6 +20427,17 @@ kwarg_or_starred_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_1;
+            case 16:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
     if (p->call_invalid_rules) { // invalid_kwarg
         if (p->error_indicator) {
             p->level--;
@@ -18607,6 +20457,10 @@ kwarg_or_starred_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // NAME '=' expression
         if (p->error_indicator) {
             p->level--;
@@ -18646,6 +20500,10 @@ kwarg_or_starred_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // starred_expression
         if (p->error_indicator) {
             p->level--;
@@ -18670,6 +20528,11 @@ kwarg_or_starred_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -18698,6 +20561,17 @@ kwarg_or_double_starred_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_1;
+            case 35:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
     if (p->call_invalid_rules) { // invalid_kwarg
         if (p->error_indicator) {
             p->level--;
@@ -18717,6 +20591,10 @@ kwarg_or_double_starred_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // NAME '=' expression
         if (p->error_indicator) {
             p->level--;
@@ -18756,6 +20634,10 @@ kwarg_or_double_starred_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '**' expression
         if (p->error_indicator) {
             p->level--;
@@ -18792,6 +20674,11 @@ kwarg_or_double_starred_rule(Parser *p)
         D(fprintf(stderr, "%*c%s kwarg_or_double_starred[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -18920,6 +20807,29 @@ star_target_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 25:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '*' (!'*' star_target)
         if (p->error_indicator) {
             p->level--;
@@ -18956,6 +20866,10 @@ star_target_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // target
         if (p->error_indicator) {
             p->level--;
@@ -18975,6 +20889,11 @@ star_target_rule(Parser *p)
         D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     _PyPegen_insert_memo(p, _mark, star_target_type, _res);
@@ -19276,6 +21195,49 @@ type_expressions_rule(Parser *p)
     }
     asdl_expr_seq* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x18ULL;
+                break;
+            case 35:
+                _first_set_mask = 0x20ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x47ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // ','.expression+ ',' '*' expression ',' '**' expression
         if (p->error_indicator) {
             p->level--;
@@ -19318,6 +21280,7 @@ type_expressions_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // ','.expression+ ',' '*' expression
         if (p->error_indicator) {
             p->level--;
@@ -19351,6 +21314,7 @@ type_expressions_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // ','.expression+ ',' '**' expression
         if (p->error_indicator) {
             p->level--;
@@ -19384,6 +21348,7 @@ type_expressions_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // '*' expression ',' '**' expression
         if (p->error_indicator) {
             p->level--;
@@ -19420,6 +21385,7 @@ type_expressions_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression ',' '**' expression"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // '*' expression
         if (p->error_indicator) {
             p->level--;
@@ -19447,6 +21413,7 @@ type_expressions_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // '**' expression
         if (p->error_indicator) {
             p->level--;
@@ -19474,6 +21441,7 @@ type_expressions_rule(Parser *p)
         D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // ','.expression+
         if (p->error_indicator) {
             p->level--;
@@ -19520,6 +21488,23 @@ func_type_comment_rule(Parser *p)
     }
     Token* _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 4:
+                goto _first_set_alt_0;
+            case 57:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
         if (p->error_indicator) {
             p->level--;
@@ -19549,6 +21534,9 @@ func_type_comment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
     if (p->call_invalid_rules) { // invalid_double_type_comments
         if (p->error_indicator) {
             p->level--;
@@ -19568,6 +21556,10 @@ func_type_comment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_double_type_comments"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // TYPE_COMMENT
         if (p->error_indicator) {
             p->level--;
@@ -19587,6 +21579,11 @@ func_type_comment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -19675,6 +21672,8 @@ _loop1_2_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement"));
         asdl_stmt_seq* statement_var;
         while (
+            _PyPegen_next_token_in(p, 0x481200008201c28eULL, 0x69c0fffffULL)  // first set
+            &&
             (statement_var = statement_rule(p))  // statement
         )
         {
@@ -19835,6 +21834,25 @@ _tmp_5_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 500:
+                goto _first_set_alt_0;
+            case 501:
+                goto _first_set_alt_1;
+            case 1:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'import'
         if (p->error_indicator) {
             p->level--;
@@ -19854,6 +21872,10 @@ _tmp_5_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_5[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'from'
         if (p->error_indicator) {
             p->level--;
@@ -19873,6 +21895,10 @@ _tmp_5_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_5[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // "lazy"
         if (p->error_indicator) {
             p->level--;
@@ -19892,6 +21918,11 @@ _tmp_5_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_5[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"lazy\""));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -19911,6 +21942,25 @@ _tmp_6_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 512:
+                goto _first_set_alt_0;
+            case 49:
+                goto _first_set_alt_1;
+            case 513:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'def'
         if (p->error_indicator) {
             p->level--;
@@ -19930,6 +21980,10 @@ _tmp_6_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '@'
         if (p->error_indicator) {
             p->level--;
@@ -19949,6 +22003,10 @@ _tmp_6_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // 'async'
         if (p->error_indicator) {
             p->level--;
@@ -19968,6 +22026,11 @@ _tmp_6_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_6[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -19987,6 +22050,23 @@ _tmp_7_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 515:
+                goto _first_set_alt_0;
+            case 49:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'class'
         if (p->error_indicator) {
             p->level--;
@@ -20006,6 +22086,10 @@ _tmp_7_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '@'
         if (p->error_indicator) {
             p->level--;
@@ -20025,6 +22109,11 @@ _tmp_7_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_7[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -20044,6 +22133,23 @@ _tmp_8_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 516:
+                goto _first_set_alt_0;
+            case 513:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'with'
         if (p->error_indicator) {
             p->level--;
@@ -20063,6 +22169,10 @@ _tmp_8_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'async'
         if (p->error_indicator) {
             p->level--;
@@ -20082,6 +22192,11 @@ _tmp_8_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_8[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -20101,6 +22216,23 @@ _tmp_9_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 517:
+                goto _first_set_alt_0;
+            case 513:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'for'
         if (p->error_indicator) {
             p->level--;
@@ -20120,6 +22252,10 @@ _tmp_9_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'async'
         if (p->error_indicator) {
             p->level--;
@@ -20139,6 +22275,11 @@ _tmp_9_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_9[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'async'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -20204,6 +22345,36 @@ _tmp_11_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+            case 2:
+            case 3:
+            case 9:
+            case 25:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 7:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // '(' single_target ')'
         if (p->error_indicator) {
             p->level--;
@@ -20234,6 +22405,7 @@ _tmp_11_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_11[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // attribute_or_subscript_target
         if (p->error_indicator) {
             p->level--;
@@ -20283,6 +22455,8 @@ _loop1_12_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
         void *_tmp_178_var;
         while (
+            _PyPegen_next_token_in(p, 0x481000000201028eULL, 0x1c000000ULL)  // first set
+            &&
             (_tmp_178_var = _tmp_178_rule(p))  // star_targets '='
         )
         {
@@ -20443,6 +22617,23 @@ _tmp_15_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 13:
+                goto _first_set_alt_0;
+            case 4:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ';'
         if (p->error_indicator) {
             p->level--;
@@ -20462,6 +22653,10 @@ _tmp_15_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -20481,6 +22676,11 @@ _tmp_15_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -20557,6 +22757,8 @@ _loop0_17_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
         void *_tmp_179_var;
         while (
+            _PyPegen_next_token_in(p, 0x10000000800000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_179_var = _tmp_179_rule(p))  // '.' | '...'
         )
         {
@@ -20615,6 +22817,8 @@ _loop1_18_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
         void *_tmp_179_var;
         while (
+            _PyPegen_next_token_in(p, 0x10000000800000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_179_var = _tmp_179_rule(p))  // '.' | '...'
         )
         {
@@ -20940,6 +23144,8 @@ _loop1_24_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)"));
         void *_tmp_180_var;
         while (
+            _PyPegen_next_token_in(p, 0x2000000000000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_180_var = _tmp_180_rule(p))  // '@' named_expression NEWLINE
         )
         {
@@ -21098,6 +23304,8 @@ _loop0_27_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
         arg_ty param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_no_default_var = param_no_default_rule(p))  // param_no_default
         )
         {
@@ -21156,6 +23364,8 @@ _loop0_28_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
         NameDefaultPair* param_with_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_with_default_var = param_with_default_rule(p))  // param_with_default
         )
         {
@@ -21214,6 +23424,8 @@ _loop1_29_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
         arg_ty param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_no_default_var = param_no_default_rule(p))  // param_no_default
         )
         {
@@ -21277,6 +23489,8 @@ _loop1_30_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
         NameDefaultPair* param_with_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_with_default_var = param_with_default_rule(p))  // param_with_default
         )
         {
@@ -21340,6 +23554,8 @@ _loop0_31_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
         NameDefaultPair* param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default
         )
         {
@@ -21398,6 +23614,8 @@ _loop1_32_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
         NameDefaultPair* param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default
         )
         {
@@ -21558,6 +23776,25 @@ _tmp_35_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 12:
+                goto _first_set_alt_0;
+            case 8:
+                goto _first_set_alt_1;
+            case 11:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -21577,6 +23814,10 @@ _tmp_35_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -21596,6 +23837,10 @@ _tmp_35_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -21615,6 +23860,11 @@ _tmp_35_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -21645,6 +23895,8 @@ _loop1_36_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
         excepthandler_ty except_block_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x1000000ULL)  // first set
+            &&
             (except_block_var = except_block_rule(p))  // except_block
         )
         {
@@ -21708,6 +23960,8 @@ _loop1_37_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block"));
         excepthandler_ty except_star_block_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x1000000ULL)  // first set
+            &&
             (except_star_block_var = except_star_block_rule(p))  // except_star_block
         )
         {
@@ -21771,6 +24025,8 @@ _loop1_38_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "case_block"));
         match_case_ty case_block_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (case_block_var = case_block_rule(p))  // case_block
         )
         {
@@ -21931,6 +24187,23 @@ _tmp_41_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 14:
+                goto _first_set_alt_0;
+            case 15:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '+'
         if (p->error_indicator) {
             p->level--;
@@ -21950,6 +24223,10 @@ _tmp_41_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_41[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '-'
         if (p->error_indicator) {
             p->level--;
@@ -21969,6 +24246,11 @@ _tmp_41_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_41[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -21988,6 +24270,25 @@ _tmp_42_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 3:
+                goto _first_set_alt_0;
+            case 59:
+                goto _first_set_alt_1;
+            case 62:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // STRING
         if (p->error_indicator) {
             p->level--;
@@ -22007,6 +24308,10 @@ _tmp_42_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_42[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // FSTRING_START
         if (p->error_indicator) {
             p->level--;
@@ -22026,6 +24331,10 @@ _tmp_42_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_42[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "FSTRING_START"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // TSTRING_START
         if (p->error_indicator) {
             p->level--;
@@ -22045,6 +24354,11 @@ _tmp_42_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_42[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TSTRING_START"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -22064,6 +24378,25 @@ _tmp_43_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 23:
+                goto _first_set_alt_0;
+            case 7:
+                goto _first_set_alt_1;
+            case 22:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '.'
         if (p->error_indicator) {
             p->level--;
@@ -22083,6 +24416,10 @@ _tmp_43_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '('
         if (p->error_indicator) {
             p->level--;
@@ -22102,6 +24439,10 @@ _tmp_43_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '='
         if (p->error_indicator) {
             p->level--;
@@ -22121,6 +24462,11 @@ _tmp_43_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_43[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -22356,6 +24702,31 @@ _tmp_48_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 14:
+            case 15:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                goto _first_set_alt_0;
+            case 1:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // literal_expr
         if (p->error_indicator) {
             p->level--;
@@ -22375,6 +24746,10 @@ _tmp_48_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_48[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "literal_expr"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // attr
         if (p->error_indicator) {
             p->level--;
@@ -22394,6 +24769,11 @@ _tmp_48_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_48[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "attr"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -22748,6 +25128,8 @@ _loop1_55_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"));
         void *_tmp_16_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_16_var = _tmp_16_rule(p))  // ',' expression
         )
         {
@@ -22811,6 +25193,8 @@ _loop1_56_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)"));
         void *_tmp_181_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_181_var = _tmp_181_rule(p))  // ',' star_expression
         )
         {
@@ -22982,6 +25366,8 @@ _loop1_59_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)"));
         void *_tmp_182_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x20000000ULL)  // first set
+            &&
             (_tmp_182_var = _tmp_182_rule(p))  // 'or' conjunction
         )
         {
@@ -23045,6 +25431,8 @@ _loop1_60_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)"));
         void *_tmp_183_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x40000000ULL)  // first set
+            &&
             (_tmp_183_var = _tmp_183_rule(p))  // 'and' inversion
         )
         {
@@ -23108,6 +25496,8 @@ _loop1_61_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair"));
         CmpopExprPair* compare_op_bitwise_or_pair_var;
         while (
+            _PyPegen_next_token_in(p, 0x78300000ULL, 0x180800000ULL)  // first set
+            &&
             (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p))  // compare_op_bitwise_or_pair
         )
         {
@@ -23357,6 +25747,27 @@ _tmp_66_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 9:
+            case 25:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 7:
+                _first_set_mask = 0x7ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // genexp
         if (p->error_indicator) {
             p->level--;
@@ -23376,6 +25787,7 @@ _tmp_66_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // tuple
         if (p->error_indicator) {
             p->level--;
@@ -23395,6 +25807,7 @@ _tmp_66_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_66[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // group
         if (p->error_indicator) {
             p->level--;
@@ -23433,6 +25846,27 @@ _tmp_67_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+            case 25:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 9:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // listcomp
         if (p->error_indicator) {
             p->level--;
@@ -23452,6 +25886,7 @@ _tmp_67_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_67[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // list
         if (p->error_indicator) {
             p->level--;
@@ -23490,6 +25925,27 @@ _tmp_68_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+            case 9:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 25:
+                _first_set_mask = 0xfULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // dictcomp
         if (p->error_indicator) {
             p->level--;
@@ -23509,6 +25965,7 @@ _tmp_68_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // setcomp
         if (p->error_indicator) {
             p->level--;
@@ -23528,6 +25985,7 @@ _tmp_68_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // dict
         if (p->error_indicator) {
             p->level--;
@@ -23547,6 +26005,7 @@ _tmp_68_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_68[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // set
         if (p->error_indicator) {
             p->level--;
@@ -23585,6 +26044,43 @@ _tmp_69_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 506:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // yield_expr
         if (p->error_indicator) {
             p->level--;
@@ -23604,6 +26100,10 @@ _tmp_69_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // named_expression
         if (p->error_indicator) {
             p->level--;
@@ -23623,6 +26123,11 @@ _tmp_69_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -23653,6 +26158,8 @@ _loop0_70_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
         arg_ty lambda_param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
         )
         {
@@ -23711,6 +26218,8 @@ _loop0_71_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
         NameDefaultPair* lambda_param_with_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
         )
         {
@@ -23769,6 +26278,8 @@ _loop1_72_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
         arg_ty lambda_param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
         )
         {
@@ -23832,6 +26343,8 @@ _loop1_73_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
         NameDefaultPair* lambda_param_with_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
         )
         {
@@ -23895,6 +26408,8 @@ _loop0_74_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
         NameDefaultPair* lambda_param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default
         )
         {
@@ -23953,6 +26468,8 @@ _loop1_75_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
         NameDefaultPair* lambda_param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default
         )
         {
@@ -24016,6 +26533,8 @@ _loop0_76_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec"));
         expr_ty fstring_format_spec_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000000002000000ULL, 0x0ULL)  // first set
+            &&
             (fstring_format_spec_var = fstring_format_spec_rule(p))  // fstring_format_spec
         )
         {
@@ -24074,6 +26593,8 @@ _loop0_77_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_middle"));
         expr_ty fstring_middle_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000000002000000ULL, 0x0ULL)  // first set
+            &&
             (fstring_middle_var = fstring_middle_rule(p))  // fstring_middle
         )
         {
@@ -24132,6 +26653,8 @@ _loop0_78_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_format_spec"));
         expr_ty tstring_format_spec_var;
         while (
+            _PyPegen_next_token_in(p, 0x8000000002000000ULL, 0x0ULL)  // first set
+            &&
             (tstring_format_spec_var = tstring_format_spec_rule(p))  // tstring_format_spec
         )
         {
@@ -24190,6 +26713,8 @@ _loop0_79_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring_middle"));
         expr_ty tstring_middle_var;
         while (
+            _PyPegen_next_token_in(p, 0x8000000002000000ULL, 0x0ULL)  // first set
+            &&
             (tstring_middle_var = tstring_middle_rule(p))  // tstring_middle
         )
         {
@@ -24248,6 +26773,8 @@ _loop1_80_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)"));
         void *_tmp_185_var;
         while (
+            _PyPegen_next_token_in(p, 0x800000000000008ULL, 0x0ULL)  // first set
+            &&
             (_tmp_185_var = _tmp_185_rule(p))  // fstring | string
         )
         {
@@ -24311,6 +26838,8 @@ _loop1_81_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring"));
         expr_ty tstring_var;
         while (
+            _PyPegen_next_token_in(p, 0x4000000000000000ULL, 0x0ULL)  // first set
+            &&
             (tstring_var = tstring_rule(p))  // tstring
         )
         {
@@ -24639,6 +27168,8 @@ _loop1_87_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause"));
         comprehension_ty for_if_clause_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x22000ULL)  // first set
+            &&
             (for_if_clause_var = for_if_clause_rule(p))  // for_if_clause
         )
         {
@@ -24702,6 +27233,8 @@ _loop0_88_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
         void *_tmp_186_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x4000ULL)  // first set
+            &&
             (_tmp_186_var = _tmp_186_rule(p))  // 'if' disjunction
         )
         {
@@ -24749,6 +27282,48 @@ _tmp_89_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3ULL;
+                break;
+            case 16:
+                _first_set_mask = 0x4ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // assignment_expression
         if (p->error_indicator) {
             p->level--;
@@ -24768,6 +27343,7 @@ _tmp_89_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // expression !':='
         if (p->error_indicator) {
             p->level--;
@@ -24789,6 +27365,7 @@ _tmp_89_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_89[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // starred_expression
         if (p->error_indicator) {
             p->level--;
@@ -25255,6 +27832,8 @@ _loop0_98_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
         void *_tmp_188_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_188_var = _tmp_188_rule(p))  // ',' star_target
         )
         {
@@ -25342,6 +27921,25 @@ _tmp_100_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+                goto _first_set_alt_0;
+            case 9:
+                goto _first_set_alt_1;
+            case 23:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '('
         if (p->error_indicator) {
             p->level--;
@@ -25361,6 +27959,10 @@ _tmp_100_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '['
         if (p->error_indicator) {
             p->level--;
@@ -25380,6 +27982,10 @@ _tmp_100_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '.'
         if (p->error_indicator) {
             p->level--;
@@ -25399,6 +28005,11 @@ _tmp_100_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -25721,6 +28332,23 @@ _tmp_179_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 23:
+                goto _first_set_alt_0;
+            case 52:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '.'
         if (p->error_indicator) {
             p->level--;
@@ -25740,6 +28368,10 @@ _tmp_179_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '...'
         if (p->error_indicator) {
             p->level--;
@@ -25759,6 +28391,11 @@ _tmp_179_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_179[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -25965,6 +28602,44 @@ _tmp_184_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 11:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_0;
+            case 16:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // slice
         if (p->error_indicator) {
             p->level--;
@@ -25984,6 +28659,10 @@ _tmp_184_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // starred_expression
         if (p->error_indicator) {
             p->level--;
@@ -26003,6 +28682,11 @@ _tmp_184_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_184[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -26022,6 +28706,23 @@ _tmp_185_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 59:
+                goto _first_set_alt_0;
+            case 3:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // fstring
         if (p->error_indicator) {
             p->level--;
@@ -26041,6 +28742,10 @@ _tmp_185_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_185[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // string
         if (p->error_indicator) {
             p->level--;
@@ -26060,6 +28765,11 @@ _tmp_185_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_185[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -26125,6 +28835,43 @@ _tmp_187_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // starred_expression
         if (p->error_indicator) {
             p->level--;
@@ -26144,6 +28891,10 @@ _tmp_187_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_187[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // (assignment_expression | expression !':=') !'='
         if (p->error_indicator) {
             p->level--;
@@ -26165,6 +28916,11 @@ _tmp_187_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_187[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -26230,6 +28986,45 @@ _tmp_200_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // assignment_expression
         if (p->error_indicator) {
             p->level--;
@@ -26249,6 +29044,7 @@ _tmp_200_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_200[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // expression !':='
         if (p->error_indicator) {
             p->level--;
diff --git a/Parser/parser_invalid.c b/Parser/parser_invalid.c
index b306b9869a90dd..59e2a48e6000c3 100644
--- a/Parser/parser_invalid.c
+++ b/Parser/parser_invalid.c
@@ -563,6 +563,49 @@ invalid_arguments_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+            case 35:
+                _first_set_mask = 0x79ULL;
+                break;
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x7bULL;
+                break;
+            case 1:
+                _first_set_mask = 0x7fULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // ((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+
         if (p->error_indicator) {
             p->level--;
@@ -593,6 +636,7 @@ invalid_arguments_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) ',' ','.(starred_expression !'=')+"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // expression for_if_clauses ',' [args | expression for_if_clauses]
         if (p->error_indicator) {
             p->level--;
@@ -627,6 +671,7 @@ invalid_arguments_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // NAME '=' expression for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -660,6 +705,7 @@ invalid_arguments_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // [(args ',')] NAME '=' &(',' | ')')
         if (p->error_indicator) {
             p->level--;
@@ -693,6 +739,7 @@ invalid_arguments_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(args ',')] NAME '=' &(',' | ')')"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // args for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -720,6 +767,7 @@ invalid_arguments_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args for_if_clauses"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // args ',' expression for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -753,6 +801,7 @@ invalid_arguments_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' expression for_if_clauses"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // args ',' args
         if (p->error_indicator) {
             p->level--;
@@ -808,6 +857,54 @@ invalid_kwarg_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 527:
+                _first_set_mask = 0x11ULL;
+                break;
+            case 528:
+                _first_set_mask = 0x12ULL;
+                break;
+            case 526:
+                _first_set_mask = 0x14ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x18ULL;
+                break;
+            case 35:
+                _first_set_mask = 0x20ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // 'True' '='
         if (p->error_indicator) {
             p->level--;
@@ -835,6 +932,7 @@ invalid_kwarg_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True' '='"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // 'False' '='
         if (p->error_indicator) {
             p->level--;
@@ -862,6 +960,7 @@ invalid_kwarg_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False' '='"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // 'None' '='
         if (p->error_indicator) {
             p->level--;
@@ -889,6 +988,7 @@ invalid_kwarg_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None' '='"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // NAME '=' expression for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -922,6 +1022,7 @@ invalid_kwarg_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression for_if_clauses"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // !(NAME '=') expression '='
         if (p->error_indicator) {
             p->level--;
@@ -951,6 +1052,7 @@ invalid_kwarg_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // '**' expression '=' expression
         if (p->error_indicator) {
             p->level--;
@@ -1021,6 +1123,37 @@ expression_without_invalid_rule(Parser *p)
     UNUSED(_start_lineno); // Only used by EXTRA macro
     int _start_col_offset = p->tokens[_mark]->col_offset;
     UNUSED(_start_col_offset); // Only used by EXTRA macro
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+                _first_set_mask = 0x3ULL;
+                break;
+            case 534:
+                _first_set_mask = 0x4ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // disjunction 'if' disjunction 'else' expression
         if (p->error_indicator) {
             p->call_invalid_rules = _prev_call_invalid;
@@ -1069,6 +1202,7 @@ expression_without_invalid_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // disjunction
         if (p->error_indicator) {
             p->call_invalid_rules = _prev_call_invalid;
@@ -1089,6 +1223,7 @@ expression_without_invalid_rule(Parser *p)
         D(fprintf(stderr, "%*c%s expression_without_invalid[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // lambdef
         if (p->error_indicator) {
             p->call_invalid_rules = _prev_call_invalid;
@@ -1177,6 +1312,23 @@ invalid_type_param_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 35:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '*' NAME ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -1210,6 +1362,10 @@ invalid_type_param_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_type_param[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' NAME ':' expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '**' NAME ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -1243,6 +1399,11 @@ invalid_type_param_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_type_param[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' NAME ':' expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -1271,6 +1432,49 @@ invalid_expression_rule(Parser *p)
     int _mark = p->mark;
     expr_ty _prefix_12_result = NULL;
     int _prefix_12_end = 0, _prefix_12_valid = 0;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+            case 2:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+                _first_set_mask = 0xeULL;
+                break;
+            case 3:
+                _first_set_mask = 0xfULL;
+                break;
+            case 504:
+            case 508:
+            case 509:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 534:
+                _first_set_mask = 0x60ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // STRING ((!STRING expression_without_invalid))+ STRING
         if (p->error_indicator) {
             p->level--;
@@ -1301,6 +1505,7 @@ invalid_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING ((!STRING expression_without_invalid))+ STRING"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid
         if (p->error_indicator) {
             p->level--;
@@ -1330,6 +1535,7 @@ invalid_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // disjunction 'if' disjunction !('else' | ':')
         if (p->error_indicator) {
             p->level--;
@@ -1362,6 +1568,7 @@ invalid_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction !('else' | ':')"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // disjunction 'if' disjunction 'else' !expression
         if (p->error_indicator) {
             p->level--;
@@ -1397,6 +1604,7 @@ invalid_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' !expression"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // (pass_stmt | break_stmt | continue_stmt) 'if' disjunction 'else' simple_stmt
         if (p->error_indicator) {
             p->level--;
@@ -1433,6 +1641,7 @@ invalid_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(pass_stmt | break_stmt | continue_stmt) 'if' disjunction 'else' simple_stmt"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // 'lambda' lambda_params? ':' &FSTRING_MIDDLE
         if (p->error_indicator) {
             p->level--;
@@ -1466,6 +1675,7 @@ invalid_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' &FSTRING_MIDDLE"));
     }
+    if (_first_set_mask & 0x40ULL)
     { // 'lambda' lambda_params? ':' &TSTRING_MIDDLE
         if (p->error_indicator) {
             p->level--;
@@ -1620,6 +1830,47 @@ invalid_named_expression_rule(Parser *p)
         return _res;
     }
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 504:
+            case 508:
+            case 509:
+            case 531:
+            case 534:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+            case 533:
+                _first_set_mask = 0x5ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x7ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // expression ':=' expression
         if (p->error_indicator) {
             p->level--;
@@ -1650,6 +1901,7 @@ invalid_named_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // NAME '=' bitwise_or !('=' | ':=')
         if (p->error_indicator) {
             p->level--;
@@ -1682,6 +1934,7 @@ invalid_named_expression_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' bitwise_or !('=' | ':=')"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')
         if (p->error_indicator) {
             p->level--;
@@ -1742,6 +1995,53 @@ invalid_assignment_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 506:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 14:
+            case 15:
+            case 31:
+            case 504:
+            case 508:
+            case 509:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x2eULL;
+                break;
+            case 16:
+                _first_set_mask = 0x3aULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 25:
+            case 52:
+            case 59:
+            case 62:
+            case 526:
+            case 527:
+            case 528:
+                _first_set_mask = 0x3eULL;
+                break;
+            case 7:
+            case 9:
+                _first_set_mask = 0x3fULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // invalid_ann_assign_target ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -1772,6 +2072,7 @@ invalid_assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_ann_assign_target ':' expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // star_named_expression ',' star_named_expressions* ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -1808,6 +2109,7 @@ invalid_assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // expression ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -1838,6 +2140,7 @@ invalid_assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // ((star_targets '='))* star_expressions '='
         if (p->error_indicator) {
             p->level--;
@@ -1868,6 +2171,7 @@ invalid_assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* star_expressions '='"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // ((star_targets '='))* yield_expr '='
         if (p->error_indicator) {
             p->level--;
@@ -1898,6 +2202,7 @@ invalid_assignment_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))* yield_expr '='"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // star_expressions augassign annotated_rhs
         if (p->error_indicator) {
             p->level--;
@@ -1947,6 +2252,26 @@ invalid_ann_assign_target_rule(Parser *p)
     }
     expr_ty _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 9:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 7:
+                _first_set_mask = 0x6ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // list
         if (p->error_indicator) {
             p->level--;
@@ -1966,6 +2291,7 @@ invalid_ann_assign_target_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // tuple
         if (p->error_indicator) {
             p->level--;
@@ -1985,6 +2311,7 @@ invalid_ann_assign_target_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // '(' invalid_ann_assign_target ')'
         if (p->error_indicator) {
             p->level--;
@@ -2372,6 +2699,29 @@ invalid_comprehension_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 25:
+                _first_set_mask = 0xcULL;
+                break;
+            case 9:
+                _first_set_mask = 0xdULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // '[' '**' expression for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -2405,6 +2755,7 @@ invalid_comprehension_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' '**' expression for_if_clauses"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // '(' '**' expression for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -2438,6 +2789,7 @@ invalid_comprehension_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' '**' expression for_if_clauses"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -2474,6 +2826,7 @@ invalid_comprehension_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // ('[' | '{') star_named_expression ',' for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -2532,6 +2885,29 @@ invalid_parameters_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+                _first_set_mask = 0x9ULL;
+                break;
+            case 16:
+                _first_set_mask = 0x11ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3fULL;
+                break;
+            default:
+                _first_set_mask = 0x1ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // "/" ','
         if (p->error_indicator) {
             p->level--;
@@ -2559,6 +2935,7 @@ invalid_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // (slash_no_default | slash_with_default) param_maybe_default* '/'
         if (p->error_indicator) {
             p->level--;
@@ -2589,6 +2966,7 @@ invalid_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(slash_no_default | slash_with_default) param_maybe_default* '/'"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // slash_no_default? param_no_default* invalid_parameters_helper param_no_default
         if (p->error_indicator) {
             p->level--;
@@ -2623,6 +3001,7 @@ invalid_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_no_default? param_no_default* invalid_parameters_helper param_no_default"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // param_no_default* '(' param_no_default+ ','? ')'
         if (p->error_indicator) {
             p->level--;
@@ -2660,6 +3039,7 @@ invalid_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* '(' param_no_default+ ','? ')'"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'
         if (p->error_indicator) {
             p->level--;
@@ -2700,6 +3080,7 @@ invalid_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/'"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // param_maybe_default+ '/' '*'
         if (p->error_indicator) {
             p->level--;
@@ -3123,6 +3504,29 @@ invalid_lambda_parameters_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 7:
+                _first_set_mask = 0x9ULL;
+                break;
+            case 16:
+                _first_set_mask = 0x11ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3fULL;
+                break;
+            default:
+                _first_set_mask = 0x1ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // "/" ','
         if (p->error_indicator) {
             p->level--;
@@ -3150,6 +3554,7 @@ invalid_lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "\"/\" ','"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'
         if (p->error_indicator) {
             p->level--;
@@ -3180,6 +3585,7 @@ invalid_lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/'"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default
         if (p->error_indicator) {
             p->level--;
@@ -3214,6 +3620,7 @@ invalid_lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // lambda_param_no_default* '(' ','.lambda_param+ ','? ')'
         if (p->error_indicator) {
             p->level--;
@@ -3251,6 +3658,7 @@ invalid_lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* '(' ','.lambda_param+ ','? ')'"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'
         if (p->error_indicator) {
             p->level--;
@@ -3291,6 +3699,7 @@ invalid_lambda_parameters_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "[(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/'"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // lambda_param_maybe_default+ '/' '*'
         if (p->error_indicator) {
             p->level--;
@@ -4167,6 +4576,23 @@ invalid_import_from_targets_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_0;
+            case 4:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // import_from_as_names ',' NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -4197,6 +4623,10 @@ invalid_import_from_targets_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_names ',' NEWLINE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -4221,6 +4651,11 @@ invalid_import_from_targets_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_import_from_targets[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -6361,6 +6796,49 @@ invalid_double_starred_kvpairs_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 35:
+                _first_set_mask = 0x3ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x7ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // invalid_kvpair_unpacking ','?
         if (p->error_indicator) {
             p->level--;
@@ -6384,6 +6862,7 @@ invalid_double_starred_kvpairs_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kvpair_unpacking ','?"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // ','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)
         if (p->error_indicator) {
             p->level--;
@@ -6409,6 +6888,7 @@ invalid_double_starred_kvpairs_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ',' (invalid_kvpair | invalid_kvpair_unpacking)"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // expression ':' &('}' | ',')
         if (p->error_indicator) {
             p->level--;
@@ -6464,6 +6944,49 @@ invalid_kvpair_unpacking_rule(Parser *p)
     int _mark = p->mark;
     expr_ty _prefix_14_result = NULL;
     int _prefix_14_end = 0, _prefix_14_valid = 0;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 35:
+                _first_set_mask = 0x5ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x18ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // '**' if_expression
         if (p->error_indicator) {
             p->level--;
@@ -6491,6 +7014,7 @@ invalid_kvpair_unpacking_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' if_expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // '*' bitwise_or ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -6524,6 +7048,7 @@ invalid_kvpair_unpacking_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or ':' expression"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // '**' bitwise_or ':' expression
         if (p->error_indicator) {
             p->level--;
@@ -6557,6 +7082,7 @@ invalid_kvpair_unpacking_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or ':' expression"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // expression ':' '*' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -6590,6 +7116,7 @@ invalid_kvpair_unpacking_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_kvpair_unpacking[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' '*' bitwise_or"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // expression ':' '**' bitwise_or
         if (p->error_indicator) {
             p->level--;
@@ -7863,6 +8390,24 @@ invalid_string_tstring_concat_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 3:
+            case 59:
+                goto _first_set_alt_0;
+            case 62:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ((fstring | string))+ tstring
         if (p->error_indicator) {
             p->level--;
@@ -7890,6 +8435,10 @@ invalid_string_tstring_concat_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_string_tstring_concat[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((fstring | string))+ tstring"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // tstring+ (fstring | string)
         if (p->error_indicator) {
             p->level--;
@@ -7917,6 +8466,11 @@ invalid_string_tstring_concat_rule(Parser *p)
         D(fprintf(stderr, "%*c%s invalid_string_tstring_concat[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tstring+ (fstring | string)"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -8232,6 +8786,47 @@ _tmp_106_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 35:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 16:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // (','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)
         if (p->error_indicator) {
             p->level--;
@@ -8251,6 +8846,7 @@ _tmp_106_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_106[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(','.(starred_expression | (assignment_expression | expression !':=') !'=')+ ',' kwargs)"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // kwargs
         if (p->error_indicator) {
             p->level--;
@@ -8397,6 +8993,47 @@ _tmp_109_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+            case 35:
+                _first_set_mask = 0x1ULL;
+                break;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // args
         if (p->error_indicator) {
             p->level--;
@@ -8416,6 +9053,7 @@ _tmp_109_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_109[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // expression for_if_clauses
         if (p->error_indicator) {
             p->level--;
@@ -8498,6 +9136,23 @@ _tmp_111_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 12:
+                goto _first_set_alt_0;
+            case 8:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -8517,6 +9172,10 @@ _tmp_111_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -8536,6 +9195,11 @@ _tmp_111_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_111[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -8607,6 +9271,8 @@ _loop1_113_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(!STRING expression_without_invalid)"));
         void *_tmp_191_var;
         while (
+            _PyPegen_next_token_in(p, 0x481000008200c28eULL, 0x69c000000ULL)  // first set
+            &&
             (_tmp_191_var = _tmp_191_rule(p))  // !STRING expression_without_invalid
         )
         {
@@ -8719,6 +9385,23 @@ _tmp_115_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 522:
+                goto _first_set_alt_0;
+            case 11:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'else'
         if (p->error_indicator) {
             p->level--;
@@ -8738,6 +9421,10 @@ _tmp_115_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -8757,6 +9444,11 @@ _tmp_115_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_115[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -8776,6 +9468,25 @@ _tmp_116_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 504:
+                goto _first_set_alt_0;
+            case 508:
+                goto _first_set_alt_1;
+            case 509:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // pass_stmt
         if (p->error_indicator) {
             p->level--;
@@ -8795,6 +9506,10 @@ _tmp_116_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "pass_stmt"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // break_stmt
         if (p->error_indicator) {
             p->level--;
@@ -8814,6 +9529,10 @@ _tmp_116_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "break_stmt"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // continue_stmt
         if (p->error_indicator) {
             p->level--;
@@ -8833,6 +9552,11 @@ _tmp_116_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_116[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "continue_stmt"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -8852,6 +9576,23 @@ _tmp_117_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 22:
+                goto _first_set_alt_0;
+            case 53:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '='
         if (p->error_indicator) {
             p->level--;
@@ -8871,6 +9612,10 @@ _tmp_117_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ':='
         if (p->error_indicator) {
             p->level--;
@@ -8890,6 +9635,11 @@ _tmp_117_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_117[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -8909,6 +9659,38 @@ _tmp_118_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 25:
+                _first_set_mask = 0x4ULL;
+                break;
+            case 9:
+                _first_set_mask = 0x5ULL;
+                break;
+            case 7:
+                _first_set_mask = 0x6ULL;
+                break;
+            case 527:
+                _first_set_mask = 0x8ULL;
+                break;
+            case 526:
+                _first_set_mask = 0x10ULL;
+                break;
+            case 528:
+                _first_set_mask = 0x20ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // list
         if (p->error_indicator) {
             p->level--;
@@ -8928,6 +9710,7 @@ _tmp_118_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // tuple
         if (p->error_indicator) {
             p->level--;
@@ -8947,6 +9730,7 @@ _tmp_118_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
     }
+    if (_first_set_mask & 0x4ULL)
     { // genexp
         if (p->error_indicator) {
             p->level--;
@@ -8966,6 +9750,7 @@ _tmp_118_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));
     }
+    if (_first_set_mask & 0x8ULL)
     { // 'True'
         if (p->error_indicator) {
             p->level--;
@@ -8985,6 +9770,7 @@ _tmp_118_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
     }
+    if (_first_set_mask & 0x10ULL)
     { // 'None'
         if (p->error_indicator) {
             p->level--;
@@ -9004,6 +9790,7 @@ _tmp_118_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_118[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
     }
+    if (_first_set_mask & 0x20ULL)
     { // 'False'
         if (p->error_indicator) {
             p->level--;
@@ -9053,6 +9840,8 @@ _loop0_119_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions"));
         asdl_expr_seq* star_named_expressions_var;
         while (
+            _PyPegen_next_token_in(p, 0x481000008201c28eULL, 0x69c000310ULL)  // first set
+            &&
             (star_named_expressions_var = star_named_expressions_rule(p))  // star_named_expressions
         )
         {
@@ -9111,6 +9900,8 @@ _loop0_120_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
         void *_tmp_192_var;
         while (
+            _PyPegen_next_token_in(p, 0x481000000201028eULL, 0x1c000000ULL)  // first set
+            &&
             (_tmp_192_var = _tmp_192_rule(p))  // star_targets '='
         )
         {
@@ -9158,6 +9949,23 @@ _tmp_121_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 9:
+                goto _first_set_alt_0;
+            case 25:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '['
         if (p->error_indicator) {
             p->level--;
@@ -9177,6 +9985,10 @@ _tmp_121_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '{'
         if (p->error_indicator) {
             p->level--;
@@ -9196,6 +10008,11 @@ _tmp_121_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9283,6 +10100,8 @@ _loop0_123_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
         NameDefaultPair* param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default
         )
         {
@@ -9341,6 +10160,8 @@ _loop0_124_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
         arg_ty param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_no_default_var = param_no_default_rule(p))  // param_no_default
         )
         {
@@ -9399,6 +10220,8 @@ _loop1_125_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
         arg_ty param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_no_default_var = param_no_default_rule(p))  // param_no_default
         )
         {
@@ -9451,6 +10274,23 @@ _tmp_126_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 12:
+                goto _first_set_alt_0;
+            case 1:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -9470,6 +10310,10 @@ _tmp_126_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // param_no_default
         if (p->error_indicator) {
             p->level--;
@@ -9489,6 +10333,11 @@ _tmp_126_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_126[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9519,6 +10368,8 @@ _loop1_127_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
         NameDefaultPair* param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default
         )
         {
@@ -9571,6 +10422,23 @@ _tmp_128_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 8:
+                goto _first_set_alt_0;
+            case 12:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -9590,6 +10458,10 @@ _tmp_128_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -9609,6 +10481,11 @@ _tmp_128_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_128[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9628,6 +10505,23 @@ _tmp_129_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 8:
+                goto _first_set_alt_0;
+            case 12:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -9647,6 +10541,10 @@ _tmp_129_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ',' (')' | '**')
         if (p->error_indicator) {
             p->level--;
@@ -9669,6 +10567,11 @@ _tmp_129_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9688,6 +10591,23 @@ _tmp_130_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_0;
+            case 12:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // param_no_default
         if (p->error_indicator) {
             p->level--;
@@ -9707,6 +10627,10 @@ _tmp_130_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -9726,6 +10650,11 @@ _tmp_130_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9745,6 +10674,25 @@ _tmp_131_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 35:
+                goto _first_set_alt_1;
+            case 17:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '*'
         if (p->error_indicator) {
             p->level--;
@@ -9764,6 +10712,10 @@ _tmp_131_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '**'
         if (p->error_indicator) {
             p->level--;
@@ -9783,6 +10735,10 @@ _tmp_131_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '/'
         if (p->error_indicator) {
             p->level--;
@@ -9802,6 +10758,11 @@ _tmp_131_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_131[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -9832,6 +10793,8 @@ _loop1_132_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
         NameDefaultPair* param_with_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (param_with_default_var = param_with_default_rule(p))  // param_with_default
         )
         {
@@ -9952,6 +10915,8 @@ _loop0_134_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
         NameDefaultPair* lambda_param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default
         )
         {
@@ -10010,6 +10975,8 @@ _loop0_135_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
         arg_ty lambda_param_no_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
         )
         {
@@ -10165,6 +11132,23 @@ _tmp_138_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 12:
+                goto _first_set_alt_0;
+            case 1:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -10184,6 +11168,10 @@ _tmp_138_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // lambda_param_no_default
         if (p->error_indicator) {
             p->level--;
@@ -10203,6 +11191,11 @@ _tmp_138_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -10233,6 +11226,8 @@ _loop1_139_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
         NameDefaultPair* lambda_param_maybe_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default
         )
         {
@@ -10296,6 +11291,8 @@ _loop1_140_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
         NameDefaultPair* lambda_param_with_default_var;
         while (
+            _PyPegen_next_token_in(p, 0x2ULL, 0x0ULL)  // first set
+            &&
             (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
         )
         {
@@ -10348,6 +11345,23 @@ _tmp_141_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 11:
+                goto _first_set_alt_0;
+            case 12:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -10367,6 +11381,10 @@ _tmp_141_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ',' (':' | '**')
         if (p->error_indicator) {
             p->level--;
@@ -10389,6 +11407,11 @@ _tmp_141_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -10408,6 +11431,23 @@ _tmp_142_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 1:
+                goto _first_set_alt_0;
+            case 12:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // lambda_param_no_default
         if (p->error_indicator) {
             p->level--;
@@ -10427,6 +11467,10 @@ _tmp_142_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -10446,6 +11490,11 @@ _tmp_142_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -10465,6 +11514,25 @@ _tmp_143_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 12:
+                goto _first_set_alt_0;
+            case 8:
+                goto _first_set_alt_1;
+            case 11:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -10484,6 +11552,10 @@ _tmp_143_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -10503,6 +11575,10 @@ _tmp_143_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -10522,6 +11598,11 @@ _tmp_143_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -10746,6 +11827,8 @@ _loop0_148_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
         void *_tmp_197_var;
         while (
+            _PyPegen_next_token_in(p, 0x10000000800000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_197_var = _tmp_197_rule(p))  // '.' | '...'
         )
         {
@@ -11009,6 +12092,23 @@ _tmp_153_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 524:
+                goto _first_set_alt_0;
+            case 525:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // 'except'
         if (p->error_indicator) {
             p->level--;
@@ -11028,6 +12128,10 @@ _tmp_153_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // 'finally'
         if (p->error_indicator) {
             p->level--;
@@ -11047,6 +12151,11 @@ _tmp_153_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_153[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -11077,6 +12186,8 @@ _loop0_154_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "block"));
         asdl_stmt_seq* block_var;
         while (
+            _PyPegen_next_token_in(p, 0x481000008201c29eULL, 0x69c000fffULL)  // first set
+            &&
             (block_var = block_rule(p))  // block
         )
         {
@@ -11135,6 +12246,8 @@ _loop1_155_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
         excepthandler_ty except_block_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x1000000ULL)  // first set
+            &&
             (except_block_var = except_block_rule(p))  // except_block
         )
         {
@@ -11239,6 +12352,8 @@ _loop1_157_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_157[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_star_block"));
         excepthandler_ty except_star_block_var;
         while (
+            _PyPegen_next_token_in(p, 0x0ULL, 0x1000000ULL)  // first set
+            &&
             (except_star_block_var = except_star_block_rule(p))  // except_star_block
         )
         {
@@ -11333,6 +12448,23 @@ _tmp_159_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 4:
+                goto _first_set_alt_0;
+            case 11:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -11352,6 +12484,10 @@ _tmp_159_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -11371,6 +12507,11 @@ _tmp_159_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_159[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -11723,6 +12864,23 @@ _tmp_167_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 26:
+                goto _first_set_alt_0;
+            case 12:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '}'
         if (p->error_indicator) {
             p->level--;
@@ -11742,6 +12900,10 @@ _tmp_167_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -11761,6 +12923,11 @@ _tmp_167_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_167[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -11780,6 +12947,27 @@ _tmp_168_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 22:
+                goto _first_set_alt_0;
+            case 54:
+                goto _first_set_alt_1;
+            case 11:
+                goto _first_set_alt_2;
+            case 26:
+                goto _first_set_alt_3;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '='
         if (p->error_indicator) {
             p->level--;
@@ -11799,6 +12987,10 @@ _tmp_168_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '!'
         if (p->error_indicator) {
             p->level--;
@@ -11818,6 +13010,10 @@ _tmp_168_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -11837,6 +13033,10 @@ _tmp_168_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // '}'
         if (p->error_indicator) {
             p->level--;
@@ -11856,6 +13056,11 @@ _tmp_168_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_168[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -11875,6 +13080,25 @@ _tmp_169_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 54:
+                goto _first_set_alt_0;
+            case 11:
+                goto _first_set_alt_1;
+            case 26:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '!'
         if (p->error_indicator) {
             p->level--;
@@ -11894,6 +13118,10 @@ _tmp_169_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -11913,6 +13141,10 @@ _tmp_169_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '}'
         if (p->error_indicator) {
             p->level--;
@@ -11932,6 +13164,11 @@ _tmp_169_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_169[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -11992,6 +13229,23 @@ _tmp_171_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 11:
+                goto _first_set_alt_0;
+            case 26:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -12011,6 +13265,10 @@ _tmp_171_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '}'
         if (p->error_indicator) {
             p->level--;
@@ -12030,6 +13288,11 @@ _tmp_171_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_171[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'}'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12060,6 +13323,8 @@ _loop0_172_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_172[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "fstring_format_spec"));
         expr_ty fstring_format_spec_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000000002000000ULL, 0x0ULL)  // first set
+            &&
             (fstring_format_spec_var = fstring_format_spec_rule(p))  // fstring_format_spec
         )
         {
@@ -12118,6 +13383,8 @@ _loop1_173_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_173[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(fstring | string)"));
         void *_tmp_175_var;
         while (
+            _PyPegen_next_token_in(p, 0x800000000000008ULL, 0x0ULL)  // first set
+            &&
             (_tmp_175_var = _tmp_175_rule(p))  // fstring | string
         )
         {
@@ -12181,6 +13448,8 @@ _loop1_174_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop1_174[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tstring"));
         expr_ty tstring_var;
         while (
+            _PyPegen_next_token_in(p, 0x4000000000000000ULL, 0x0ULL)  // first set
+            &&
             (tstring_var = tstring_rule(p))  // tstring
         )
         {
@@ -12233,6 +13502,23 @@ _tmp_175_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 59:
+                goto _first_set_alt_0;
+            case 3:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // fstring
         if (p->error_indicator) {
             p->level--;
@@ -12252,6 +13538,10 @@ _tmp_175_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "fstring"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // string
         if (p->error_indicator) {
             p->level--;
@@ -12271,6 +13561,11 @@ _tmp_175_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_175[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "string"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12290,6 +13585,33 @@ _tmp_176_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 14:
+                goto _first_set_alt_0;
+            case 15:
+                goto _first_set_alt_1;
+            case 16:
+                goto _first_set_alt_2;
+            case 17:
+                goto _first_set_alt_3;
+            case 24:
+                goto _first_set_alt_4;
+            case 47:
+                goto _first_set_alt_5;
+            case 49:
+                goto _first_set_alt_6;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '+'
         if (p->error_indicator) {
             p->level--;
@@ -12309,6 +13631,10 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '-'
         if (p->error_indicator) {
             p->level--;
@@ -12328,6 +13654,10 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '*'
         if (p->error_indicator) {
             p->level--;
@@ -12347,6 +13677,10 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // '/'
         if (p->error_indicator) {
             p->level--;
@@ -12366,6 +13700,10 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_4:
     { // '%'
         if (p->error_indicator) {
             p->level--;
@@ -12385,6 +13723,10 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_5:
     { // '//'
         if (p->error_indicator) {
             p->level--;
@@ -12404,6 +13746,10 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_6:
     { // '@'
         if (p->error_indicator) {
             p->level--;
@@ -12423,6 +13769,11 @@ _tmp_176_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_176[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12442,6 +13793,25 @@ _tmp_177_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 14:
+                goto _first_set_alt_0;
+            case 15:
+                goto _first_set_alt_1;
+            case 31:
+                goto _first_set_alt_2;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '+'
         if (p->error_indicator) {
             p->level--;
@@ -12461,6 +13831,10 @@ _tmp_177_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '-'
         if (p->error_indicator) {
             p->level--;
@@ -12480,6 +13854,10 @@ _tmp_177_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // '~'
         if (p->error_indicator) {
             p->level--;
@@ -12499,6 +13877,11 @@ _tmp_177_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_177[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12684,6 +14067,23 @@ _tmp_193_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 8:
+                goto _first_set_alt_0;
+            case 35:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -12703,6 +14103,10 @@ _tmp_193_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '**'
         if (p->error_indicator) {
             p->level--;
@@ -12722,6 +14126,11 @@ _tmp_193_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_193[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12741,6 +14150,23 @@ _tmp_194_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 11:
+                goto _first_set_alt_0;
+            case 35:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ':'
         if (p->error_indicator) {
             p->level--;
@@ -12760,6 +14186,10 @@ _tmp_194_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_194[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '**'
         if (p->error_indicator) {
             p->level--;
@@ -12779,6 +14209,11 @@ _tmp_194_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_194[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12809,6 +14244,8 @@ _loop0_195_rule(Parser *p)
         D(fprintf(stderr, "%*c> _loop0_195[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' bitwise_or)"));
         void *_tmp_203_var;
         while (
+            _PyPegen_next_token_in(p, 0x1000ULL, 0x0ULL)  // first set
+            &&
             (_tmp_203_var = _tmp_203_rule(p))  // ',' bitwise_or
         )
         {
@@ -12856,6 +14293,27 @@ _tmp_196_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 12:
+                goto _first_set_alt_0;
+            case 8:
+                goto _first_set_alt_1;
+            case 13:
+                goto _first_set_alt_2;
+            case 4:
+                goto _first_set_alt_3;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // ','
         if (p->error_indicator) {
             p->level--;
@@ -12875,6 +14333,10 @@ _tmp_196_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_196[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // ')'
         if (p->error_indicator) {
             p->level--;
@@ -12894,6 +14356,10 @@ _tmp_196_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_196[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_2:
     { // ';'
         if (p->error_indicator) {
             p->level--;
@@ -12913,6 +14379,10 @@ _tmp_196_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_196[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_3:
     { // NEWLINE
         if (p->error_indicator) {
             p->level--;
@@ -12932,6 +14402,11 @@ _tmp_196_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_196[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -12951,6 +14426,23 @@ _tmp_197_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 23:
+                goto _first_set_alt_0;
+            case 52:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // '.'
         if (p->error_indicator) {
             p->level--;
@@ -12970,6 +14462,10 @@ _tmp_197_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_197[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // '...'
         if (p->error_indicator) {
             p->level--;
@@ -12989,6 +14485,11 @@ _tmp_197_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_197[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -13283,6 +14784,43 @@ _tmp_205_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 16:
+                goto _first_set_alt_0;
+            case 1:
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                goto _first_set_alt_1;
+            default:
+                goto _first_set_done;
+        }
+    }
+    _first_set_alt_0:
     { // starred_expression
         if (p->error_indicator) {
             p->level--;
@@ -13302,6 +14840,10 @@ _tmp_205_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_205[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_alt_1:
     { // (assignment_expression | expression !':=') !'='
         if (p->error_indicator) {
             p->level--;
@@ -13323,6 +14865,11 @@ _tmp_205_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_205[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(assignment_expression | expression !':=') !'='"));
     }
+    if (!p->call_invalid_rules) {
+        goto _first_set_done;
+    }
+    _first_set_done:
+    ;
     _res = NULL;
   done:
     p->level--;
@@ -13342,6 +14889,45 @@ _tmp_206_rule(Parser *p)
     }
     void * _res = NULL;
     int _mark = p->mark;
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        p->level--;
+        return NULL;
+    }
+    int _current_token_type = p->tokens[_mark]->type;
+    unsigned long long _first_set_mask = ~0ULL;
+    if (!p->call_invalid_rules) {
+        switch (_current_token_type) {
+            case 2:
+            case 3:
+            case 7:
+            case 9:
+            case 14:
+            case 15:
+            case 25:
+            case 31:
+            case 52:
+            case 59:
+            case 62:
+            case 504:
+            case 508:
+            case 509:
+            case 526:
+            case 527:
+            case 528:
+            case 531:
+            case 533:
+            case 534:
+                _first_set_mask = 0x2ULL;
+                break;
+            case 1:
+                _first_set_mask = 0x3ULL;
+                break;
+            default:
+                _first_set_mask = 0x0ULL;
+        }
+    }
+    if (_first_set_mask & 0x1ULL)
     { // assignment_expression
         if (p->error_indicator) {
             p->level--;
@@ -13361,6 +14947,7 @@ _tmp_206_rule(Parser *p)
         D(fprintf(stderr, "%*c%s _tmp_206[%d-%d]: %s failed!\n", p->level, ' ',
                   p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment_expression"));
     }
+    if (_first_set_mask & 0x2ULL)
     { // expression !':='
         if (p->error_indicator) {
             p->level--;
diff --git a/Parser/pegen.h b/Parser/pegen.h
index 5a2a5b1d926e26..e746d99b7cc584 100644
--- a/Parser/pegen.h
+++ b/Parser/pegen.h
@@ -194,6 +194,24 @@ expr_ty _PyPegen_soft_keyword_token(Parser *p);
 expr_ty _PyPegen_fstring_middle_token(Parser* p);
 Token *_PyPegen_get_last_nonnwhitespace_token(Parser *);
 int _PyPegen_fill_token(Parser *p);
+
+// Return whether the type of the next token is in a first set, given as masks
+// of the token types below 64 and of the keyword types (numbered from 500).
+static inline int
+_PyPegen_next_token_in(Parser *p, uint64_t token_mask, uint64_t keyword_mask)
+{
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        return 0;
+    }
+    int type = p->tokens[p->mark]->type;
+    if (type < 64) {
+        return (token_mask >> type) & 1;
+    }
+    type -= 500;
+    return 0 <= type && type < 64 && ((keyword_mask >> type) & 1);
+}
+
 // Return -1 on failure, leaving the buffer and capacity unchanged.
 int _PyPegen_grow_loop_buffer(void ***buffer, Py_ssize_t *capacity);
 expr_ty _PyPegen_name_token(Parser *p);
diff --git a/Tools/peg_generator/pegen/c_generator.py b/Tools/peg_generator/pegen/c_generator.py
index 721327bcfb59ae..b20e1810e9d742 100644
--- a/Tools/peg_generator/pegen/c_generator.py
+++ b/Tools/peg_generator/pegen/c_generator.py
@@ -73,7 +73,7 @@ def __init__(
         super().__init__(grammar, set(tokens.values()), file)
         self.included_files = included_files or {}
         self.callmakervisitor: CCallMakerVisitor = CCallMakerVisitor(
-            self, exact_tokens, non_exact_tokens
+            self, exact_tokens, non_exact_tokens, tokens
         )
         self._collected = False
         self.debug = debug
diff --git a/Tools/peg_generator/pegen/c_generator_calls.py b/Tools/peg_generator/pegen/c_generator_calls.py
index 474e65fd04793c..53364d34d805f9 100644
--- a/Tools/peg_generator/pegen/c_generator_calls.py
+++ b/Tools/peg_generator/pegen/c_generator_calls.py
@@ -3,7 +3,7 @@
 import ast
 import pathlib
 import re
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import replace
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any
@@ -45,6 +45,8 @@
     RuleKind,
     StringLeaf,
 )
+from pegen.grammar_analysis import FirstSetVisitor
+from pegen.parser_generator import KEYWORD_TYPE_BASE
 
 if TYPE_CHECKING:
     from pegen.parser_generator import ParserGenerator
@@ -111,11 +113,13 @@ def __init__(
         parser_generator: "ParserGenerator",
         exact_tokens: dict[str, int],
         non_exact_tokens: set[str],
+        tokens: dict[int, str],
     ):
         self._registry = parser_generator
         self._keywords = parser_generator.keywords
         self._exact_tokens = exact_tokens
         self._non_exact_tokens = non_exact_tokens
+        self._token_types = {name: token_type for token_type, name in tokens.items()}
         self._helper_cache: dict[tuple[pathlib.Path | None, type, str], str] = {}
         self._calls: dict[NamedItem, tuple[Item, FunctionCall]] = {}
 
@@ -343,8 +347,47 @@ def _resolve_artificial_rule(self, node: _HelperNode) -> CRuleSignature:
             self._helper_cache[key] = name
         return rule_signature(self._registry.all_rules[name])
 
+    def _token_type(self, terminal: str) -> int | None:
+        if not terminal.startswith("'"):
+            return self._token_types.get(terminal)
+        value = ast.literal_eval(terminal)
+        if value in self._keywords:
+            return self._keywords[value]
+        return self._exact_tokens.get(value)
+
+    def _first_set(
+        self, first_sets: FirstSetVisitor, alt: Alt
+    ) -> frozenset[int] | None:
+        if (first := first_sets.visit(alt)) is None:
+            return None
+        token_types = set()
+        for terminal in first:
+            if (token_type := self._token_type(terminal)) is None:
+                return None
+            token_types.add(token_type)
+        return frozenset(token_types)
+
+    def _next_token_check(self, token_types: frozenset[int]) -> FunctionCall | None:
+        token_mask = keyword_mask = 0
+        for token_type in token_types:
+            if token_type < 64:
+                token_mask |= 1 << token_type
+            elif 0 <= token_type - KEYWORD_TYPE_BASE < 64:
+                keyword_mask |= 1 << (token_type - KEYWORD_TYPE_BASE)
+            else:
+                return None
+        return FunctionCall(
+            function="_PyPegen_next_token_in",
+            arguments=("p", f"0x{token_mask:x}ULL", f"0x{keyword_mask:x}ULL"),
+            return_type="int",
+            comment="first set",
+        )
+
     def make_lowerer(self) -> "CCallLowerer":
+        first_sets = FirstSetVisitor(self._registry.all_rules)
         return CCallLowerer(
+            first_set=lambda alt: self._first_set(first_sets, alt),
+            next_token_check=self._next_token_check,
             calls=self._calls,
             rules=self._registry.all_rules,
             original_rules=self._registry.rules,
@@ -363,11 +406,17 @@ class CCallLowerer:
     def __init__(
         self,
         *,
+        first_set: Callable[[Alt], frozenset[int] | None] = lambda alt: None,
+        next_token_check: Callable[[frozenset[int]], FunctionCall | None] = (
+            lambda token_types: None
+        ),
         calls: Mapping[NamedItem, tuple[Item, FunctionCall]],
         rules: Mapping[str, Rule],
         original_rules: dict[str, Rule],
         signatures: Mapping[str, CRuleSignature],
     ):
+        self._first_set = first_set
+        self._next_token_check = next_token_check
         self._calls = MappingProxyType(dict(calls))
         self._signatures = MappingProxyType(dict(signatures))
         self._prefixes: dict[str, tuple[CPrefix, ...]] = {}
@@ -415,13 +464,19 @@ def prepare_rule(
         if (signature := self._signatures.get(rule.name)) is None:
             raise RuntimeError(f"Rule {rule.name!r} was not discovered")
         rhs = rule.flatten()
-        if signature.kind in {RuleKind.LOOP0, RuleKind.LOOP1}:
+        is_loop = signature.kind in {RuleKind.LOOP0, RuleKind.LOOP1}
+        if is_loop:
             assert len(rhs.alts) == 1
         return CRule(
             signature=signature,
             text=str(rule),
             alternatives=tuple(
-                self.prepare_alt(alt, kind=signature.kind, skip_actions=skip_actions)
+                self.prepare_alt(
+                    alt,
+                    kind=signature.kind,
+                    skip_actions=skip_actions,
+                    first_set_check=self._loop_check(alt) if is_loop else None,
+                )
                 for alt in rhs.alts
             ),
             left_recursive=rule.left_recursive,
@@ -429,18 +484,51 @@ def prepare_rule(
             memoize="memo" in rule.flags and not rule.left_recursive,
             disable_invalid_rules=rule.name.endswith("without_invalid"),
             prefixes=self._prefixes.get(rule.name, ()),
+            first_set_dispatch=None if is_loop else self._first_set_dispatch(rhs),
             source=rule.source,
             shared=shared,
         )
 
+    def _loop_check(self, alt: Alt) -> FunctionCall | None:
+        # Matching a token costs no more than checking it.
+        match alt.items:
+            case [NamedItem(item=StringLeaf()), *_]:
+                return None
+            case [NamedItem(item=NameLeaf(value=name)), *_] if name not in self._signatures:
+                return None
+        if (token_types := self._first_set(alt)) is None:
+            return None
+        return self._next_token_check(token_types)
+
+    def _first_set_dispatch(self, rhs: Rhs) -> tuple[frozenset[int] | None, ...] | None:
+        # The dispatch mask has a bit per alternative.
+        if not 2 <= len(rhs.alts) <= 64:
+            return None
+        dispatch: list[frozenset[int] | None] = []
+        tried: list[frozenset[int] | None] = []
+        for alt in rhs.alts:
+            if self._requires_invalid_rules(alt):
+                # Only the second pass tries it, and doesn't dispatch.
+                dispatch.append(frozenset())
+            else:
+                dispatch.append(token_types := self._first_set(alt))
+                tried.append(token_types)
+        # Worthless if all first sets are unknown, or are the same: the rule
+        # is then rarely tried on a token that rules out an alternative.
+        known = [token_types for token_types in tried if token_types is not None]
+        if not known or (len(known) == len(tried) and len(set(known)) == 1):
+            return None
+        return tuple(dispatch)
+
     def prepare_alt(
         self,
         node: Alt,
         *,
         kind: RuleKind = RuleKind.NORMAL,
         skip_actions: bool = False,
+        first_set_check: FunctionCall | None = None,
     ) -> CAlternative:
-        calls: list[FunctionCall] = []
+        calls = [first_set_check] if first_set_check is not None else []
         variables: dict[str, CVariable] = {}
         cut_variable = None
         for item in node.items:
diff --git a/Tools/peg_generator/pegen/c_generator_model.py b/Tools/peg_generator/pegen/c_generator_model.py
index 61ffa91787ff46..9559b9bfbef670 100644
--- a/Tools/peg_generator/pegen/c_generator_model.py
+++ b/Tools/peg_generator/pegen/c_generator_model.py
@@ -125,6 +125,7 @@ class CRule:
     memoize: bool
     disable_invalid_rules: bool
     prefixes: tuple[CPrefix, ...] = ()
+    first_set_dispatch: tuple[frozenset[int] | None, ...] | None = None
     source: pathlib.Path | None = None
     shared: bool = False
 
diff --git a/Tools/peg_generator/pegen/c_generator_rules.py b/Tools/peg_generator/pegen/c_generator_rules.py
index 89d105039f9e36..3a33796acfd4fe 100644
--- a/Tools/peg_generator/pegen/c_generator_rules.py
+++ b/Tools/peg_generator/pegen/c_generator_rules.py
@@ -187,9 +187,12 @@ def _emit_rule_body(self) -> None:
                 self._print(f"int {prefix.end} = 0, {prefix.valid} = 0;")
             if self._rule.uses_locations:
                 self._emit_token_start_metadata()
-            for alt in self._rule.alternatives:
-                with self._alternative(alt):
-                    self._emit_normal_alt(alt)
+            if (dispatch := self._rule.first_set_dispatch) is not None:
+                self._emit_first_set_dispatch(dispatch)
+            else:
+                for alt in self._rule.alternatives:
+                    with self._alternative(alt):
+                        self._emit_normal_alt(alt)
             if self._debug:
                 self._print(f'D(fprintf(stderr, "Fail at %d: {signature.name}\\n", p->mark));')
             self._print("_res = NULL;")
@@ -199,6 +202,86 @@ def _emit_rule_body(self) -> None:
                 self._print(f"_PyPegen_insert_memo(p, _mark, {signature.name}_type, _res);")
             self._returns.emit("_res")
 
+    def _emit_first_set_dispatch(self, dispatch: tuple[frozenset[int] | None, ...]) -> None:
+        if not self._rule.uses_locations:
+            self._print("if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {")
+            with self._indent():
+                self._print("p->error_indicator = 1;")
+                self._returns.emit("NULL")
+            self._print("}")
+        self._print("int _current_token_type = p->tokens[_mark]->type;")
+        # The second pass tries every alternative in order, so that it reports
+        # the same errors as without dispatch.
+        known = [token_types for token_types in dispatch if token_types is not None]
+        if len(known) == len(dispatch) and sum(map(len, known)) == len(frozenset().union(*known)):
+            # At most one alternative may match the next token.
+            self._emit_first_set_jumps(known)
+        else:
+            self._emit_first_set_mask(dispatch)
+
+    def _emit_first_set_jumps(self, dispatch: list[frozenset[int]]) -> None:
+        self._print("if (!p->call_invalid_rules) {")
+        with self._indent():
+            self._print("switch (_current_token_type) {")
+            with self._indent():
+                for index, token_types in enumerate(dispatch):
+                    if not token_types:
+                        continue
+                    for token_type in sorted(token_types):
+                        self._print(f"case {token_type}:")
+                    with self._indent():
+                        self._print(f"goto _first_set_alt_{index};")
+                self._print("default:")
+                with self._indent():
+                    self._print("goto _first_set_done;")
+            self._print("}")
+        self._print("}")
+        for index, (alt, token_types) in enumerate(zip(self._rule.alternatives, dispatch)):
+            if token_types:
+                self._print(f"_first_set_alt_{index}:")
+            with self._alternative(alt):
+                self._emit_normal_alt(alt)
+            self._print("if (!p->call_invalid_rules) {")
+            with self._indent():
+                self._print("goto _first_set_done;")
+            self._print("}")
+        self._print("_first_set_done:")
+        self._print(";")
+
+    def _emit_first_set_mask(self, dispatch: tuple[frozenset[int] | None, ...]) -> None:
+        # Bits of the alternatives that may match the next token.
+        unknown = sum(
+            1 << index for index, token_types in enumerate(dispatch) if token_types is None
+        )
+        masks: dict[int, int] = {}
+        for index, token_types in enumerate(dispatch):
+            for token_type in token_types or ():
+                masks[token_type] = masks.get(token_type, unknown) | (1 << index)
+        token_types_by_mask: dict[int, list[int]] = {}
+        for token_type, mask in sorted(masks.items()):
+            token_types_by_mask.setdefault(mask, []).append(token_type)
+
+        self._print("unsigned long long _first_set_mask = ~0ULL;")
+        self._print("if (!p->call_invalid_rules) {")
+        with self._indent():
+            self._print("switch (_current_token_type) {")
+            with self._indent():
+                for mask, cases in sorted(token_types_by_mask.items()):
+                    for token_type in cases:
+                        self._print(f"case {token_type}:")
+                    with self._indent():
+                        self._print(f"_first_set_mask = 0x{mask:x}ULL;")
+                        self._print("break;")
+                self._print("default:")
+                with self._indent():
+                    self._print(f"_first_set_mask = 0x{unknown:x}ULL;")
+            self._print("}")
+        self._print("}")
+        for index, alt in enumerate(self._rule.alternatives):
+            self._print(f"if (_first_set_mask & 0x{1 << index:x}ULL)")
+            with self._alternative(alt):
+                self._emit_normal_alt(alt)
+
     def _emit_loop_body(self) -> None:
         rule = self._rule
         signature = rule.signature
diff --git a/Tools/peg_generator/pegen/first_sets.py b/Tools/peg_generator/pegen/first_sets.py
index 9980f76666518d..a336aca17c33f9 100755
--- a/Tools/peg_generator/pegen/first_sets.py
+++ b/Tools/peg_generator/pegen/first_sets.py
@@ -6,24 +6,7 @@
 import sys
 
 from pegen.build import build_parser
-from pegen.grammar import (
-    Alt,
-    Cut,
-    Gather,
-    GrammarVisitor,
-    Group,
-    Lookahead,
-    NamedItem,
-    NameLeaf,
-    NegativeLookahead,
-    Opt,
-    Repeat0,
-    Repeat1,
-    Rhs,
-    Rule,
-    StringLeaf,
-)
-from pegen.parser_generator import compute_nullables
+from pegen.grammar_analysis import FirstSetVisitor
 
 argparser = argparse.ArgumentParser(
     prog="calculate_first_sets",
@@ -32,106 +15,6 @@
 argparser.add_argument("grammar_file", type=pathlib.Path, help="The grammar file")
 
 
-class FirstSetCalculator(GrammarVisitor):
-    def __init__(self, rules: dict[str, Rule]) -> None:
-        self.rules = rules
-        self.nullables = compute_nullables(rules)
-        self.first_sets: dict[str, set[str]] = dict()
-        self.in_process: set[str] = set()
-
-    def calculate(self) -> dict[str, set[str]]:
-        for name, rule in self.rules.items():
-            self.visit(rule)
-        return self.first_sets
-
-    def visit_Alt(self, item: Alt) -> set[str]:
-        result: set[str] = set()
-        to_remove: set[str] = set()
-        for other in item.items:
-            new_terminals = self.visit(other)
-            if isinstance(other.item, NegativeLookahead):
-                to_remove |= new_terminals
-            result |= new_terminals
-            if to_remove:
-                result -= to_remove
-
-            # If the set of new terminals can start with the empty string,
-            # it means that the item is completely nullable and we should
-            # also considering at least the next item in case the current
-            # one fails to parse.
-
-            if "" in new_terminals:
-                continue
-
-            if not isinstance(other.item, (Opt, NegativeLookahead, Repeat0)):
-                break
-
-        # Do not allow the empty string to propagate.
-        result.discard("")
-
-        return result
-
-    def visit_Cut(self, item: Cut) -> set[str]:
-        return set()
-
-    def visit_Group(self, item: Group) -> set[str]:
-        return self.visit(item.rhs)
-
-    def visit_PositiveLookahead(self, item: Lookahead) -> set[str]:
-        return self.visit(item.node)
-
-    def visit_NegativeLookahead(self, item: NegativeLookahead) -> set[str]:
-        return self.visit(item.node)
-
-    def visit_NamedItem(self, item: NamedItem) -> set[str]:
-        return self.visit(item.item)
-
-    def visit_Opt(self, item: Opt) -> set[str]:
-        return self.visit(item.node)
-
-    def visit_Gather(self, item: Gather) -> set[str]:
-        return self.visit(item.node)
-
-    def visit_Repeat0(self, item: Repeat0) -> set[str]:
-        return self.visit(item.node)
-
-    def visit_Repeat1(self, item: Repeat1) -> set[str]:
-        return self.visit(item.node)
-
-    def visit_NameLeaf(self, item: NameLeaf) -> set[str]:
-        if item.value not in self.rules:
-            return {item.value}
-
-        if item.value not in self.first_sets:
-            self.first_sets[item.value] = self.visit(self.rules[item.value])
-            return self.first_sets[item.value]
-        elif item.value in self.in_process:
-            return set()
-
-        return self.first_sets[item.value]
-
-    def visit_StringLeaf(self, item: StringLeaf) -> set[str]:
-        return {item.value}
-
-    def visit_Rhs(self, item: Rhs) -> set[str]:
-        result: set[str] = set()
-        for alt in item.alts:
-            result |= self.visit(alt)
-        return result
-
-    def visit_Rule(self, item: Rule) -> set[str]:
-        if item.name in self.in_process:
-            return set()
-        elif item.name not in self.first_sets:
-            self.in_process.add(item.name)
-            terminals = self.visit(item.rhs)
-            if item in self.nullables:
-                terminals.add("")
-            self.first_sets[item.name] = terminals
-            self.in_process.remove(item.name)
-        return self.first_sets[item.name]
-
-
 def main() -> None:
     args = argparser.parse_args()
 
@@ -141,8 +24,8 @@ def main() -> None:
         print("ERROR: Failed to parse grammar file", err, file=sys.stderr)
         sys.exit(1)
 
-    firs_sets = FirstSetCalculator(grammar.rules).calculate()
-    pprint.pprint(firs_sets)
+    first_sets = FirstSetVisitor(grammar.rules).first_sets
+    pprint.pprint(first_sets)
 
 
 if __name__ == "__main__":
diff --git a/Tools/peg_generator/pegen/grammar_analysis.py b/Tools/peg_generator/pegen/grammar_analysis.py
index 5b716cf209e000..91dca331a155f3 100644
--- a/Tools/peg_generator/pegen/grammar_analysis.py
+++ b/Tools/peg_generator/pegen/grammar_analysis.py
@@ -1,5 +1,6 @@
-"""Nullable and left-recursion analysis for source grammar rules."""
+"""Nullable, first set and left-recursion analysis for source grammar rules."""
 
+import ast
 from collections.abc import Iterable, Set
 from typing import Any
 
@@ -13,11 +14,14 @@
     Group,
     NamedItem,
     NameLeaf,
+    NegativeLookahead,
     Opt,
+    PositiveLookahead,
     Repeat0,
     Repeat1,
     Rhs,
     Rule,
+    RuleKind,
     StringLeaf,
 )
 
@@ -106,6 +110,77 @@ def visit(self, node: Any, *args: Any, **kwargs: Any) -> set[Any]:
                 return self.generic_visit(node, *args, **kwargs)
 
 
+# A set of terminals (token names, quoted keywords and quoted exact tokens)
+# such that an item may only match, or have any effect, if the next token is in
+# it. None if the item may match whatever the next token is, or have an effect
+# (commit to a cut, raise for a forced token or in an action) before it fails.
+FirstSet = frozenset[str] | None
+
+
+class FirstSetVisitor(GrammarVisitor):
+
+    def __init__(self, rules: dict[str, Rule]) -> None:
+        self.rules = rules
+        self.first_sets: dict[str, FirstSet] = {name: frozenset() for name in rules}
+        # Grow the first sets until they cover each other's in recursive rules.
+        changed = True
+        while changed:
+            changed = False
+            for name, rule in rules.items():
+                first = None if rule.kind is RuleKind.LOOP0 else self.visit(rule.rhs)
+                if first != self.first_sets[name]:
+                    self.first_sets[name] = first
+                    changed = True
+
+    def visit(self, node: Any, *args: Any, **kwargs: Any) -> FirstSet:
+        match node:
+            case Rhs(alts=alts):
+                result: set[str] = set()
+                for alt in alts:
+                    if (first := self.visit(alt)) is None:
+                        return None
+                    result |= first
+                return frozenset(result)
+            case Alt(items=items):
+                result = set()
+                for item in items:
+                    match item.item:
+                        case Cut() | Forced():
+                            return None
+                        case NegativeLookahead() | Opt() | Repeat0() as optional:
+                            # Matches whatever the next token is, but only has
+                            # an effect when it's in its own first set.
+                            if (first := self.visit(optional.node)) is None:
+                                return None
+                            result |= first
+                        case required:
+                            if (first := self.visit(required)) is None:
+                                return None
+                            return frozenset(result | first)
+                return None
+            case NamedItem(item=item):
+                return self.visit(item)
+            case Group(rhs=rhs):
+                return self.visit(rhs)
+            case Repeat1(node=child) | Gather(node=child) | PositiveLookahead(node=child):
+                return self.visit(child)
+            case Opt() | Repeat0() | NegativeLookahead() | Cut() | Forced():
+                return None
+            case NameLeaf(value=name):
+                if name in self.rules:
+                    return self.first_sets[name]
+                # Soft keywords are NAME tokens.
+                return frozenset({"NAME" if name == "SOFT_KEYWORD" else name})
+            case StringLeaf(value=value):
+                if not ast.literal_eval(value):
+                    return None
+                if value.startswith('"') and value[1:-1].isidentifier():
+                    return frozenset({"NAME"})
+                return frozenset({value})
+            case _:
+                raise TypeError(f"Unexpected grammar node {node!r}")
+
+
 def compute_left_recursives(
     rules: dict[str, Rule]
 ) -> tuple[dict[str, Set[str]], list[Set[str]]]:
diff --git a/Tools/peg_generator/pegen/parser_generator.py b/Tools/peg_generator/pegen/parser_generator.py
index b603b6f837b8e9..62abad6c4ba48d 100644
--- a/Tools/peg_generator/pegen/parser_generator.py
+++ b/Tools/peg_generator/pegen/parser_generator.py
@@ -37,6 +37,8 @@
     make_first_graph as make_first_graph,
 )
 
+KEYWORD_TYPE_BASE = 500
+
 
 class RuleCollectorVisitor(GrammarVisitor):
     """Visitor that invokes a provided callmaker visitor with just the NamedItem nodes"""
@@ -108,7 +110,7 @@ def __init__(self, grammar: Grammar, tokens: set[str], file: IO[str] | None):
         self.level = 0
         self.first_graph, self.first_sccs = compute_left_recursives(self.rules)
         self.counter = 0  # For name_rule()/name_loop()
-        self.keyword_counter = 499  # For keyword_type()
+        self.keyword_counter = KEYWORD_TYPE_BASE - 1  # For keyword_type()
         self.all_rules: dict[str, Rule] = self.rules.copy()  # Rules + temporal rules
         self._local_variable_stack: list[list[str]] = []