Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

17 files changed, 30477 insertions, 30477 deletions

diff --git a/contrib/tools/python3/src/Parser/acceler.c b/contrib/tools/python3/src/Parser/acceler.c
index e83f15f120..e515833e1d 100644
--- a/contrib/tools/python3/src/Parser/acceler.c
+++ b/contrib/tools/python3/src/Parser/acceler.c
@@ -10,21 +10,21 @@
    are not part of the static data structure written on graminit.[ch]
    by the parser generator. */
 
-#include "Python.h" 
+#include "Python.h"
 #include "grammar.h"
 #include "node.h"
 #include "token.h"
 #include "parser.h"
 
 /* Forward references */
-static void fixdfa(grammar *, const dfa *); 
+static void fixdfa(grammar *, const dfa *);
 static void fixstate(grammar *, state *);
 
 void
 PyGrammar_AddAccelerators(grammar *g)
 {
     int i;
-    const dfa *d = g->g_dfa; 
+    const dfa *d = g->g_dfa;
     for (i = g->g_ndfas; --i >= 0; d++)
         fixdfa(g, d);
     g->g_accel = 1;
@@ -35,7 +35,7 @@ PyGrammar_RemoveAccelerators(grammar *g)
 {
     int i;
     g->g_accel = 0;
-    const dfa *d = g->g_dfa; 
+    const dfa *d = g->g_dfa;
     for (i = g->g_ndfas; --i >= 0; d++) {
         state *s;
         int j;
@@ -49,7 +49,7 @@ PyGrammar_RemoveAccelerators(grammar *g)
 }
 
 static void
-fixdfa(grammar *g, const dfa *d) 
+fixdfa(grammar *g, const dfa *d)
 {
     state *s;
     int j;
@@ -61,7 +61,7 @@ fixdfa(grammar *g, const dfa *d)
 static void
 fixstate(grammar *g, state *s)
 {
-    const arc *a; 
+    const arc *a;
     int k;
     int *accel;
     int nl = g->g_ll.ll_nlabels;
@@ -76,14 +76,14 @@ fixstate(grammar *g, state *s)
     a = s->s_arc;
     for (k = s->s_narcs; --k >= 0; a++) {
         int lbl = a->a_lbl;
-        const label *l = &g->g_ll.ll_label[lbl]; 
+        const label *l = &g->g_ll.ll_label[lbl];
         int type = l->lb_type;
         if (a->a_arrow >= (1 << 7)) {
             printf("XXX too many states!\n");
             continue;
         }
         if (ISNONTERMINAL(type)) {
-            const dfa *d1 = PyGrammar_FindDFA(g, type); 
+            const dfa *d1 = PyGrammar_FindDFA(g, type);
             int ibit;
             if (type - NT_OFFSET >= (1 << 7)) {
                 printf("XXX too high nonterminal number!\n");
diff --git a/contrib/tools/python3/src/Parser/grammar1.c b/contrib/tools/python3/src/Parser/grammar1.c
index 574679a6d6..c702040efd 100644
--- a/contrib/tools/python3/src/Parser/grammar1.c
+++ b/contrib/tools/python3/src/Parser/grammar1.c
@@ -7,11 +7,11 @@
 
 /* Return the DFA for the given type */
 
-const dfa * 
+const dfa *
 PyGrammar_FindDFA(grammar *g, int type)
 {
     /* Massive speed-up */
-    const dfa *d = &g->g_dfa[type - NT_OFFSET]; 
+    const dfa *d = &g->g_dfa[type - NT_OFFSET];
     assert(d->d_type == type);
     return d;
 }
@@ -41,7 +41,7 @@ PyGrammar_LabelRepr(label *lb)
         }
     }
     else {
-        Py_FatalError("invalid grammar label"); 
+        Py_FatalError("invalid grammar label");
         return NULL;
     }
 }
diff --git a/contrib/tools/python3/src/Parser/listnode.c b/contrib/tools/python3/src/Parser/listnode.c
index 2479cec778..c806b98e48 100644
--- a/contrib/tools/python3/src/Parser/listnode.c
+++ b/contrib/tools/python3/src/Parser/listnode.c
@@ -1,9 +1,9 @@
 
 /* List a node on a file */
 
-#include "Python.h" 
-#include "pycore_interp.h"        // PyInterpreterState.parser 
-#include "pycore_pystate.h"       // _PyInterpreterState_GET() 
+#include "Python.h"
+#include "pycore_interp.h"        // PyInterpreterState.parser
+#include "pycore_pystate.h"       // _PyInterpreterState_GET()
 #include "token.h"
 #include "node.h"
 
@@ -20,18 +20,18 @@ PyNode_ListTree(node *n)
 static void
 listnode(FILE *fp, node *n)
 {
-    PyInterpreterState *interp = _PyInterpreterState_GET(); 
- 
-    interp->parser.listnode.level = 0; 
-    interp->parser.listnode.atbol = 1; 
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+
+    interp->parser.listnode.level = 0;
+    interp->parser.listnode.atbol = 1;
     list1node(fp, n);
 }
 
 static void
 list1node(FILE *fp, node *n)
 {
-    PyInterpreterState *interp; 
- 
+    PyInterpreterState *interp;
+
     if (n == NULL)
         return;
     if (ISNONTERMINAL(TYPE(n))) {
@@ -40,26 +40,26 @@ list1node(FILE *fp, node *n)
             list1node(fp, CHILD(n, i));
     }
     else if (ISTERMINAL(TYPE(n))) {
-        interp = _PyInterpreterState_GET(); 
+        interp = _PyInterpreterState_GET();
         switch (TYPE(n)) {
         case INDENT:
-            interp->parser.listnode.level++; 
+            interp->parser.listnode.level++;
             break;
         case DEDENT:
-            interp->parser.listnode.level--; 
+            interp->parser.listnode.level--;
             break;
         default:
-            if (interp->parser.listnode.atbol) { 
+            if (interp->parser.listnode.atbol) {
                 int i;
-                for (i = 0; i < interp->parser.listnode.level; ++i) 
+                for (i = 0; i < interp->parser.listnode.level; ++i)
                     fprintf(fp, "\t");
-                interp->parser.listnode.atbol = 0; 
+                interp->parser.listnode.atbol = 0;
             }
             if (TYPE(n) == NEWLINE) {
                 if (STR(n) != NULL)
                     fprintf(fp, "%s", STR(n));
                 fprintf(fp, "\n");
-                interp->parser.listnode.atbol = 1; 
+                interp->parser.listnode.atbol = 1;
             }
             else
                 fprintf(fp, "%s ", STR(n));
diff --git a/contrib/tools/python3/src/Parser/myreadline.c b/contrib/tools/python3/src/Parser/myreadline.c
index 672b6af226..143b41f1ea 100644
--- a/contrib/tools/python3/src/Parser/myreadline.c
+++ b/contrib/tools/python3/src/Parser/myreadline.c
@@ -10,10 +10,10 @@
 */
 
 #include "Python.h"
-#include "pycore_pystate.h"   // _PyThreadState_GET() 
+#include "pycore_pystate.h"   // _PyThreadState_GET()
 #ifdef MS_WINDOWS
-#  define WIN32_LEAN_AND_MEAN 
-#  include "windows.h" 
+#  define WIN32_LEAN_AND_MEAN
+#  include "windows.h"
 #endif /* MS_WINDOWS */
 
 
@@ -24,36 +24,36 @@ static PyThread_type_lock _PyOS_ReadlineLock = NULL;
 int (*PyOS_InputHook)(void) = NULL;
 
 /* This function restarts a fgets() after an EINTR error occurred
-   except if _PyOS_InterruptOccurred() returns true. */ 
+   except if _PyOS_InterruptOccurred() returns true. */
 
 static int
-my_fgets(PyThreadState* tstate, char *buf, int len, FILE *fp) 
+my_fgets(PyThreadState* tstate, char *buf, int len, FILE *fp)
 {
 #ifdef MS_WINDOWS
-    HANDLE handle; 
-    _Py_BEGIN_SUPPRESS_IPH 
-    handle = (HANDLE)_get_osfhandle(fileno(fp)); 
-    _Py_END_SUPPRESS_IPH 
- 
-    /* bpo-40826: fgets(fp) does crash if fileno(fp) is closed */ 
-    if (handle == INVALID_HANDLE_VALUE) { 
-        return -1; /* EOF */ 
-    } 
+    HANDLE handle;
+    _Py_BEGIN_SUPPRESS_IPH
+    handle = (HANDLE)_get_osfhandle(fileno(fp));
+    _Py_END_SUPPRESS_IPH
+
+    /* bpo-40826: fgets(fp) does crash if fileno(fp) is closed */
+    if (handle == INVALID_HANDLE_VALUE) {
+        return -1; /* EOF */
+    }
 #endif
- 
+
     while (1) {
-        if (PyOS_InputHook != NULL) { 
+        if (PyOS_InputHook != NULL) {
             (void)(PyOS_InputHook)();
-        } 
- 
+        }
+
         errno = 0;
         clearerr(fp);
-        char *p = fgets(buf, len, fp); 
-        if (p != NULL) { 
+        char *p = fgets(buf, len, fp);
+        if (p != NULL) {
             return 0; /* No error */
-        } 
-        int err = errno; 
- 
+        }
+        int err = errno;
+
 #ifdef MS_WINDOWS
         /* Ctrl-C anywhere on the line or Ctrl-Z if the only character
            on a line will set ERROR_OPERATION_ABORTED. Under normal
@@ -69,7 +69,7 @@ my_fgets(PyThreadState* tstate, char *buf, int len, FILE *fp)
            through to check for EOF.
         */
         if (GetLastError()==ERROR_OPERATION_ABORTED) {
-            HANDLE hInterruptEvent = _PyOS_SigintEvent(); 
+            HANDLE hInterruptEvent = _PyOS_SigintEvent();
             switch (WaitForSingleObjectEx(hInterruptEvent, 10, FALSE)) {
             case WAIT_OBJECT_0:
                 ResetEvent(hInterruptEvent);
@@ -79,27 +79,27 @@ my_fgets(PyThreadState* tstate, char *buf, int len, FILE *fp)
             }
         }
 #endif /* MS_WINDOWS */
- 
+
         if (feof(fp)) {
             clearerr(fp);
             return -1; /* EOF */
         }
- 
+
 #ifdef EINTR
         if (err == EINTR) {
-            PyEval_RestoreThread(tstate); 
-            int s = PyErr_CheckSignals(); 
+            PyEval_RestoreThread(tstate);
+            int s = PyErr_CheckSignals();
             PyEval_SaveThread();
- 
-            if (s < 0) { 
-                return 1; 
-            } 
-            /* try again */ 
+
+            if (s < 0) {
+                return 1;
+            }
+            /* try again */
             continue;
         }
 #endif
- 
-        if (_PyOS_InterruptOccurred(tstate)) { 
+
+        if (_PyOS_InterruptOccurred(tstate)) {
             return 1; /* Interrupt */
         }
         return -2; /* Error */
@@ -113,7 +113,7 @@ my_fgets(PyThreadState* tstate, char *buf, int len, FILE *fp)
 extern char _get_console_type(HANDLE handle);
 
 char *
-_PyOS_WindowsConsoleReadline(PyThreadState *tstate, HANDLE hStdIn) 
+_PyOS_WindowsConsoleReadline(PyThreadState *tstate, HANDLE hStdIn)
 {
     static wchar_t wbuf_local[1024 * 16];
     const DWORD chunk_size = 1024;
@@ -148,12 +148,12 @@ _PyOS_WindowsConsoleReadline(PyThreadState *tstate, HANDLE hStdIn)
             if (WaitForSingleObjectEx(hInterruptEvent, 100, FALSE)
                     == WAIT_OBJECT_0) {
                 ResetEvent(hInterruptEvent);
-                PyEval_RestoreThread(tstate); 
+                PyEval_RestoreThread(tstate);
                 s = PyErr_CheckSignals();
                 PyEval_SaveThread();
-                if (s < 0) { 
+                if (s < 0) {
                     goto exit;
-                } 
+                }
             }
             break;
         }
@@ -166,22 +166,22 @@ _PyOS_WindowsConsoleReadline(PyThreadState *tstate, HANDLE hStdIn)
         if (wbuf == wbuf_local) {
             wbuf[total_read] = '\0';
             wbuf = (wchar_t*)PyMem_RawMalloc(wbuflen * sizeof(wchar_t));
-            if (wbuf) { 
+            if (wbuf) {
                 wcscpy_s(wbuf, wbuflen, wbuf_local);
-            } 
+            }
             else {
-                PyEval_RestoreThread(tstate); 
+                PyEval_RestoreThread(tstate);
                 PyErr_NoMemory();
-                PyEval_SaveThread(); 
+                PyEval_SaveThread();
                 goto exit;
             }
         }
         else {
             wchar_t *tmp = PyMem_RawRealloc(wbuf, wbuflen * sizeof(wchar_t));
             if (tmp == NULL) {
-                PyEval_RestoreThread(tstate); 
+                PyEval_RestoreThread(tstate);
                 PyErr_NoMemory();
-                PyEval_SaveThread(); 
+                PyEval_SaveThread();
                 goto exit;
             }
             wbuf = tmp;
@@ -190,42 +190,42 @@ _PyOS_WindowsConsoleReadline(PyThreadState *tstate, HANDLE hStdIn)
 
     if (wbuf[0] == '\x1a') {
         buf = PyMem_RawMalloc(1);
-        if (buf) { 
+        if (buf) {
             buf[0] = '\0';
-        } 
+        }
         else {
-            PyEval_RestoreThread(tstate); 
+            PyEval_RestoreThread(tstate);
             PyErr_NoMemory();
-            PyEval_SaveThread(); 
+            PyEval_SaveThread();
         }
         goto exit;
     }
 
-    u8len = WideCharToMultiByte(CP_UTF8, 0, 
-                                wbuf, total_read, 
-                                NULL, 0, 
-                                NULL, NULL); 
+    u8len = WideCharToMultiByte(CP_UTF8, 0,
+                                wbuf, total_read,
+                                NULL, 0,
+                                NULL, NULL);
     buf = PyMem_RawMalloc(u8len + 1);
     if (buf == NULL) {
-        PyEval_RestoreThread(tstate); 
+        PyEval_RestoreThread(tstate);
         PyErr_NoMemory();
-        PyEval_SaveThread(); 
+        PyEval_SaveThread();
         goto exit;
     }
- 
-    u8len = WideCharToMultiByte(CP_UTF8, 0, 
-                                wbuf, total_read, 
-                                buf, u8len, 
-                                NULL, NULL); 
+
+    u8len = WideCharToMultiByte(CP_UTF8, 0,
+                                wbuf, total_read,
+                                buf, u8len,
+                                NULL, NULL);
     buf[u8len] = '\0';
 
 exit:
-    if (wbuf != wbuf_local) { 
+    if (wbuf != wbuf_local) {
         PyMem_RawFree(wbuf);
-    } 
+    }
 
     if (err) {
-        PyEval_RestoreThread(tstate); 
+        PyEval_RestoreThread(tstate);
         PyErr_SetFromWindowsErr(err);
         PyEval_SaveThread();
     }
@@ -242,8 +242,8 @@ PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt)
 {
     size_t n;
     char *p, *pr;
-    PyThreadState *tstate = _PyOS_ReadlineTState; 
-    assert(tstate != NULL); 
+    PyThreadState *tstate = _PyOS_ReadlineTState;
+    assert(tstate != NULL);
 
 #ifdef MS_WINDOWS
     if (!Py_LegacyWindowsStdioFlag && sys_stdin == stdin) {
@@ -265,9 +265,9 @@ PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt)
                     if (wlen) {
                         wbuf = PyMem_RawMalloc(wlen * sizeof(wchar_t));
                         if (wbuf == NULL) {
-                            PyEval_RestoreThread(tstate); 
+                            PyEval_RestoreThread(tstate);
                             PyErr_NoMemory();
-                            PyEval_SaveThread(); 
+                            PyEval_SaveThread();
                             return NULL;
                         }
                         wlen = MultiByteToWideChar(CP_UTF8, 0, prompt, -1,
@@ -286,56 +286,56 @@ PyOS_StdioReadline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt)
                 }
             }
             clearerr(sys_stdin);
-            return _PyOS_WindowsConsoleReadline(tstate, hStdIn); 
+            return _PyOS_WindowsConsoleReadline(tstate, hStdIn);
         }
     }
 #endif
 
     fflush(sys_stdout);
-    if (prompt) { 
+    if (prompt) {
         fprintf(stderr, "%s", prompt);
-    } 
+    }
     fflush(stderr);
 
-    n = 0; 
-    p = NULL; 
-    do { 
-        size_t incr = (n > 0) ? n + 2 : 100; 
+    n = 0;
+    p = NULL;
+    do {
+        size_t incr = (n > 0) ? n + 2 : 100;
         if (incr > INT_MAX) {
             PyMem_RawFree(p);
-            PyEval_RestoreThread(tstate); 
+            PyEval_RestoreThread(tstate);
             PyErr_SetString(PyExc_OverflowError, "input line too long");
-            PyEval_SaveThread(); 
+            PyEval_SaveThread();
             return NULL;
         }
         pr = (char *)PyMem_RawRealloc(p, n + incr);
         if (pr == NULL) {
             PyMem_RawFree(p);
-            PyEval_RestoreThread(tstate); 
+            PyEval_RestoreThread(tstate);
             PyErr_NoMemory();
-            PyEval_SaveThread(); 
+            PyEval_SaveThread();
             return NULL;
         }
         p = pr;
-        int err = my_fgets(tstate, p + n, (int)incr, sys_stdin); 
-        if (err == 1) { 
-            // Interrupt 
-            PyMem_RawFree(p); 
-            return NULL; 
-        } else if (err != 0) { 
-            // EOF or error 
-            p[n] = '\0'; 
+        int err = my_fgets(tstate, p + n, (int)incr, sys_stdin);
+        if (err == 1) {
+            // Interrupt
+            PyMem_RawFree(p);
+            return NULL;
+        } else if (err != 0) {
+            // EOF or error
+            p[n] = '\0';
             break;
-        } 
-        n += strlen(p + n); 
-    } while (p[n-1] != '\n'); 
- 
+        }
+        n += strlen(p + n);
+    } while (p[n-1] != '\n');
+
     pr = (char *)PyMem_RawRealloc(p, n+1);
     if (pr == NULL) {
         PyMem_RawFree(p);
-        PyEval_RestoreThread(tstate); 
+        PyEval_RestoreThread(tstate);
         PyErr_NoMemory();
-        PyEval_SaveThread(); 
+        PyEval_SaveThread();
         return NULL;
     }
     return pr;
@@ -358,8 +358,8 @@ PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt)
     char *rv, *res;
     size_t len;
 
-    PyThreadState *tstate = _PyThreadState_GET(); 
-    if (_PyOS_ReadlineTState == tstate) { 
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (_PyOS_ReadlineTState == tstate) {
         PyErr_SetString(PyExc_RuntimeError,
                         "can't re-enter readline");
         return NULL;
@@ -378,7 +378,7 @@ PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt)
         }
     }
 
-    _PyOS_ReadlineTState = tstate; 
+    _PyOS_ReadlineTState = tstate;
     Py_BEGIN_ALLOW_THREADS
     PyThread_acquire_lock(_PyOS_ReadlineLock, 1);
 
diff --git a/contrib/tools/python3/src/Parser/node.c b/contrib/tools/python3/src/Parser/node.c
index 9d1fc24d83..8789e01e9b 100644
--- a/contrib/tools/python3/src/Parser/node.c
+++ b/contrib/tools/python3/src/Parser/node.c
@@ -13,9 +13,9 @@ PyNode_New(int type)
     n->n_type = type;
     n->n_str = NULL;
     n->n_lineno = 0;
-    n->n_end_lineno = 0; 
-    n->n_col_offset = 0; 
-    n->n_end_col_offset = -1; 
+    n->n_end_lineno = 0;
+    n->n_col_offset = 0;
+    n->n_end_col_offset = -1;
     n->n_nchildren = 0;
     n->n_child = NULL;
     return n;
@@ -78,34 +78,34 @@ fancy_roundup(int n)
                fancy_roundup(n))
 
 
-void 
-_PyNode_FinalizeEndPos(node *n) 
-{ 
-    int nch = NCH(n); 
-    node *last; 
-    if (nch == 0) { 
-        return; 
-    } 
-    last = CHILD(n, nch - 1); 
-    _PyNode_FinalizeEndPos(last); 
-    n->n_end_lineno = last->n_end_lineno; 
-    n->n_end_col_offset = last->n_end_col_offset; 
-} 
- 
+void
+_PyNode_FinalizeEndPos(node *n)
+{
+    int nch = NCH(n);
+    node *last;
+    if (nch == 0) {
+        return;
+    }
+    last = CHILD(n, nch - 1);
+    _PyNode_FinalizeEndPos(last);
+    n->n_end_lineno = last->n_end_lineno;
+    n->n_end_col_offset = last->n_end_col_offset;
+}
+
 int
-PyNode_AddChild(node *n1, int type, char *str, int lineno, int col_offset, 
-                int end_lineno, int end_col_offset) 
+PyNode_AddChild(node *n1, int type, char *str, int lineno, int col_offset,
+                int end_lineno, int end_col_offset)
 {
     const int nch = n1->n_nchildren;
     int current_capacity;
     int required_capacity;
     node *n;
 
-    // finalize end position of previous node (if any) 
-    if (nch > 0) { 
-        _PyNode_FinalizeEndPos(CHILD(n1, nch - 1)); 
-    } 
- 
+    // finalize end position of previous node (if any)
+    if (nch > 0) {
+        _PyNode_FinalizeEndPos(CHILD(n1, nch - 1));
+    }
+
     if (nch == INT_MAX || nch < 0)
         return E_OVERFLOW;
 
@@ -130,8 +130,8 @@ PyNode_AddChild(node *n1, int type, char *str, int lineno, int col_offset,
     n->n_str = str;
     n->n_lineno = lineno;
     n->n_col_offset = col_offset;
-    n->n_end_lineno = end_lineno;  // this and below will be updates after all children are added. 
-    n->n_end_col_offset = end_col_offset; 
+    n->n_end_lineno = end_lineno;  // this and below will be updates after all children are added.
+    n->n_end_col_offset = end_col_offset;
     n->n_nchildren = 0;
     n->n_child = NULL;
     return 0;
diff --git a/contrib/tools/python3/src/Parser/parser.c b/contrib/tools/python3/src/Parser/parser.c
index cc6050ca20..a61b2f5ebf 100644
--- a/contrib/tools/python3/src/Parser/parser.c
+++ b/contrib/tools/python3/src/Parser/parser.c
@@ -11,7 +11,7 @@
 #include "node.h"
 #include "parser.h"
 #include "errcode.h"
-#include "graminit.h" 
+#include "graminit.h"
 
 
 #ifdef Py_DEBUG
@@ -35,7 +35,7 @@ s_reset(stack *s)
 #define s_empty(s) ((s)->s_top == &(s)->s_base[MAXSTACK])
 
 static int
-s_push(stack *s, const dfa *d, node *parent) 
+s_push(stack *s, const dfa *d, node *parent)
 {
     stackentry *top;
     if (s->s_top == s->s_base) {
@@ -54,9 +54,9 @@ s_push(stack *s, const dfa *d, node *parent)
 static void
 s_pop(stack *s)
 {
-    if (s_empty(s)) { 
-        Py_FatalError("parser stack underflow"); 
-    } 
+    if (s_empty(s)) {
+        Py_FatalError("parser stack underflow");
+    }
     s->s_top++;
 }
 
@@ -106,13 +106,13 @@ PyParser_Delete(parser_state *ps)
 /* PARSER STACK OPERATIONS */
 
 static int
-shift(stack *s, int type, char *str, int newstate, int lineno, int col_offset, 
-      int end_lineno, int end_col_offset) 
+shift(stack *s, int type, char *str, int newstate, int lineno, int col_offset,
+      int end_lineno, int end_col_offset)
 {
     int err;
     assert(!s_empty(s));
-    err = PyNode_AddChild(s->s_top->s_parent, type, str, lineno, col_offset, 
-                          end_lineno, end_col_offset); 
+    err = PyNode_AddChild(s->s_top->s_parent, type, str, lineno, col_offset,
+                          end_lineno, end_col_offset);
     if (err)
         return err;
     s->s_top->s_state = newstate;
@@ -120,15 +120,15 @@ shift(stack *s, int type, char *str, int newstate, int lineno, int col_offset,
 }
 
 static int
-push(stack *s, int type, const dfa *d, int newstate, int lineno, int col_offset, 
-     int end_lineno, int end_col_offset) 
+push(stack *s, int type, const dfa *d, int newstate, int lineno, int col_offset,
+     int end_lineno, int end_col_offset)
 {
     int err;
     node *n;
     n = s->s_top->s_parent;
     assert(!s_empty(s));
-    err = PyNode_AddChild(n, type, (char *)NULL, lineno, col_offset, 
-                          end_lineno, end_col_offset); 
+    err = PyNode_AddChild(n, type, (char *)NULL, lineno, col_offset,
+                          end_lineno, end_col_offset);
     if (err)
         return err;
     s->s_top->s_state = newstate;
@@ -145,7 +145,7 @@ classify(parser_state *ps, int type, const char *str)
     int n = g->g_ll.ll_nlabels;
 
     if (type == NAME) {
-        const label *l = g->g_ll.ll_label; 
+        const label *l = g->g_ll.ll_label;
         int i;
         for (i = n; i > 0; i--, l++) {
             if (l->lb_type != NAME || l->lb_str == NULL ||
@@ -169,7 +169,7 @@ classify(parser_state *ps, int type, const char *str)
     }
 
     {
-        const label *l = g->g_ll.ll_label; 
+        const label *l = g->g_ll.ll_label;
         int i;
         for (i = n; i > 0; i--, l++) {
             if (l->lb_type == type && l->lb_str == NULL) {
@@ -230,9 +230,9 @@ future_hack(parser_state *ps)
 
 int
 PyParser_AddToken(parser_state *ps, int type, char *str,
-                  int lineno, int col_offset, 
-                  int end_lineno, int end_col_offset, 
-                  int *expected_ret) 
+                  int lineno, int col_offset,
+                  int end_lineno, int end_col_offset,
+                  int *expected_ret)
 {
     int ilabel;
     int err;
@@ -247,7 +247,7 @@ PyParser_AddToken(parser_state *ps, int type, char *str,
     /* Loop until the token is shifted or an error occurred */
     for (;;) {
         /* Fetch the current dfa and state */
-        const dfa *d = ps->p_stack.s_top->s_dfa; 
+        const dfa *d = ps->p_stack.s_top->s_dfa;
         state *s = &d->d_state[ps->p_stack.s_top->s_state];
 
         D(printf(" DFA '%s', state %d:",
@@ -261,29 +261,29 @@ PyParser_AddToken(parser_state *ps, int type, char *str,
                     /* Push non-terminal */
                     int nt = (x >> 8) + NT_OFFSET;
                     int arrow = x & ((1<<7)-1);
-                    if (nt == func_body_suite && !(ps->p_flags & PyCF_TYPE_COMMENTS)) { 
-                        /* When parsing type comments is not requested, 
-                           we can provide better errors about bad indentation 
-                           by using 'suite' for the body of a funcdef */ 
-                        D(printf(" [switch func_body_suite to suite]")); 
-                        nt = suite; 
-                    } 
-                    const dfa *d1 = PyGrammar_FindDFA( 
+                    if (nt == func_body_suite && !(ps->p_flags & PyCF_TYPE_COMMENTS)) {
+                        /* When parsing type comments is not requested,
+                           we can provide better errors about bad indentation
+                           by using 'suite' for the body of a funcdef */
+                        D(printf(" [switch func_body_suite to suite]"));
+                        nt = suite;
+                    }
+                    const dfa *d1 = PyGrammar_FindDFA(
                         ps->p_grammar, nt);
                     if ((err = push(&ps->p_stack, nt, d1,
-                        arrow, lineno, col_offset, 
-                        end_lineno, end_col_offset)) > 0) { 
+                        arrow, lineno, col_offset,
+                        end_lineno, end_col_offset)) > 0) {
                         D(printf(" MemError: push\n"));
                         return err;
                     }
-                    D(printf(" Push '%s'\n", d1->d_name)); 
+                    D(printf(" Push '%s'\n", d1->d_name));
                     continue;
                 }
 
                 /* Shift the token */
                 if ((err = shift(&ps->p_stack, type, str,
-                                x, lineno, col_offset, 
-                                end_lineno, end_col_offset)) > 0) { 
+                                x, lineno, col_offset,
+                                end_lineno, end_col_offset)) > 0) {
                     D(printf(" MemError: shift.\n"));
                     return err;
                 }
diff --git a/contrib/tools/python3/src/Parser/parser.h b/contrib/tools/python3/src/Parser/parser.h
index 28cf6f3782..b16075e7f2 100644
--- a/contrib/tools/python3/src/Parser/parser.h
+++ b/contrib/tools/python3/src/Parser/parser.h
@@ -7,11 +7,11 @@ extern "C" {
 
 /* Parser interface */
 
-#define MAXSTACK 1700 
+#define MAXSTACK 1700
 
 typedef struct {
     int              s_state;       /* State in current DFA */
-    const dfa       *s_dfa;         /* Current DFA */ 
+    const dfa       *s_dfa;         /* Current DFA */
     struct _node    *s_parent;      /* Where to add next node */
 } stackentry;
 
@@ -32,17 +32,17 @@ typedef struct {
 
 parser_state *PyParser_New(grammar *g, int start);
 void PyParser_Delete(parser_state *ps);
-int PyParser_AddToken(parser_state *ps, int type, char *str, 
-                      int lineno, int col_offset, 
-                      int end_lineno, int end_col_offset, 
+int PyParser_AddToken(parser_state *ps, int type, char *str,
+                      int lineno, int col_offset,
+                      int end_lineno, int end_col_offset,
                       int *expected_ret);
 void PyGrammar_AddAccelerators(grammar *g);
 
- 
-#define showtree _Py_showtree 
-#define printtree _Py_printtree 
-#define dumptree _Py_dumptree 
- 
+
+#define showtree _Py_showtree
+#define printtree _Py_printtree
+#define dumptree _Py_dumptree
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/contrib/tools/python3/src/Parser/parsetok.c b/contrib/tools/python3/src/Parser/parsetok.c
index 1000887dbf..1ecb2c4a16 100644
--- a/contrib/tools/python3/src/Parser/parsetok.c
+++ b/contrib/tools/python3/src/Parser/parsetok.c
@@ -1,7 +1,7 @@
 
 /* Parser-tokenizer link implementation */
 
-#include "Python.h" 
+#include "Python.h"
 #include "tokenizer.h"
 #include "node.h"
 #include "grammar.h"
@@ -15,51 +15,51 @@
 static node *parsetok(struct tok_state *, grammar *, int, perrdetail *, int *);
 static int initerr(perrdetail *err_ret, PyObject * filename);
 
-typedef struct { 
-    struct { 
-        int lineno; 
-        char *comment; 
-    } *items; 
-    size_t size; 
-    size_t num_items; 
-} growable_comment_array; 
- 
-static int 
-growable_comment_array_init(growable_comment_array *arr, size_t initial_size) { 
-    assert(initial_size > 0); 
-    arr->items = malloc(initial_size * sizeof(*arr->items)); 
-    arr->size = initial_size; 
-    arr->num_items = 0; 
- 
-    return arr->items != NULL; 
-} 
- 
-static int 
-growable_comment_array_add(growable_comment_array *arr, int lineno, char *comment) { 
-    if (arr->num_items >= arr->size) { 
-        size_t new_size = arr->size * 2; 
-        void *new_items_array = realloc(arr->items, new_size * sizeof(*arr->items)); 
-        if (!new_items_array) { 
-            return 0; 
-        } 
-        arr->items = new_items_array; 
-        arr->size = new_size; 
-    } 
- 
-    arr->items[arr->num_items].lineno = lineno; 
-    arr->items[arr->num_items].comment = comment; 
-    arr->num_items++; 
-    return 1; 
-} 
- 
-static void 
-growable_comment_array_deallocate(growable_comment_array *arr) { 
-    for (unsigned i = 0; i < arr->num_items; i++) { 
-        PyObject_FREE(arr->items[i].comment); 
-    } 
-    free(arr->items); 
-} 
- 
+typedef struct {
+    struct {
+        int lineno;
+        char *comment;
+    } *items;
+    size_t size;
+    size_t num_items;
+} growable_comment_array;
+
+static int
+growable_comment_array_init(growable_comment_array *arr, size_t initial_size) {
+    assert(initial_size > 0);
+    arr->items = malloc(initial_size * sizeof(*arr->items));
+    arr->size = initial_size;
+    arr->num_items = 0;
+
+    return arr->items != NULL;
+}
+
+static int
+growable_comment_array_add(growable_comment_array *arr, int lineno, char *comment) {
+    if (arr->num_items >= arr->size) {
+        size_t new_size = arr->size * 2;
+        void *new_items_array = realloc(arr->items, new_size * sizeof(*arr->items));
+        if (!new_items_array) {
+            return 0;
+        }
+        arr->items = new_items_array;
+        arr->size = new_size;
+    }
+
+    arr->items[arr->num_items].lineno = lineno;
+    arr->items[arr->num_items].comment = comment;
+    arr->num_items++;
+    return 1;
+}
+
+static void
+growable_comment_array_deallocate(growable_comment_array *arr) {
+    for (unsigned i = 0; i < arr->num_items; i++) {
+        PyObject_FREE(arr->items[i].comment);
+    }
+    free(arr->items);
+}
+
 /* Parse input coming from a string.  Return error code, print some errors. */
 node *
 PyParser_ParseString(const char *s, grammar *g, int start, perrdetail *err_ret)
@@ -96,11 +96,11 @@ PyParser_ParseStringObject(const char *s, PyObject *filename,
     if (initerr(err_ret, filename) < 0)
         return NULL;
 
-    if (PySys_Audit("compile", "yO", s, err_ret->filename) < 0) { 
-        err_ret->error = E_ERROR; 
-        return NULL; 
-    } 
- 
+    if (PySys_Audit("compile", "yO", s, err_ret->filename) < 0) {
+        err_ret->error = E_ERROR;
+        return NULL;
+    }
+
     if (*flags & PyPARSE_IGNORE_COOKIE)
         tok = PyTokenizer_FromUTF8(s, exec_input);
     else
@@ -109,14 +109,14 @@ PyParser_ParseStringObject(const char *s, PyObject *filename,
         err_ret->error = PyErr_Occurred() ? E_DECODE : E_NOMEM;
         return NULL;
     }
-    if (*flags & PyPARSE_TYPE_COMMENTS) { 
-        tok->type_comments = 1; 
-    } 
+    if (*flags & PyPARSE_TYPE_COMMENTS) {
+        tok->type_comments = 1;
+    }
 
     Py_INCREF(err_ret->filename);
     tok->filename = err_ret->filename;
-    if (*flags & PyPARSE_ASYNC_HACKS) 
-        tok->async_hacks = 1; 
+    if (*flags & PyPARSE_ASYNC_HACKS)
+        tok->async_hacks = 1;
     return parsetok(tok, g, start, err_ret, flags);
 }
 
@@ -172,17 +172,17 @@ PyParser_ParseFileObject(FILE *fp, PyObject *filename,
     if (initerr(err_ret, filename) < 0)
         return NULL;
 
-    if (PySys_Audit("compile", "OO", Py_None, err_ret->filename) < 0) { 
-        return NULL; 
-    } 
- 
+    if (PySys_Audit("compile", "OO", Py_None, err_ret->filename) < 0) {
+        return NULL;
+    }
+
     if ((tok = PyTokenizer_FromFile(fp, enc, ps1, ps2)) == NULL) {
         err_ret->error = E_NOMEM;
         return NULL;
     }
-    if (*flags & PyPARSE_TYPE_COMMENTS) { 
-        tok->type_comments = 1; 
-    } 
+    if (*flags & PyPARSE_TYPE_COMMENTS) {
+        tok->type_comments = 1;
+    }
     Py_INCREF(err_ret->filename);
     tok->filename = err_ret->filename;
     return parsetok(tok, g, start, err_ret, flags);
@@ -219,39 +219,39 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
     parser_state *ps;
     node *n;
     int started = 0;
-    int col_offset, end_col_offset; 
-    growable_comment_array type_ignores; 
-
-    if (!growable_comment_array_init(&type_ignores, 10)) { 
-        err_ret->error = E_NOMEM; 
-        PyTokenizer_Free(tok); 
-        return NULL; 
-    } 
- 
+    int col_offset, end_col_offset;
+    growable_comment_array type_ignores;
+
+    if (!growable_comment_array_init(&type_ignores, 10)) {
+        err_ret->error = E_NOMEM;
+        PyTokenizer_Free(tok);
+        return NULL;
+    }
+
     if ((ps = PyParser_New(g, start)) == NULL) {
         err_ret->error = E_NOMEM;
-        growable_comment_array_deallocate(&type_ignores); 
+        growable_comment_array_deallocate(&type_ignores);
         PyTokenizer_Free(tok);
         return NULL;
     }
 #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
     if (*flags & PyPARSE_BARRY_AS_BDFL)
         ps->p_flags |= CO_FUTURE_BARRY_AS_BDFL;
-    if (*flags & PyPARSE_TYPE_COMMENTS) 
-        ps->p_flags |= PyCF_TYPE_COMMENTS; 
+    if (*flags & PyPARSE_TYPE_COMMENTS)
+        ps->p_flags |= PyCF_TYPE_COMMENTS;
 #endif
 
     for (;;) {
-        const char *a, *b; 
+        const char *a, *b;
         int type;
         size_t len;
         char *str;
-        col_offset = -1; 
-        int lineno; 
-        const char *line_start; 
+        col_offset = -1;
+        int lineno;
+        const char *line_start;
 
         type = PyTokenizer_Get(tok, &a, &b);
- 
+
         len = (a != NULL && b != NULL) ? b - a : 0;
         str = (char *) PyObject_MALLOC(len + 1);
         if (str == NULL) {
@@ -279,65 +279,65 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
             }
         }
 #endif
- 
-        /* Nodes of type STRING, especially multi line strings 
-           must be handled differently in order to get both 
-           the starting line number and the column offset right. 
-           (cf. issue 16806) */ 
-        lineno = type == STRING ? tok->first_lineno : tok->lineno; 
-        line_start = type == STRING ? tok->multi_line_start : tok->line_start; 
-        if (a != NULL && a >= line_start) { 
-            col_offset = Py_SAFE_DOWNCAST(a - line_start, 
+
+        /* Nodes of type STRING, especially multi line strings
+           must be handled differently in order to get both
+           the starting line number and the column offset right.
+           (cf. issue 16806) */
+        lineno = type == STRING ? tok->first_lineno : tok->lineno;
+        line_start = type == STRING ? tok->multi_line_start : tok->line_start;
+        if (a != NULL && a >= line_start) {
+            col_offset = Py_SAFE_DOWNCAST(a - line_start,
                                           intptr_t, int);
         }
         else {
             col_offset = -1;
         }
 
-        if (b != NULL && b >= tok->line_start) { 
-            end_col_offset = Py_SAFE_DOWNCAST(b - tok->line_start, 
-                                              intptr_t, int); 
-        } 
-        else { 
-            end_col_offset = -1; 
-        } 
- 
-        if (type == TYPE_IGNORE) { 
-            if (!growable_comment_array_add(&type_ignores, tok->lineno, str)) { 
-                err_ret->error = E_NOMEM; 
-                break; 
-            } 
-            continue; 
-        } 
- 
-        if (type == ERRORTOKEN) { 
-            err_ret->error = tok->done; 
-            break; 
-        } 
-        if (type == ENDMARKER && started) { 
-            type = NEWLINE; /* Add an extra newline */ 
-            started = 0; 
-            /* Add the right number of dedent tokens, 
-               except if a certain flag is given -- 
-               codeop.py uses this. */ 
-            if (tok->indent && 
-                !(*flags & PyPARSE_DONT_IMPLY_DEDENT)) 
-            { 
-                tok->pendin = -tok->indent; 
-                tok->indent = 0; 
-            } 
-        } 
-        else { 
-            started = 1; 
-        } 
- 
+        if (b != NULL && b >= tok->line_start) {
+            end_col_offset = Py_SAFE_DOWNCAST(b - tok->line_start,
+                                              intptr_t, int);
+        }
+        else {
+            end_col_offset = -1;
+        }
+
+        if (type == TYPE_IGNORE) {
+            if (!growable_comment_array_add(&type_ignores, tok->lineno, str)) {
+                err_ret->error = E_NOMEM;
+                break;
+            }
+            continue;
+        }
+
+        if (type == ERRORTOKEN) {
+            err_ret->error = tok->done;
+            break;
+        }
+        if (type == ENDMARKER && started) {
+            type = NEWLINE; /* Add an extra newline */
+            started = 0;
+            /* Add the right number of dedent tokens,
+               except if a certain flag is given --
+               codeop.py uses this. */
+            if (tok->indent &&
+                !(*flags & PyPARSE_DONT_IMPLY_DEDENT))
+            {
+                tok->pendin = -tok->indent;
+                tok->indent = 0;
+            }
+        }
+        else {
+            started = 1;
+        }
+
         if ((err_ret->error =
              PyParser_AddToken(ps, (int)type, str,
-                               lineno, col_offset, tok->lineno, end_col_offset, 
+                               lineno, col_offset, tok->lineno, end_col_offset,
                                &(err_ret->expected))) != E_OK) {
-            if (tok->done == E_EOF && !ISWHITESPACE(type)) { 
-                tok->done = E_SYNTAX; 
-            } 
+            if (tok->done == E_EOF && !ISWHITESPACE(type)) {
+                tok->done = E_SYNTAX;
+            }
             if (err_ret->error != E_DONE) {
                 PyObject_FREE(str);
                 err_ret->token = type;
@@ -350,36 +350,36 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
         n = ps->p_tree;
         ps->p_tree = NULL;
 
-        if (n->n_type == file_input) { 
-            /* Put type_ignore nodes in the ENDMARKER of file_input. */ 
-            int num; 
-            node *ch; 
-            size_t i; 
- 
-            num = NCH(n); 
-            ch = CHILD(n, num - 1); 
-            REQ(ch, ENDMARKER); 
- 
-            for (i = 0; i < type_ignores.num_items; i++) { 
-                int res = PyNode_AddChild(ch, TYPE_IGNORE, type_ignores.items[i].comment, 
-                                          type_ignores.items[i].lineno, 0, 
-                                          type_ignores.items[i].lineno, 0); 
-                if (res != 0) { 
-                    err_ret->error = res; 
-                    PyNode_Free(n); 
-                    n = NULL; 
-                    break; 
-                } 
-                type_ignores.items[i].comment = NULL; 
-            } 
-        } 
- 
+        if (n->n_type == file_input) {
+            /* Put type_ignore nodes in the ENDMARKER of file_input. */
+            int num;
+            node *ch;
+            size_t i;
+
+            num = NCH(n);
+            ch = CHILD(n, num - 1);
+            REQ(ch, ENDMARKER);
+
+            for (i = 0; i < type_ignores.num_items; i++) {
+                int res = PyNode_AddChild(ch, TYPE_IGNORE, type_ignores.items[i].comment,
+                                          type_ignores.items[i].lineno, 0,
+                                          type_ignores.items[i].lineno, 0);
+                if (res != 0) {
+                    err_ret->error = res;
+                    PyNode_Free(n);
+                    n = NULL;
+                    break;
+                }
+                type_ignores.items[i].comment = NULL;
+            }
+        }
+
         /* Check that the source for a single input statement really
            is a single statement by looking at what is left in the
            buffer after parsing.  Trailing whitespace and comments
            are OK.  */
-        if (err_ret->error == E_DONE && start == single_input) { 
-            const char *cur = tok->cur; 
+        if (err_ret->error == E_DONE && start == single_input) {
+            const char *cur = tok->cur;
             char c = *tok->cur;
 
             for (;;) {
@@ -405,8 +405,8 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
     else
         n = NULL;
 
-    growable_comment_array_deallocate(&type_ignores); 
- 
+    growable_comment_array_deallocate(&type_ignores);
+
 #ifdef PY_PARSER_REQUIRES_FUTURE_KEYWORD
     *flags = ps->p_flags;
 #endif
@@ -419,10 +419,10 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
         if (tok->buf != NULL) {
             size_t len;
             assert(tok->cur - tok->buf < INT_MAX);
-            /* if we've managed to parse a token, point the offset to its start, 
-             * else use the current reading position of the tokenizer 
-             */ 
-            err_ret->offset = col_offset != -1 ? col_offset + 1 : ((int)(tok->cur - tok->buf)); 
+            /* if we've managed to parse a token, point the offset to its start,
+             * else use the current reading position of the tokenizer
+             */
+            err_ret->offset = col_offset != -1 ? col_offset + 1 : ((int)(tok->cur - tok->buf));
             len = tok->inp - tok->buf;
             err_ret->text = (char *) PyObject_MALLOC(len + 1);
             if (err_ret->text != NULL) {
@@ -456,9 +456,9 @@ parsetok(struct tok_state *tok, grammar *g, int start, perrdetail *err_ret,
 done:
     PyTokenizer_Free(tok);
 
-    if (n != NULL) { 
-        _PyNode_FinalizeEndPos(n); 
-    } 
+    if (n != NULL) {
+        _PyNode_FinalizeEndPos(n);
+    }
     return n;
 }
 
diff --git a/contrib/tools/python3/src/Parser/pegen/parse.c b/contrib/tools/python3/src/Parser/pegen/parse.c
index c20f6c4007..105b0faa20 100644
--- a/contrib/tools/python3/src/Parser/pegen/parse.c
+++ b/contrib/tools/python3/src/Parser/pegen/parse.c
@@ -1,25594 +1,25594 @@
-// @generated by pegen.py from python.gram 
-#include "pegen.h" 
- 
-#if defined(Py_DEBUG) && defined(Py_BUILD_CORE) 
-extern int Py_DebugFlag; 
-#define D(x) if (Py_DebugFlag) x; 
-#else 
-#define D(x) 
-#endif 
- 
-# define MAXSTACK 6000 
-static const int n_keyword_lists = 15; 
-static KeywordToken *reserved_keywords[] = { 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) { 
-        {"if", 510}, 
-        {"in", 518}, 
-        {"as", 520}, 
-        {"is", 527}, 
-        {"or", 532}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) { 
-        {"del", 503}, 
-        {"try", 511}, 
-        {"for", 517}, 
-        {"def", 523}, 
-        {"not", 526}, 
-        {"and", 533}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) { 
-        {"pass", 502}, 
-        {"from", 514}, 
-        {"elif", 515}, 
-        {"else", 516}, 
-        {"with", 519}, 
-        {"True", 528}, 
-        {"None", 530}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) { 
-        {"raise", 501}, 
-        {"yield", 504}, 
-        {"break", 506}, 
-        {"while", 512}, 
-        {"class", 524}, 
-        {"False", 529}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) { 
-        {"return", 500}, 
-        {"assert", 505}, 
-        {"global", 508}, 
-        {"import", 513}, 
-        {"except", 521}, 
-        {"lambda", 525}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) { 
-        {"finally", 522}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) { 
-        {"continue", 507}, 
-        {"nonlocal", 509}, 
-        {NULL, -1}, 
-    }, 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) {{NULL, -1}}, 
-    (KeywordToken[]) { 
-        {"__peg_parser__", 531}, 
-        {NULL, -1}, 
-    }, 
-}; 
-#define file_type 1000 
-#define interactive_type 1001 
-#define eval_type 1002 
-#define func_type_type 1003 
-#define fstring_type 1004 
-#define type_expressions_type 1005 
-#define statements_type 1006 
-#define statement_type 1007 
-#define statement_newline_type 1008 
-#define simple_stmt_type 1009 
-#define small_stmt_type 1010 
-#define compound_stmt_type 1011 
-#define assignment_type 1012 
-#define augassign_type 1013 
-#define global_stmt_type 1014 
-#define nonlocal_stmt_type 1015 
-#define yield_stmt_type 1016 
-#define assert_stmt_type 1017 
-#define del_stmt_type 1018 
-#define import_stmt_type 1019 
-#define import_name_type 1020 
-#define import_from_type 1021 
-#define import_from_targets_type 1022 
-#define import_from_as_names_type 1023 
-#define import_from_as_name_type 1024 
-#define dotted_as_names_type 1025 
-#define dotted_as_name_type 1026 
-#define dotted_name_type 1027  // Left-recursive 
-#define if_stmt_type 1028 
-#define elif_stmt_type 1029 
-#define else_block_type 1030 
-#define while_stmt_type 1031 
-#define for_stmt_type 1032 
-#define with_stmt_type 1033 
-#define with_item_type 1034 
-#define try_stmt_type 1035 
-#define except_block_type 1036 
-#define finally_block_type 1037 
-#define return_stmt_type 1038 
-#define raise_stmt_type 1039 
-#define function_def_type 1040 
-#define function_def_raw_type 1041 
-#define func_type_comment_type 1042 
-#define params_type 1043 
-#define parameters_type 1044 
-#define slash_no_default_type 1045 
-#define slash_with_default_type 1046 
-#define star_etc_type 1047 
-#define kwds_type 1048 
-#define param_no_default_type 1049 
-#define param_with_default_type 1050 
-#define param_maybe_default_type 1051 
-#define param_type 1052 
-#define annotation_type 1053 
-#define default_type 1054 
-#define decorators_type 1055 
-#define class_def_type 1056 
-#define class_def_raw_type 1057 
-#define block_type 1058 
-#define star_expressions_type 1059 
-#define star_expression_type 1060 
-#define star_named_expressions_type 1061 
-#define star_named_expression_type 1062 
-#define named_expression_type 1063 
-#define annotated_rhs_type 1064 
-#define expressions_type 1065 
-#define expression_type 1066 
-#define lambdef_type 1067 
-#define lambda_params_type 1068 
-#define lambda_parameters_type 1069 
-#define lambda_slash_no_default_type 1070 
-#define lambda_slash_with_default_type 1071 
-#define lambda_star_etc_type 1072 
-#define lambda_kwds_type 1073 
-#define lambda_param_no_default_type 1074 
-#define lambda_param_with_default_type 1075 
-#define lambda_param_maybe_default_type 1076 
-#define lambda_param_type 1077 
-#define disjunction_type 1078 
-#define conjunction_type 1079 
-#define inversion_type 1080 
-#define comparison_type 1081 
-#define compare_op_bitwise_or_pair_type 1082 
-#define eq_bitwise_or_type 1083 
-#define noteq_bitwise_or_type 1084 
-#define lte_bitwise_or_type 1085 
-#define lt_bitwise_or_type 1086 
-#define gte_bitwise_or_type 1087 
-#define gt_bitwise_or_type 1088 
-#define notin_bitwise_or_type 1089 
-#define in_bitwise_or_type 1090 
-#define isnot_bitwise_or_type 1091 
-#define is_bitwise_or_type 1092 
-#define bitwise_or_type 1093  // Left-recursive 
-#define bitwise_xor_type 1094  // Left-recursive 
-#define bitwise_and_type 1095  // Left-recursive 
-#define shift_expr_type 1096  // Left-recursive 
-#define sum_type 1097  // Left-recursive 
-#define term_type 1098  // Left-recursive 
-#define factor_type 1099 
-#define power_type 1100 
-#define await_primary_type 1101 
-#define primary_type 1102  // Left-recursive 
-#define slices_type 1103 
-#define slice_type 1104 
-#define atom_type 1105 
-#define strings_type 1106 
-#define list_type 1107 
-#define listcomp_type 1108 
-#define tuple_type 1109 
-#define group_type 1110 
-#define genexp_type 1111 
-#define set_type 1112 
-#define setcomp_type 1113 
-#define dict_type 1114 
-#define dictcomp_type 1115 
-#define double_starred_kvpairs_type 1116 
-#define double_starred_kvpair_type 1117 
-#define kvpair_type 1118 
-#define for_if_clauses_type 1119 
-#define for_if_clause_type 1120 
-#define yield_expr_type 1121 
-#define arguments_type 1122 
-#define args_type 1123 
-#define kwargs_type 1124 
-#define starred_expression_type 1125 
-#define kwarg_or_starred_type 1126 
-#define kwarg_or_double_starred_type 1127 
-#define star_targets_type 1128 
-#define star_targets_list_seq_type 1129 
-#define star_targets_tuple_seq_type 1130 
-#define star_target_type 1131 
-#define target_with_star_atom_type 1132 
-#define star_atom_type 1133 
-#define single_target_type 1134 
-#define single_subscript_attribute_target_type 1135 
-#define del_targets_type 1136 
-#define del_target_type 1137 
-#define del_t_atom_type 1138 
-#define t_primary_type 1139  // Left-recursive 
-#define t_lookahead_type 1140 
-#define invalid_arguments_type 1141 
-#define invalid_kwarg_type 1142 
-#define invalid_named_expression_type 1143 
-#define invalid_assignment_type 1144 
-#define invalid_ann_assign_target_type 1145 
-#define invalid_del_stmt_type 1146 
-#define invalid_block_type 1147 
-#define invalid_primary_type 1148  // Left-recursive 
-#define invalid_comprehension_type 1149 
-#define invalid_dict_comprehension_type 1150 
-#define invalid_parameters_type 1151 
-#define invalid_lambda_parameters_type 1152 
-#define invalid_star_etc_type 1153 
-#define invalid_lambda_star_etc_type 1154 
-#define invalid_double_type_comments_type 1155 
-#define invalid_with_item_type 1156 
-#define invalid_for_target_type 1157 
-#define invalid_group_type 1158 
-#define invalid_import_from_targets_type 1159 
-#define _loop0_1_type 1160 
-#define _loop0_2_type 1161 
-#define _loop0_4_type 1162 
-#define _gather_3_type 1163 
-#define _loop0_6_type 1164 
-#define _gather_5_type 1165 
-#define _loop0_8_type 1166 
-#define _gather_7_type 1167 
-#define _loop0_10_type 1168 
-#define _gather_9_type 1169 
-#define _loop1_11_type 1170 
-#define _loop0_13_type 1171 
-#define _gather_12_type 1172 
-#define _tmp_14_type 1173 
-#define _tmp_15_type 1174 
-#define _tmp_16_type 1175 
-#define _tmp_17_type 1176 
-#define _tmp_18_type 1177 
-#define _tmp_19_type 1178 
-#define _tmp_20_type 1179 
-#define _tmp_21_type 1180 
-#define _loop1_22_type 1181 
-#define _tmp_23_type 1182 
-#define _tmp_24_type 1183 
-#define _loop0_26_type 1184 
-#define _gather_25_type 1185 
-#define _loop0_28_type 1186 
-#define _gather_27_type 1187 
-#define _tmp_29_type 1188 
-#define _tmp_30_type 1189 
-#define _loop0_31_type 1190 
-#define _loop1_32_type 1191 
-#define _loop0_34_type 1192 
-#define _gather_33_type 1193 
-#define _tmp_35_type 1194 
-#define _loop0_37_type 1195 
-#define _gather_36_type 1196 
-#define _tmp_38_type 1197 
-#define _loop0_40_type 1198 
-#define _gather_39_type 1199 
-#define _loop0_42_type 1200 
-#define _gather_41_type 1201 
-#define _loop0_44_type 1202 
-#define _gather_43_type 1203 
-#define _loop0_46_type 1204 
-#define _gather_45_type 1205 
-#define _tmp_47_type 1206 
-#define _loop1_48_type 1207 
-#define _tmp_49_type 1208 
-#define _tmp_50_type 1209 
-#define _tmp_51_type 1210 
-#define _tmp_52_type 1211 
-#define _tmp_53_type 1212 
-#define _loop0_54_type 1213 
-#define _loop0_55_type 1214 
-#define _loop0_56_type 1215 
-#define _loop1_57_type 1216 
-#define _loop0_58_type 1217 
-#define _loop1_59_type 1218 
-#define _loop1_60_type 1219 
-#define _loop1_61_type 1220 
-#define _loop0_62_type 1221 
-#define _loop1_63_type 1222 
-#define _loop0_64_type 1223 
-#define _loop1_65_type 1224 
-#define _loop0_66_type 1225 
-#define _loop1_67_type 1226 
-#define _loop1_68_type 1227 
-#define _tmp_69_type 1228 
-#define _loop1_70_type 1229 
-#define _loop0_72_type 1230 
-#define _gather_71_type 1231 
-#define _loop1_73_type 1232 
-#define _loop0_74_type 1233 
-#define _loop0_75_type 1234 
-#define _loop0_76_type 1235 
-#define _loop1_77_type 1236 
-#define _loop0_78_type 1237 
-#define _loop1_79_type 1238 
-#define _loop1_80_type 1239 
-#define _loop1_81_type 1240 
-#define _loop0_82_type 1241 
-#define _loop1_83_type 1242 
-#define _loop0_84_type 1243 
-#define _loop1_85_type 1244 
-#define _loop0_86_type 1245 
-#define _loop1_87_type 1246 
-#define _loop1_88_type 1247 
-#define _loop1_89_type 1248 
-#define _loop1_90_type 1249 
-#define _tmp_91_type 1250 
-#define _loop0_93_type 1251 
-#define _gather_92_type 1252 
-#define _tmp_94_type 1253 
-#define _tmp_95_type 1254 
-#define _tmp_96_type 1255 
-#define _tmp_97_type 1256 
-#define _loop1_98_type 1257 
-#define _tmp_99_type 1258 
-#define _tmp_100_type 1259 
-#define _loop0_102_type 1260 
-#define _gather_101_type 1261 
-#define _loop1_103_type 1262 
-#define _loop0_104_type 1263 
-#define _loop0_105_type 1264 
-#define _loop0_107_type 1265 
-#define _gather_106_type 1266 
-#define _tmp_108_type 1267 
-#define _loop0_110_type 1268 
-#define _gather_109_type 1269 
-#define _loop0_112_type 1270 
-#define _gather_111_type 1271 
-#define _loop0_114_type 1272 
-#define _gather_113_type 1273 
-#define _loop0_116_type 1274 
-#define _gather_115_type 1275 
-#define _loop0_117_type 1276 
-#define _loop0_119_type 1277 
-#define _gather_118_type 1278 
-#define _loop1_120_type 1279 
-#define _tmp_121_type 1280 
-#define _loop0_123_type 1281 
-#define _gather_122_type 1282 
-#define _tmp_124_type 1283 
-#define _tmp_125_type 1284 
-#define _loop0_126_type 1285 
-#define _loop0_127_type 1286 
-#define _loop0_128_type 1287 
-#define _tmp_129_type 1288 
-#define _tmp_130_type 1289 
-#define _loop0_131_type 1290 
-#define _tmp_132_type 1291 
-#define _loop0_133_type 1292 
-#define _tmp_134_type 1293 
-#define _tmp_135_type 1294 
-#define _tmp_136_type 1295 
-#define _tmp_137_type 1296 
-#define _tmp_138_type 1297 
-#define _tmp_139_type 1298 
-#define _tmp_140_type 1299 
-#define _tmp_141_type 1300 
-#define _tmp_142_type 1301 
-#define _tmp_143_type 1302 
-#define _tmp_144_type 1303 
-#define _tmp_145_type 1304 
-#define _tmp_146_type 1305 
-#define _tmp_147_type 1306 
-#define _tmp_148_type 1307 
-#define _tmp_149_type 1308 
-#define _tmp_150_type 1309 
-#define _tmp_151_type 1310 
-#define _loop1_152_type 1311 
-#define _loop1_153_type 1312 
-#define _tmp_154_type 1313 
-#define _tmp_155_type 1314 
- 
-static mod_ty file_rule(Parser *p); 
-static mod_ty interactive_rule(Parser *p); 
-static mod_ty eval_rule(Parser *p); 
-static mod_ty func_type_rule(Parser *p); 
-static expr_ty fstring_rule(Parser *p); 
-static asdl_seq* type_expressions_rule(Parser *p); 
-static asdl_seq* statements_rule(Parser *p); 
-static asdl_seq* statement_rule(Parser *p); 
-static asdl_seq* statement_newline_rule(Parser *p); 
-static asdl_seq* simple_stmt_rule(Parser *p); 
-static stmt_ty small_stmt_rule(Parser *p); 
-static stmt_ty compound_stmt_rule(Parser *p); 
-static stmt_ty assignment_rule(Parser *p); 
-static AugOperator* augassign_rule(Parser *p); 
-static stmt_ty global_stmt_rule(Parser *p); 
-static stmt_ty nonlocal_stmt_rule(Parser *p); 
-static stmt_ty yield_stmt_rule(Parser *p); 
-static stmt_ty assert_stmt_rule(Parser *p); 
-static stmt_ty del_stmt_rule(Parser *p); 
-static stmt_ty import_stmt_rule(Parser *p); 
-static stmt_ty import_name_rule(Parser *p); 
-static stmt_ty import_from_rule(Parser *p); 
-static asdl_seq* import_from_targets_rule(Parser *p); 
-static asdl_seq* import_from_as_names_rule(Parser *p); 
-static alias_ty import_from_as_name_rule(Parser *p); 
-static asdl_seq* dotted_as_names_rule(Parser *p); 
-static alias_ty dotted_as_name_rule(Parser *p); 
-static expr_ty dotted_name_rule(Parser *p); 
-static stmt_ty if_stmt_rule(Parser *p); 
-static stmt_ty elif_stmt_rule(Parser *p); 
-static asdl_seq* else_block_rule(Parser *p); 
-static stmt_ty while_stmt_rule(Parser *p); 
-static stmt_ty for_stmt_rule(Parser *p); 
-static stmt_ty with_stmt_rule(Parser *p); 
-static withitem_ty with_item_rule(Parser *p); 
-static stmt_ty try_stmt_rule(Parser *p); 
-static excepthandler_ty except_block_rule(Parser *p); 
-static asdl_seq* finally_block_rule(Parser *p); 
-static stmt_ty return_stmt_rule(Parser *p); 
-static stmt_ty raise_stmt_rule(Parser *p); 
-static stmt_ty function_def_rule(Parser *p); 
-static stmt_ty function_def_raw_rule(Parser *p); 
-static Token* func_type_comment_rule(Parser *p); 
-static arguments_ty params_rule(Parser *p); 
-static arguments_ty parameters_rule(Parser *p); 
-static asdl_seq* slash_no_default_rule(Parser *p); 
-static SlashWithDefault* slash_with_default_rule(Parser *p); 
-static StarEtc* star_etc_rule(Parser *p); 
-static arg_ty kwds_rule(Parser *p); 
-static arg_ty param_no_default_rule(Parser *p); 
-static NameDefaultPair* param_with_default_rule(Parser *p); 
-static NameDefaultPair* param_maybe_default_rule(Parser *p); 
-static arg_ty param_rule(Parser *p); 
-static expr_ty annotation_rule(Parser *p); 
-static expr_ty default_rule(Parser *p); 
-static asdl_seq* decorators_rule(Parser *p); 
-static stmt_ty class_def_rule(Parser *p); 
-static stmt_ty class_def_raw_rule(Parser *p); 
-static asdl_seq* block_rule(Parser *p); 
-static expr_ty star_expressions_rule(Parser *p); 
-static expr_ty star_expression_rule(Parser *p); 
-static asdl_seq* star_named_expressions_rule(Parser *p); 
-static expr_ty star_named_expression_rule(Parser *p); 
-static expr_ty named_expression_rule(Parser *p); 
-static expr_ty annotated_rhs_rule(Parser *p); 
-static expr_ty expressions_rule(Parser *p); 
-static expr_ty expression_rule(Parser *p); 
-static expr_ty lambdef_rule(Parser *p); 
-static arguments_ty lambda_params_rule(Parser *p); 
-static arguments_ty lambda_parameters_rule(Parser *p); 
-static asdl_seq* lambda_slash_no_default_rule(Parser *p); 
-static SlashWithDefault* lambda_slash_with_default_rule(Parser *p); 
-static StarEtc* lambda_star_etc_rule(Parser *p); 
-static arg_ty lambda_kwds_rule(Parser *p); 
-static arg_ty lambda_param_no_default_rule(Parser *p); 
-static NameDefaultPair* lambda_param_with_default_rule(Parser *p); 
-static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p); 
-static arg_ty lambda_param_rule(Parser *p); 
-static expr_ty disjunction_rule(Parser *p); 
-static expr_ty conjunction_rule(Parser *p); 
-static expr_ty inversion_rule(Parser *p); 
-static expr_ty comparison_rule(Parser *p); 
-static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p); 
-static CmpopExprPair* eq_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* noteq_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* lte_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* lt_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* gte_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* gt_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* notin_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* in_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* isnot_bitwise_or_rule(Parser *p); 
-static CmpopExprPair* is_bitwise_or_rule(Parser *p); 
-static expr_ty bitwise_or_rule(Parser *p); 
-static expr_ty bitwise_xor_rule(Parser *p); 
-static expr_ty bitwise_and_rule(Parser *p); 
-static expr_ty shift_expr_rule(Parser *p); 
-static expr_ty sum_rule(Parser *p); 
-static expr_ty term_rule(Parser *p); 
-static expr_ty factor_rule(Parser *p); 
-static expr_ty power_rule(Parser *p); 
-static expr_ty await_primary_rule(Parser *p); 
-static expr_ty primary_rule(Parser *p); 
-static expr_ty slices_rule(Parser *p); 
-static expr_ty slice_rule(Parser *p); 
-static expr_ty atom_rule(Parser *p); 
-static expr_ty strings_rule(Parser *p); 
-static expr_ty list_rule(Parser *p); 
-static expr_ty listcomp_rule(Parser *p); 
-static expr_ty tuple_rule(Parser *p); 
-static expr_ty group_rule(Parser *p); 
-static expr_ty genexp_rule(Parser *p); 
-static expr_ty set_rule(Parser *p); 
-static expr_ty setcomp_rule(Parser *p); 
-static expr_ty dict_rule(Parser *p); 
-static expr_ty dictcomp_rule(Parser *p); 
-static asdl_seq* double_starred_kvpairs_rule(Parser *p); 
-static KeyValuePair* double_starred_kvpair_rule(Parser *p); 
-static KeyValuePair* kvpair_rule(Parser *p); 
-static asdl_seq* for_if_clauses_rule(Parser *p); 
-static comprehension_ty for_if_clause_rule(Parser *p); 
-static expr_ty yield_expr_rule(Parser *p); 
-static expr_ty arguments_rule(Parser *p); 
-static expr_ty args_rule(Parser *p); 
-static asdl_seq* kwargs_rule(Parser *p); 
-static expr_ty starred_expression_rule(Parser *p); 
-static KeywordOrStarred* kwarg_or_starred_rule(Parser *p); 
-static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p); 
-static expr_ty star_targets_rule(Parser *p); 
-static asdl_seq* star_targets_list_seq_rule(Parser *p); 
-static asdl_seq* star_targets_tuple_seq_rule(Parser *p); 
-static expr_ty star_target_rule(Parser *p); 
-static expr_ty target_with_star_atom_rule(Parser *p); 
-static expr_ty star_atom_rule(Parser *p); 
-static expr_ty single_target_rule(Parser *p); 
-static expr_ty single_subscript_attribute_target_rule(Parser *p); 
-static asdl_seq* del_targets_rule(Parser *p); 
-static expr_ty del_target_rule(Parser *p); 
-static expr_ty del_t_atom_rule(Parser *p); 
-static expr_ty t_primary_rule(Parser *p); 
-static void *t_lookahead_rule(Parser *p); 
-static void *invalid_arguments_rule(Parser *p); 
-static void *invalid_kwarg_rule(Parser *p); 
-static void *invalid_named_expression_rule(Parser *p); 
-static void *invalid_assignment_rule(Parser *p); 
-static expr_ty invalid_ann_assign_target_rule(Parser *p); 
-static void *invalid_del_stmt_rule(Parser *p); 
-static void *invalid_block_rule(Parser *p); 
-static void *invalid_primary_rule(Parser *p); 
-static void *invalid_comprehension_rule(Parser *p); 
-static void *invalid_dict_comprehension_rule(Parser *p); 
-static void *invalid_parameters_rule(Parser *p); 
-static void *invalid_lambda_parameters_rule(Parser *p); 
-static void *invalid_star_etc_rule(Parser *p); 
-static void *invalid_lambda_star_etc_rule(Parser *p); 
-static void *invalid_double_type_comments_rule(Parser *p); 
-static void *invalid_with_item_rule(Parser *p); 
-static void *invalid_for_target_rule(Parser *p); 
-static void *invalid_group_rule(Parser *p); 
-static void *invalid_import_from_targets_rule(Parser *p); 
-static asdl_seq *_loop0_1_rule(Parser *p); 
-static asdl_seq *_loop0_2_rule(Parser *p); 
-static asdl_seq *_loop0_4_rule(Parser *p); 
-static asdl_seq *_gather_3_rule(Parser *p); 
-static asdl_seq *_loop0_6_rule(Parser *p); 
-static asdl_seq *_gather_5_rule(Parser *p); 
-static asdl_seq *_loop0_8_rule(Parser *p); 
-static asdl_seq *_gather_7_rule(Parser *p); 
-static asdl_seq *_loop0_10_rule(Parser *p); 
-static asdl_seq *_gather_9_rule(Parser *p); 
-static asdl_seq *_loop1_11_rule(Parser *p); 
-static asdl_seq *_loop0_13_rule(Parser *p); 
-static asdl_seq *_gather_12_rule(Parser *p); 
-static void *_tmp_14_rule(Parser *p); 
-static void *_tmp_15_rule(Parser *p); 
-static void *_tmp_16_rule(Parser *p); 
-static void *_tmp_17_rule(Parser *p); 
-static void *_tmp_18_rule(Parser *p); 
-static void *_tmp_19_rule(Parser *p); 
-static void *_tmp_20_rule(Parser *p); 
-static void *_tmp_21_rule(Parser *p); 
-static asdl_seq *_loop1_22_rule(Parser *p); 
-static void *_tmp_23_rule(Parser *p); 
-static void *_tmp_24_rule(Parser *p); 
-static asdl_seq *_loop0_26_rule(Parser *p); 
-static asdl_seq *_gather_25_rule(Parser *p); 
-static asdl_seq *_loop0_28_rule(Parser *p); 
-static asdl_seq *_gather_27_rule(Parser *p); 
-static void *_tmp_29_rule(Parser *p); 
-static void *_tmp_30_rule(Parser *p); 
-static asdl_seq *_loop0_31_rule(Parser *p); 
-static asdl_seq *_loop1_32_rule(Parser *p); 
-static asdl_seq *_loop0_34_rule(Parser *p); 
-static asdl_seq *_gather_33_rule(Parser *p); 
-static void *_tmp_35_rule(Parser *p); 
-static asdl_seq *_loop0_37_rule(Parser *p); 
-static asdl_seq *_gather_36_rule(Parser *p); 
-static void *_tmp_38_rule(Parser *p); 
-static asdl_seq *_loop0_40_rule(Parser *p); 
-static asdl_seq *_gather_39_rule(Parser *p); 
-static asdl_seq *_loop0_42_rule(Parser *p); 
-static asdl_seq *_gather_41_rule(Parser *p); 
-static asdl_seq *_loop0_44_rule(Parser *p); 
-static asdl_seq *_gather_43_rule(Parser *p); 
-static asdl_seq *_loop0_46_rule(Parser *p); 
-static asdl_seq *_gather_45_rule(Parser *p); 
-static void *_tmp_47_rule(Parser *p); 
-static asdl_seq *_loop1_48_rule(Parser *p); 
-static void *_tmp_49_rule(Parser *p); 
-static void *_tmp_50_rule(Parser *p); 
-static void *_tmp_51_rule(Parser *p); 
-static void *_tmp_52_rule(Parser *p); 
-static void *_tmp_53_rule(Parser *p); 
-static asdl_seq *_loop0_54_rule(Parser *p); 
-static asdl_seq *_loop0_55_rule(Parser *p); 
-static asdl_seq *_loop0_56_rule(Parser *p); 
-static asdl_seq *_loop1_57_rule(Parser *p); 
-static asdl_seq *_loop0_58_rule(Parser *p); 
-static asdl_seq *_loop1_59_rule(Parser *p); 
-static asdl_seq *_loop1_60_rule(Parser *p); 
-static asdl_seq *_loop1_61_rule(Parser *p); 
-static asdl_seq *_loop0_62_rule(Parser *p); 
-static asdl_seq *_loop1_63_rule(Parser *p); 
-static asdl_seq *_loop0_64_rule(Parser *p); 
-static asdl_seq *_loop1_65_rule(Parser *p); 
-static asdl_seq *_loop0_66_rule(Parser *p); 
-static asdl_seq *_loop1_67_rule(Parser *p); 
-static asdl_seq *_loop1_68_rule(Parser *p); 
-static void *_tmp_69_rule(Parser *p); 
-static asdl_seq *_loop1_70_rule(Parser *p); 
-static asdl_seq *_loop0_72_rule(Parser *p); 
-static asdl_seq *_gather_71_rule(Parser *p); 
-static asdl_seq *_loop1_73_rule(Parser *p); 
-static asdl_seq *_loop0_74_rule(Parser *p); 
-static asdl_seq *_loop0_75_rule(Parser *p); 
-static asdl_seq *_loop0_76_rule(Parser *p); 
-static asdl_seq *_loop1_77_rule(Parser *p); 
-static asdl_seq *_loop0_78_rule(Parser *p); 
-static asdl_seq *_loop1_79_rule(Parser *p); 
-static asdl_seq *_loop1_80_rule(Parser *p); 
-static asdl_seq *_loop1_81_rule(Parser *p); 
-static asdl_seq *_loop0_82_rule(Parser *p); 
-static asdl_seq *_loop1_83_rule(Parser *p); 
-static asdl_seq *_loop0_84_rule(Parser *p); 
-static asdl_seq *_loop1_85_rule(Parser *p); 
-static asdl_seq *_loop0_86_rule(Parser *p); 
-static asdl_seq *_loop1_87_rule(Parser *p); 
-static asdl_seq *_loop1_88_rule(Parser *p); 
-static asdl_seq *_loop1_89_rule(Parser *p); 
-static asdl_seq *_loop1_90_rule(Parser *p); 
-static void *_tmp_91_rule(Parser *p); 
-static asdl_seq *_loop0_93_rule(Parser *p); 
-static asdl_seq *_gather_92_rule(Parser *p); 
-static void *_tmp_94_rule(Parser *p); 
-static void *_tmp_95_rule(Parser *p); 
-static void *_tmp_96_rule(Parser *p); 
-static void *_tmp_97_rule(Parser *p); 
-static asdl_seq *_loop1_98_rule(Parser *p); 
-static void *_tmp_99_rule(Parser *p); 
-static void *_tmp_100_rule(Parser *p); 
-static asdl_seq *_loop0_102_rule(Parser *p); 
-static asdl_seq *_gather_101_rule(Parser *p); 
-static asdl_seq *_loop1_103_rule(Parser *p); 
-static asdl_seq *_loop0_104_rule(Parser *p); 
-static asdl_seq *_loop0_105_rule(Parser *p); 
-static asdl_seq *_loop0_107_rule(Parser *p); 
-static asdl_seq *_gather_106_rule(Parser *p); 
-static void *_tmp_108_rule(Parser *p); 
-static asdl_seq *_loop0_110_rule(Parser *p); 
-static asdl_seq *_gather_109_rule(Parser *p); 
-static asdl_seq *_loop0_112_rule(Parser *p); 
-static asdl_seq *_gather_111_rule(Parser *p); 
-static asdl_seq *_loop0_114_rule(Parser *p); 
-static asdl_seq *_gather_113_rule(Parser *p); 
-static asdl_seq *_loop0_116_rule(Parser *p); 
-static asdl_seq *_gather_115_rule(Parser *p); 
-static asdl_seq *_loop0_117_rule(Parser *p); 
-static asdl_seq *_loop0_119_rule(Parser *p); 
-static asdl_seq *_gather_118_rule(Parser *p); 
-static asdl_seq *_loop1_120_rule(Parser *p); 
-static void *_tmp_121_rule(Parser *p); 
-static asdl_seq *_loop0_123_rule(Parser *p); 
-static asdl_seq *_gather_122_rule(Parser *p); 
-static void *_tmp_124_rule(Parser *p); 
-static void *_tmp_125_rule(Parser *p); 
-static asdl_seq *_loop0_126_rule(Parser *p); 
-static asdl_seq *_loop0_127_rule(Parser *p); 
-static asdl_seq *_loop0_128_rule(Parser *p); 
-static void *_tmp_129_rule(Parser *p); 
-static void *_tmp_130_rule(Parser *p); 
-static asdl_seq *_loop0_131_rule(Parser *p); 
-static void *_tmp_132_rule(Parser *p); 
-static asdl_seq *_loop0_133_rule(Parser *p); 
-static void *_tmp_134_rule(Parser *p); 
-static void *_tmp_135_rule(Parser *p); 
-static void *_tmp_136_rule(Parser *p); 
-static void *_tmp_137_rule(Parser *p); 
-static void *_tmp_138_rule(Parser *p); 
-static void *_tmp_139_rule(Parser *p); 
-static void *_tmp_140_rule(Parser *p); 
-static void *_tmp_141_rule(Parser *p); 
-static void *_tmp_142_rule(Parser *p); 
-static void *_tmp_143_rule(Parser *p); 
-static void *_tmp_144_rule(Parser *p); 
-static void *_tmp_145_rule(Parser *p); 
-static void *_tmp_146_rule(Parser *p); 
-static void *_tmp_147_rule(Parser *p); 
-static void *_tmp_148_rule(Parser *p); 
-static void *_tmp_149_rule(Parser *p); 
-static void *_tmp_150_rule(Parser *p); 
-static void *_tmp_151_rule(Parser *p); 
-static asdl_seq *_loop1_152_rule(Parser *p); 
-static asdl_seq *_loop1_153_rule(Parser *p); 
-static void *_tmp_154_rule(Parser *p); 
-static void *_tmp_155_rule(Parser *p); 
- 
- 
-// file: statements? $ 
-static mod_ty 
-file_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    mod_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // statements? $ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $")); 
-        void *a; 
-        Token * endmarker_var; 
-        if ( 
-            (a = statements_rule(p), !p->error_indicator)  // statements? 
-            && 
-            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $")); 
-            _res = _PyPegen_make_module ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// interactive: statement_newline 
-static mod_ty 
-interactive_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    mod_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // statement_newline 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline")); 
-        asdl_seq* a; 
-        if ( 
-            (a = statement_newline_rule(p))  // statement_newline 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline")); 
-            _res = Interactive ( a , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// eval: expressions NEWLINE* $ 
-static mod_ty 
-eval_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    mod_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // expressions NEWLINE* $ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $")); 
-        asdl_seq * _loop0_1_var; 
-        expr_ty a; 
-        Token * endmarker_var; 
-        if ( 
-            (a = expressions_rule(p))  // expressions 
-            && 
-            (_loop0_1_var = _loop0_1_rule(p))  // NEWLINE* 
-            && 
-            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $")); 
-            _res = Expression ( a , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// func_type: '(' type_expressions? ')' '->' expression NEWLINE* $ 
-static mod_ty 
-func_type_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    mod_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' type_expressions? ')' '->' expression NEWLINE* $ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        asdl_seq * _loop0_2_var; 
-        void *a; 
-        expr_ty b; 
-        Token * endmarker_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = type_expressions_rule(p), !p->error_indicator)  // type_expressions? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 51))  // token='->' 
-            && 
-            (b = expression_rule(p))  // expression 
-            && 
-            (_loop0_2_var = _loop0_2_rule(p))  // NEWLINE* 
-            && 
-            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $")); 
-            _res = FunctionType ( a , b , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s func_type[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// fstring: star_expressions 
-static expr_ty 
-fstring_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-        expr_ty star_expressions_var; 
-        if ( 
-            (star_expressions_var = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-            _res = star_expressions_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s fstring[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// type_expressions: 
-//     | ','.expression+ ',' '*' expression ',' '**' expression 
-//     | ','.expression+ ',' '*' expression 
-//     | ','.expression+ ',' '**' expression 
-//     | '*' expression ',' '**' expression 
-//     | '*' expression 
-//     | '**' expression 
-//     | ','.expression+ 
-static asdl_seq* 
-type_expressions_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.expression+ ',' '*' expression ',' '**' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        Token * _literal_3; 
-        asdl_seq * a; 
-        expr_ty b; 
-        expr_ty c; 
-        if ( 
-            (a = _gather_3_rule(p))  // ','.expression+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (b = expression_rule(p))  // expression 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_literal_3 = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (c = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); 
-            _res = _PyPegen_seq_append_to_end ( p , CHECK ( _PyPegen_seq_append_to_end ( p , a , b ) ) , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression")); 
-    } 
-    { // ','.expression+ ',' '*' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * a; 
-        expr_ty b; 
-        if ( 
-            (a = _gather_5_rule(p))  // ','.expression+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression")); 
-            _res = _PyPegen_seq_append_to_end ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression")); 
-    } 
-    { // ','.expression+ ',' '**' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * a; 
-        expr_ty b; 
-        if ( 
-            (a = _gather_7_rule(p))  // ','.expression+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression")); 
-            _res = _PyPegen_seq_append_to_end ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression")); 
-    } 
-    { // '*' expression ',' '**' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = expression_rule(p))  // expression 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression")); 
-            _res = _PyPegen_seq_append_to_end ( p , CHECK ( _PyPegen_singleton_seq ( p , a ) ) , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression")); 
-            _res = _PyPegen_singleton_seq ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); 
-    } 
-    { // '**' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression")); 
-            _res = _PyPegen_singleton_seq ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression")); 
-    } 
-    { // ','.expression+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+")); 
-        asdl_seq * _gather_9_var; 
-        if ( 
-            (_gather_9_var = _gather_9_rule(p))  // ','.expression+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+")); 
-            _res = _gather_9_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// statements: statement+ 
-static asdl_seq* 
-statements_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // statement+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+")); 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_11_rule(p))  // statement+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement+")); 
-            _res = _PyPegen_seq_flatten ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// statement: compound_stmt | simple_stmt 
-static asdl_seq* 
-statement_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // compound_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt")); 
-        stmt_ty a; 
-        if ( 
-            (a = compound_stmt_rule(p))  // compound_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt")); 
-            _res = _PyPegen_singleton_seq ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt")); 
-    } 
-    { // simple_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt")); 
-        asdl_seq* simple_stmt_var; 
-        if ( 
-            (simple_stmt_var = simple_stmt_rule(p))  // simple_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt")); 
-            _res = simple_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// statement_newline: compound_stmt NEWLINE | simple_stmt | NEWLINE | $ 
-static asdl_seq* 
-statement_newline_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // compound_stmt NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE")); 
-        stmt_ty a; 
-        Token * newline_var; 
-        if ( 
-            (a = compound_stmt_rule(p))  // compound_stmt 
-            && 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE")); 
-            _res = _PyPegen_singleton_seq ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt NEWLINE")); 
-    } 
-    { // simple_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt")); 
-        asdl_seq* simple_stmt_var; 
-        if ( 
-            (simple_stmt_var = simple_stmt_rule(p))  // simple_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt")); 
-            _res = simple_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt")); 
-    } 
-    { // NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); 
-        Token * newline_var; 
-        if ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _PyPegen_singleton_seq ( p , CHECK ( _Py_Pass ( EXTRA ) ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); 
-    } 
-    { // $ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$")); 
-        Token * endmarker_var; 
-        if ( 
-            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "$")); 
-            _res = _PyPegen_interactive_exit ( p ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "$")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// simple_stmt: small_stmt !';' NEWLINE | ';'.small_stmt+ ';'? NEWLINE 
-static asdl_seq* 
-simple_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // small_stmt !';' NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "small_stmt !';' NEWLINE")); 
-        stmt_ty a; 
-        Token * newline_var; 
-        if ( 
-            (a = small_stmt_rule(p))  // small_stmt 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13)  // token=';' 
-            && 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "small_stmt !';' NEWLINE")); 
-            _res = _PyPegen_singleton_seq ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "small_stmt !';' NEWLINE")); 
-    } 
-    { // ';'.small_stmt+ ';'? NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        Token * newline_var; 
-        if ( 
-            (a = _gather_12_rule(p))  // ';'.small_stmt+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator)  // ';'? 
-            && 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// small_stmt: 
-//     | assignment 
-//     | star_expressions 
-//     | &'return' return_stmt 
-//     | &('import' | 'from') import_stmt 
-//     | &'raise' raise_stmt 
-//     | 'pass' 
-//     | &'del' del_stmt 
-//     | &'yield' yield_stmt 
-//     | &'assert' assert_stmt 
-//     | 'break' 
-//     | 'continue' 
-//     | &'global' global_stmt 
-//     | &'nonlocal' nonlocal_stmt 
-static stmt_ty 
-small_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    stmt_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, small_stmt_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // assignment 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment")); 
-        stmt_ty assignment_var; 
-        if ( 
-            (assignment_var = assignment_rule(p))  // assignment 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment")); 
-            _res = assignment_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment")); 
-    } 
-    { // star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-        expr_ty e; 
-        if ( 
-            (e = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Expr ( e , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); 
-    } 
-    { // &'return' return_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt")); 
-        stmt_ty return_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 500)  // token='return' 
-            && 
-            (return_stmt_var = return_stmt_rule(p))  // return_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt")); 
-            _res = return_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt")); 
-    } 
-    { // &('import' | 'from') import_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt")); 
-        stmt_ty import_stmt_var; 
-        if ( 
-            _PyPegen_lookahead(1, _tmp_14_rule, p) 
-            && 
-            (import_stmt_var = import_stmt_rule(p))  // import_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt")); 
-            _res = import_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from') import_stmt")); 
-    } 
-    { // &'raise' raise_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt")); 
-        stmt_ty raise_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 501)  // token='raise' 
-            && 
-            (raise_stmt_var = raise_stmt_rule(p))  // raise_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt")); 
-            _res = raise_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt")); 
-    } 
-    { // 'pass' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 502))  // token='pass' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Pass ( EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'pass'")); 
-    } 
-    { // &'del' del_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt")); 
-        stmt_ty del_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 503)  // token='del' 
-            && 
-            (del_stmt_var = del_stmt_rule(p))  // del_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt")); 
-            _res = del_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt")); 
-    } 
-    { // &'yield' yield_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt")); 
-        stmt_ty yield_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 504)  // token='yield' 
-            && 
-            (yield_stmt_var = yield_stmt_rule(p))  // yield_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt")); 
-            _res = yield_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt")); 
-    } 
-    { // &'assert' assert_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt")); 
-        stmt_ty assert_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 505)  // token='assert' 
-            && 
-            (assert_stmt_var = assert_stmt_rule(p))  // assert_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt")); 
-            _res = assert_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt")); 
-    } 
-    { // 'break' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 506))  // token='break' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Break ( EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'break'")); 
-    } 
-    { // 'continue' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 507))  // token='continue' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Continue ( EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'continue'")); 
-    } 
-    { // &'global' global_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt")); 
-        stmt_ty global_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 508)  // token='global' 
-            && 
-            (global_stmt_var = global_stmt_rule(p))  // global_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt")); 
-            _res = global_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt")); 
-    } 
-    { // &'nonlocal' nonlocal_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt")); 
-        stmt_ty nonlocal_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 509)  // token='nonlocal' 
-            && 
-            (nonlocal_stmt_var = nonlocal_stmt_rule(p))  // nonlocal_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt")); 
-            _res = nonlocal_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'nonlocal' nonlocal_stmt")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, small_stmt_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// compound_stmt: 
-//     | &('def' | '@' | ASYNC) function_def 
-//     | &'if' if_stmt 
-//     | &('class' | '@') class_def 
-//     | &('with' | ASYNC) with_stmt 
-//     | &('for' | ASYNC) for_stmt 
-//     | &'try' try_stmt 
-//     | &'while' while_stmt 
-static stmt_ty 
-compound_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    stmt_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // &('def' | '@' | ASYNC) function_def 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def")); 
-        stmt_ty function_def_var; 
-        if ( 
-            _PyPegen_lookahead(1, _tmp_15_rule, p) 
-            && 
-            (function_def_var = function_def_rule(p))  // function_def 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def")); 
-            _res = function_def_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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' if_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt")); 
-        stmt_ty if_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 510)  // token='if' 
-            && 
-            (if_stmt_var = if_stmt_rule(p))  // if_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt")); 
-            _res = if_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt")); 
-    } 
-    { // &('class' | '@') class_def 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def")); 
-        stmt_ty class_def_var; 
-        if ( 
-            _PyPegen_lookahead(1, _tmp_16_rule, p) 
-            && 
-            (class_def_var = class_def_rule(p))  // class_def 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def")); 
-            _res = class_def_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def")); 
-    } 
-    { // &('with' | ASYNC) with_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt")); 
-        stmt_ty with_stmt_var; 
-        if ( 
-            _PyPegen_lookahead(1, _tmp_17_rule, p) 
-            && 
-            (with_stmt_var = with_stmt_rule(p))  // with_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt")); 
-            _res = with_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // &('for' | ASYNC) for_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt")); 
-        stmt_ty for_stmt_var; 
-        if ( 
-            _PyPegen_lookahead(1, _tmp_18_rule, p) 
-            && 
-            (for_stmt_var = for_stmt_rule(p))  // for_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt")); 
-            _res = for_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // &'try' try_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt")); 
-        stmt_ty try_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 511)  // token='try' 
-            && 
-            (try_stmt_var = try_stmt_rule(p))  // try_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt")); 
-            _res = try_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt")); 
-    } 
-    { // &'while' while_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt")); 
-        stmt_ty while_stmt_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 512)  // token='while' 
-            && 
-            (while_stmt_var = while_stmt_rule(p))  // while_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt")); 
-            _res = while_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// assignment: 
-//     | NAME ':' expression ['=' annotated_rhs] 
-//     | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs] 
-//     | ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT? 
-//     | single_target augassign ~ (yield_expr | star_expressions) 
-//     | invalid_assignment 
-static stmt_ty 
-assignment_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME ':' expression ['=' annotated_rhs] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        void *c; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = expression_rule(p))  // expression 
-            && 
-            (c = _tmp_19_rule(p), !p->error_indicator)  // ['=' annotated_rhs] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 6 , "Variable annotation syntax is" , _Py_AnnAssign ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]")); 
-    } 
-    { // ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); 
-        Token * _literal; 
-        void *a; 
-        expr_ty b; 
-        void *c; 
-        if ( 
-            (a = _tmp_20_rule(p))  // '(' single_target ')' | single_subscript_attribute_target 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = expression_rule(p))  // expression 
-            && 
-            (c = _tmp_21_rule(p), !p->error_indicator)  // ['=' annotated_rhs] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 6 , "Variable annotations syntax is" , _Py_AnnAssign ( a , b , c , 0 , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]")); 
-    } 
-    { // ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?")); 
-        asdl_seq * a; 
-        void *b; 
-        void *tc; 
-        if ( 
-            (a = _loop1_22_rule(p))  // ((star_targets '='))+ 
-            && 
-            (b = _tmp_23_rule(p))  // yield_expr | star_expressions 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)  // token='=' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?")); 
-    } 
-    { // single_target augassign ~ (yield_expr | star_expressions) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)")); 
-        int _cut_var = 0; 
-        expr_ty a; 
-        AugOperator* b; 
-        void *c; 
-        if ( 
-            (a = single_target_rule(p))  // single_target 
-            && 
-            (b = augassign_rule(p))  // augassign 
-            && 
-            (_cut_var = 1) 
-            && 
-            (c = _tmp_24_rule(p))  // yield_expr | star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_AugAssign ( a , b -> kind , c , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    if (p->call_invalid_rules) { // invalid_assignment 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignment")); 
-        void *invalid_assignment_var; 
-        if ( 
-            (invalid_assignment_var = invalid_assignment_rule(p))  // invalid_assignment 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_assignment")); 
-            _res = invalid_assignment_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_assignment")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// augassign: 
-//     | '+=' 
-//     | '-=' 
-//     | '*=' 
-//     | '@=' 
-//     | '/=' 
-//     | '%=' 
-//     | '&=' 
-//     | '|=' 
-//     | '^=' 
-//     | '<<=' 
-//     | '>>=' 
-//     | '**=' 
-//     | '//=' 
-static AugOperator* 
-augassign_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    AugOperator* _res = NULL; 
-    int _mark = p->mark; 
-    { // '+=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 36))  // token='+=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='")); 
-            _res = _PyPegen_augoperator ( p , Add ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='")); 
-    } 
-    { // '-=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 37))  // token='-=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='")); 
-            _res = _PyPegen_augoperator ( p , Sub ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='")); 
-    } 
-    { // '*=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 38))  // token='*=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='")); 
-            _res = _PyPegen_augoperator ( p , Mult ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='")); 
-    } 
-    { // '@=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 50))  // token='@=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='")); 
-            _res = CHECK_VERSION ( 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='")); 
-    } 
-    { // '/=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 39))  // token='/=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='")); 
-            _res = _PyPegen_augoperator ( p , Div ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='")); 
-    } 
-    { // '%=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 40))  // token='%=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='")); 
-            _res = _PyPegen_augoperator ( p , Mod ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='")); 
-    } 
-    { // '&=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 41))  // token='&=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='")); 
-            _res = _PyPegen_augoperator ( p , BitAnd ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='")); 
-    } 
-    { // '|=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 42))  // token='|=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='")); 
-            _res = _PyPegen_augoperator ( p , BitOr ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='")); 
-    } 
-    { // '^=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 43))  // token='^=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='")); 
-            _res = _PyPegen_augoperator ( p , BitXor ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='")); 
-    } 
-    { // '<<=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 44))  // token='<<=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='")); 
-            _res = _PyPegen_augoperator ( p , LShift ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='")); 
-    } 
-    { // '>>=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 45))  // token='>>=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='")); 
-            _res = _PyPegen_augoperator ( p , RShift ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='")); 
-    } 
-    { // '**=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 46))  // token='**=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='")); 
-            _res = _PyPegen_augoperator ( p , Pow ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='")); 
-    } 
-    { // '//=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 48))  // token='//=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='")); 
-            _res = _PyPegen_augoperator ( p , FloorDiv ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// global_stmt: 'global' ','.NAME+ 
-static stmt_ty 
-global_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'global' ','.NAME+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+")); 
-        Token * _keyword; 
-        asdl_seq * a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 508))  // token='global' 
-            && 
-            (a = _gather_25_rule(p))  // ','.NAME+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Global ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s global_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'global' ','.NAME+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// nonlocal_stmt: 'nonlocal' ','.NAME+ 
-static stmt_ty 
-nonlocal_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'nonlocal' ','.NAME+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+")); 
-        Token * _keyword; 
-        asdl_seq * a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 509))  // token='nonlocal' 
-            && 
-            (a = _gather_27_rule(p))  // ','.NAME+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Nonlocal ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s nonlocal_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'nonlocal' ','.NAME+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// yield_stmt: yield_expr 
-static stmt_ty 
-yield_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // yield_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-        expr_ty y; 
-        if ( 
-            (y = yield_expr_rule(p))  // yield_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Expr ( y , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s yield_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// assert_stmt: 'assert' expression [',' expression] 
-static stmt_ty 
-assert_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'assert' expression [',' expression] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]")); 
-        Token * _keyword; 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 505))  // token='assert' 
-            && 
-            (a = expression_rule(p))  // expression 
-            && 
-            (b = _tmp_29_rule(p), !p->error_indicator)  // [',' expression] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Assert ( a , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s assert_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'assert' expression [',' expression]")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt 
-static stmt_ty 
-del_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'del' del_targets &(';' | NEWLINE) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); 
-        Token * _keyword; 
-        asdl_seq* a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 503))  // token='del' 
-            && 
-            (a = del_targets_rule(p))  // del_targets 
-            && 
-            _PyPegen_lookahead(1, _tmp_30_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Delete ( a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' del_targets &(';' | NEWLINE)")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_del_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt")); 
-        void *invalid_del_stmt_var; 
-        if ( 
-            (invalid_del_stmt_var = invalid_del_stmt_rule(p))  // invalid_del_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt")); 
-            _res = invalid_del_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_del_stmt")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// import_stmt: import_name | import_from 
-static stmt_ty 
-import_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    stmt_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // import_name 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name")); 
-        stmt_ty import_name_var; 
-        if ( 
-            (import_name_var = import_name_rule(p))  // import_name 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_name")); 
-            _res = import_name_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name")); 
-    } 
-    { // import_from 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from")); 
-        stmt_ty import_from_var; 
-        if ( 
-            (import_from_var = import_from_rule(p))  // import_from 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from")); 
-            _res = import_from_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// import_name: 'import' dotted_as_names 
-static stmt_ty 
-import_name_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'import' dotted_as_names 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names")); 
-        Token * _keyword; 
-        asdl_seq* a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 513))  // token='import' 
-            && 
-            (a = dotted_as_names_rule(p))  // dotted_as_names 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Import ( a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_name[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' dotted_as_names")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// import_from: 
-//     | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets 
-//     | 'from' (('.' | '...'))+ 'import' import_from_targets 
-static stmt_ty 
-import_from_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets")); 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        asdl_seq * a; 
-        expr_ty b; 
-        asdl_seq* c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 514))  // token='from' 
-            && 
-            (a = _loop0_31_rule(p))  // (('.' | '...'))* 
-            && 
-            (b = dotted_name_rule(p))  // dotted_name 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 513))  // token='import' 
-            && 
-            (c = import_from_targets_rule(p))  // import_from_targets 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets")); 
-    } 
-    { // 'from' (('.' | '...'))+ 'import' import_from_targets 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets")); 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        asdl_seq * a; 
-        asdl_seq* b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 514))  // token='from' 
-            && 
-            (a = _loop1_32_rule(p))  // (('.' | '...'))+ 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 513))  // token='import' 
-            && 
-            (b = import_from_targets_rule(p))  // import_from_targets 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// import_from_targets: 
-//     | '(' import_from_as_names ','? ')' 
-//     | import_from_as_names !',' 
-//     | '*' 
-//     | invalid_import_from_targets 
-static asdl_seq* 
-import_from_targets_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' import_from_as_names ','? ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq* a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = import_from_as_names_rule(p))  // import_from_as_names 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 ','? ')'")); 
-    } 
-    { // import_from_as_names !',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','")); 
-        asdl_seq* import_from_as_names_var; 
-        if ( 
-            (import_from_as_names_var = import_from_as_names_rule(p))  // import_from_as_names 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','")); 
-            _res = import_from_as_names_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'")); 
-            _res = _PyPegen_singleton_seq ( p , CHECK ( _PyPegen_alias_for_star ( p ) ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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) { // invalid_import_from_targets 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets")); 
-        void *invalid_import_from_targets_var; 
-        if ( 
-            (invalid_import_from_targets_var = invalid_import_from_targets_rule(p))  // invalid_import_from_targets 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets")); 
-            _res = invalid_import_from_targets_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// import_from_as_names: ','.import_from_as_name+ 
-static asdl_seq* 
-import_from_as_names_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.import_from_as_name+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+")); 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_33_rule(p))  // ','.import_from_as_name+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_from_as_names[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.import_from_as_name+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// import_from_as_name: NAME ['as' NAME] 
-static alias_ty 
-import_from_as_name_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    alias_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // NAME ['as' NAME] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]")); 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (b = _tmp_35_rule(p), !p->error_indicator)  // ['as' NAME] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]")); 
-            _res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s import_from_as_name[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ['as' NAME]")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// dotted_as_names: ','.dotted_as_name+ 
-static asdl_seq* 
-dotted_as_names_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.dotted_as_name+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+")); 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_36_rule(p))  // ','.dotted_as_name+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dotted_as_names[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.dotted_as_name+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// dotted_as_name: dotted_name ['as' NAME] 
-static alias_ty 
-dotted_as_name_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    alias_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // dotted_name ['as' NAME] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]")); 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (a = dotted_name_rule(p))  // dotted_name 
-            && 
-            (b = _tmp_38_rule(p), !p->error_indicator)  // ['as' NAME] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]")); 
-            _res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dotted_as_name[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name ['as' NAME]")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// dotted_name: dotted_name '.' NAME | NAME 
-static expr_ty dotted_name_raw(Parser *); 
-static expr_ty 
-dotted_name_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res); 
-        if (tmpvar_0) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = dotted_name_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-dotted_name_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // dotted_name '.' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = dotted_name_rule(p))  // dotted_name 
-            && 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-            && 
-            (b = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME")); 
-            _res = _PyPegen_join_names_with_dot ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name '.' NAME")); 
-    } 
-    { // NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); 
-        expr_ty name_var; 
-        if ( 
-            (name_var = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); 
-            _res = name_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// if_stmt: 
-//     | 'if' named_expression ':' block elif_stmt 
-//     | 'if' named_expression ':' block else_block? 
-static stmt_ty 
-if_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'if' named_expression ':' block elif_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt")); 
-        Token * _keyword; 
-        Token * _literal; 
-        expr_ty a; 
-        asdl_seq* b; 
-        stmt_ty c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 510))  // token='if' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (c = elif_stmt_rule(p))  // elif_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block elif_stmt")); 
-    } 
-    { // 'if' named_expression ':' block else_block? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?")); 
-        Token * _keyword; 
-        Token * _literal; 
-        expr_ty a; 
-        asdl_seq* b; 
-        void *c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 510))  // token='if' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (c = else_block_rule(p), !p->error_indicator)  // else_block? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_If ( a , b , c , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block else_block?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// elif_stmt: 
-//     | 'elif' named_expression ':' block elif_stmt 
-//     | 'elif' named_expression ':' block else_block? 
-static stmt_ty 
-elif_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'elif' named_expression ':' block elif_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt")); 
-        Token * _keyword; 
-        Token * _literal; 
-        expr_ty a; 
-        asdl_seq* b; 
-        stmt_ty c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 515))  // token='elif' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (c = elif_stmt_rule(p))  // elif_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block elif_stmt")); 
-    } 
-    { // 'elif' named_expression ':' block else_block? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?")); 
-        Token * _keyword; 
-        Token * _literal; 
-        expr_ty a; 
-        asdl_seq* b; 
-        void *c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 515))  // token='elif' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (c = else_block_rule(p), !p->error_indicator)  // else_block? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_If ( a , b , c , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block else_block?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// else_block: 'else' ':' block 
-static asdl_seq* 
-else_block_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // 'else' ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq* b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 516))  // token='else' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' ':' block")); 
-            _res = b; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' ':' block")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// while_stmt: 'while' named_expression ':' block else_block? 
-static stmt_ty 
-while_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'while' named_expression ':' block else_block? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?")); 
-        Token * _keyword; 
-        Token * _literal; 
-        expr_ty a; 
-        asdl_seq* b; 
-        void *c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 512))  // token='while' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (c = else_block_rule(p), !p->error_indicator)  // else_block? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_While ( a , b , c , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' block else_block?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// for_stmt: 
-//     | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? 
-//     | ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? 
-//     | invalid_for_target 
-static stmt_ty 
-for_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); 
-        int _cut_var = 0; 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        Token * _literal; 
-        asdl_seq* b; 
-        void *el; 
-        expr_ty ex; 
-        expr_ty t; 
-        void *tc; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 517))  // token='for' 
-            && 
-            (t = star_targets_rule(p))  // star_targets 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in' 
-            && 
-            (_cut_var = 1) 
-            && 
-            (ex = star_expressions_rule(p))  // star_expressions 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (el = else_block_rule(p), !p->error_indicator)  // else_block? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    { // ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); 
-        int _cut_var = 0; 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        Token * _literal; 
-        Token * async_var; 
-        asdl_seq* b; 
-        void *el; 
-        expr_ty ex; 
-        expr_ty t; 
-        void *tc; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 517))  // token='for' 
-            && 
-            (t = star_targets_rule(p))  // star_targets 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in' 
-            && 
-            (_cut_var = 1) 
-            && 
-            (ex = star_expressions_rule(p))  // star_expressions 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (el = else_block_rule(p), !p->error_indicator)  // else_block? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 5 , "Async for loops are" , _Py_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    if (p->call_invalid_rules) { // invalid_for_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); 
-        void *invalid_for_target_var; 
-        if ( 
-            (invalid_for_target_var = invalid_for_target_rule(p))  // invalid_for_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); 
-            _res = invalid_for_target_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// with_stmt: 
-//     | 'with' '(' ','.with_item+ ','? ')' ':' block 
-//     | 'with' ','.with_item+ ':' TYPE_COMMENT? block 
-//     | ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block 
-//     | ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block 
-static stmt_ty 
-with_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'with' '(' ','.with_item+ ','? ')' ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        asdl_seq* b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 519))  // token='with' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = _gather_39_rule(p))  // ','.with_item+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_With ( a , b , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block")); 
-    } 
-    { // 'with' ','.with_item+ ':' TYPE_COMMENT? block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq * a; 
-        asdl_seq* b; 
-        void *tc; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 519))  // token='with' 
-            && 
-            (a = _gather_41_rule(p))  // ','.with_item+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        Token * async_var; 
-        asdl_seq* b; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 519))  // token='with' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = _gather_43_rule(p))  // ','.with_item+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 5 , "Async with statements are" , _Py_AsyncWith ( a , b , NULL , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq * a; 
-        Token * async_var; 
-        asdl_seq* b; 
-        void *tc; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 519))  // token='with' 
-            && 
-            (a = _gather_45_rule(p))  // ','.with_item+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 5 , "Async with statements are" , _Py_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// with_item: 
-//     | expression 'as' star_target &(',' | ')' | ':') 
-//     | invalid_with_item 
-//     | expression 
-static withitem_ty 
-with_item_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    withitem_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // expression 'as' star_target &(',' | ')' | ':') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')")); 
-        Token * _keyword; 
-        expr_ty e; 
-        expr_ty t; 
-        if ( 
-            (e = expression_rule(p))  // expression 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 520))  // token='as' 
-            && 
-            (t = star_target_rule(p))  // star_target 
-            && 
-            _PyPegen_lookahead(1, _tmp_47_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')")); 
-            _res = _Py_withitem ( e , t , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_with_item 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item")); 
-        void *invalid_with_item_var; 
-        if ( 
-            (invalid_with_item_var = invalid_with_item_rule(p))  // invalid_with_item 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_item")); 
-            _res = invalid_with_item_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_item")); 
-    } 
-    { // expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); 
-        expr_ty e; 
-        if ( 
-            (e = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); 
-            _res = _Py_withitem ( e , NULL , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// try_stmt: 
-//     | 'try' ':' block finally_block 
-//     | 'try' ':' block except_block+ else_block? finally_block? 
-static stmt_ty 
-try_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'try' ':' block finally_block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block finally_block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq* b; 
-        asdl_seq* f; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 511))  // token='try' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (f = finally_block_rule(p))  // finally_block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block finally_block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Try ( b , NULL , NULL , f , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block finally_block")); 
-    } 
-    { // 'try' ':' block except_block+ else_block? finally_block? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq* b; 
-        void *el; 
-        asdl_seq * ex; 
-        void *f; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 511))  // token='try' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-            && 
-            (ex = _loop1_48_rule(p))  // except_block+ 
-            && 
-            (el = else_block_rule(p), !p->error_indicator)  // else_block? 
-            && 
-            (f = finally_block_rule(p), !p->error_indicator)  // finally_block? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Try ( b , ex , el , f , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// except_block: 'except' expression ['as' NAME] ':' block | 'except' ':' block 
-static excepthandler_ty 
-except_block_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    excepthandler_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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'except' expression ['as' NAME] ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq* b; 
-        expr_ty e; 
-        void *t; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 521))  // token='except' 
-            && 
-            (e = expression_rule(p))  // expression 
-            && 
-            (t = _tmp_49_rule(p), !p->error_indicator)  // ['as' NAME] 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' block")); 
-    } 
-    { // 'except' ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq* b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 521))  // token='except' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_ExceptHandler ( NULL , NULL , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' block")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// finally_block: 'finally' ':' block 
-static asdl_seq* 
-finally_block_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // 'finally' ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        asdl_seq* a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 522))  // token='finally' 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (a = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' ':' block")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' ':' block")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// return_stmt: 'return' star_expressions? 
-static stmt_ty 
-return_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'return' star_expressions? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?")); 
-        Token * _keyword; 
-        void *a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 500))  // token='return' 
-            && 
-            (a = star_expressions_rule(p), !p->error_indicator)  // star_expressions? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Return ( a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s return_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'return' star_expressions?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// raise_stmt: 'raise' expression ['from' expression] | 'raise' 
-static stmt_ty 
-raise_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'raise' expression ['from' expression] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]")); 
-        Token * _keyword; 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 501))  // token='raise' 
-            && 
-            (a = expression_rule(p))  // expression 
-            && 
-            (b = _tmp_50_rule(p), !p->error_indicator)  // ['from' expression] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Raise ( a , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise' expression ['from' expression]")); 
-    } 
-    { // 'raise' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 501))  // token='raise' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Raise ( NULL , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// function_def: decorators function_def_raw | function_def_raw 
-static stmt_ty 
-function_def_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    stmt_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // decorators function_def_raw 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw")); 
-        asdl_seq* d; 
-        stmt_ty f; 
-        if ( 
-            (d = decorators_rule(p))  // decorators 
-            && 
-            (f = function_def_raw_rule(p))  // function_def_raw 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw")); 
-            _res = _PyPegen_function_def_decorators ( p , d , f ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // function_def_raw 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_raw")); 
-        stmt_ty function_def_raw_var; 
-        if ( 
-            (function_def_raw_var = function_def_raw_rule(p))  // function_def_raw 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "function_def_raw")); 
-            _res = function_def_raw_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// function_def_raw: 
-//     | 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block 
-//     | ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block 
-static stmt_ty 
-function_def_raw_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        void *a; 
-        asdl_seq* b; 
-        expr_ty n; 
-        void *params; 
-        void *tc; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 523))  // token='def' 
-            && 
-            (n = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (params = params_rule(p), !p->error_indicator)  // params? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-            && 
-            (a = _tmp_51_rule(p), !p->error_indicator)  // ['->' expression] 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (tc = func_type_comment_rule(p), !p->error_indicator)  // func_type_comment? 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block")); 
-    } 
-    { // ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * _literal_2; 
-        void *a; 
-        Token * async_var; 
-        asdl_seq* b; 
-        expr_ty n; 
-        void *params; 
-        void *tc; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 523))  // token='def' 
-            && 
-            (n = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (params = params_rule(p), !p->error_indicator)  // params? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-            && 
-            (a = _tmp_52_rule(p), !p->error_indicator)  // ['->' expression] 
-            && 
-            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (tc = func_type_comment_rule(p), !p->error_indicator)  // func_type_comment? 
-            && 
-            (b = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 5 , "Async functions are" , _Py_AsyncFunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 '(' params? ')' ['->' expression] ':' func_type_comment? block")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// func_type_comment: 
-//     | NEWLINE TYPE_COMMENT &(NEWLINE INDENT) 
-//     | invalid_double_type_comments 
-//     | TYPE_COMMENT 
-static Token* 
-func_type_comment_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    Token* _res = NULL; 
-    int _mark = p->mark; 
-    { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); 
-        Token * newline_var; 
-        Token * t; 
-        if ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-            && 
-            (t = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT' 
-            && 
-            _PyPegen_lookahead(1, _tmp_53_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)")); 
-            _res = t; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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) { // invalid_double_type_comments 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments")); 
-        void *invalid_double_type_comments_var; 
-        if ( 
-            (invalid_double_type_comments_var = invalid_double_type_comments_rule(p))  // invalid_double_type_comments 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments")); 
-            _res = invalid_double_type_comments_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // TYPE_COMMENT 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT")); 
-        Token * type_comment_var; 
-        if ( 
-            (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT")); 
-            _res = type_comment_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// params: invalid_parameters | parameters 
-static arguments_ty 
-params_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arguments_ty _res = NULL; 
-    int _mark = p->mark; 
-    if (p->call_invalid_rules) { // invalid_parameters 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters")); 
-        void *invalid_parameters_var; 
-        if ( 
-            (invalid_parameters_var = invalid_parameters_rule(p))  // invalid_parameters 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_parameters")); 
-            _res = invalid_parameters_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_parameters")); 
-    } 
-    { // parameters 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters")); 
-        arguments_ty parameters_var; 
-        if ( 
-            (parameters_var = parameters_rule(p))  // parameters 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameters")); 
-            _res = parameters_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// parameters: 
-//     | slash_no_default param_no_default* param_with_default* star_etc? 
-//     | slash_with_default param_with_default* star_etc? 
-//     | param_no_default+ param_with_default* star_etc? 
-//     | param_with_default+ star_etc? 
-//     | star_etc 
-static arguments_ty 
-parameters_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arguments_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // slash_no_default param_no_default* param_with_default* star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?")); 
-        asdl_seq* a; 
-        asdl_seq * b; 
-        asdl_seq * c; 
-        void *d; 
-        if ( 
-            (a = slash_no_default_rule(p))  // slash_no_default 
-            && 
-            (b = _loop0_54_rule(p))  // param_no_default* 
-            && 
-            (c = _loop0_55_rule(p))  // param_with_default* 
-            && 
-            (d = star_etc_rule(p), !p->error_indicator)  // star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // slash_with_default param_with_default* star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?")); 
-        SlashWithDefault* a; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (a = slash_with_default_rule(p))  // slash_with_default 
-            && 
-            (b = _loop0_56_rule(p))  // param_with_default* 
-            && 
-            (c = star_etc_rule(p), !p->error_indicator)  // star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // param_no_default+ param_with_default* star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?")); 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (a = _loop1_57_rule(p))  // param_no_default+ 
-            && 
-            (b = _loop0_58_rule(p))  // param_with_default* 
-            && 
-            (c = star_etc_rule(p), !p->error_indicator)  // star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // param_with_default+ star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?")); 
-        asdl_seq * a; 
-        void *b; 
-        if ( 
-            (a = _loop1_59_rule(p))  // param_with_default+ 
-            && 
-            (b = star_etc_rule(p), !p->error_indicator)  // star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // star_etc 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc")); 
-        StarEtc* a; 
-        if ( 
-            (a = star_etc_rule(p))  // star_etc 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_etc")); 
-            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_etc")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')' 
-static asdl_seq* 
-slash_no_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // param_no_default+ '/' ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_60_rule(p))  // param_no_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' ','")); 
-    } 
-    { // param_no_default+ '/' &')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'")); 
-        Token * _literal; 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_61_rule(p))  // param_no_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' &')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// slash_with_default: 
-//     | param_no_default* param_with_default+ '/' ',' 
-//     | param_no_default* param_with_default+ '/' &')' 
-static SlashWithDefault* 
-slash_with_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    SlashWithDefault* _res = NULL; 
-    int _mark = p->mark; 
-    { // param_no_default* param_with_default+ '/' ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        if ( 
-            (a = _loop0_62_rule(p))  // param_no_default* 
-            && 
-            (b = _loop1_63_rule(p))  // param_with_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','")); 
-            _res = _PyPegen_slash_with_default ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' ','")); 
-    } 
-    { // param_no_default* param_with_default+ '/' &')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'")); 
-        Token * _literal; 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        if ( 
-            (a = _loop0_64_rule(p))  // param_no_default* 
-            && 
-            (b = _loop1_65_rule(p))  // param_with_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'")); 
-            _res = _PyPegen_slash_with_default ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' &')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_etc: 
-//     | '*' param_no_default param_maybe_default* kwds? 
-//     | '*' ',' param_maybe_default+ kwds? 
-//     | kwds 
-//     | invalid_star_etc 
-static StarEtc* 
-star_etc_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    StarEtc* _res = NULL; 
-    int _mark = p->mark; 
-    { // '*' param_no_default param_maybe_default* kwds? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?")); 
-        Token * _literal; 
-        arg_ty a; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = param_no_default_rule(p))  // param_no_default 
-            && 
-            (b = _loop0_66_rule(p))  // param_maybe_default* 
-            && 
-            (c = kwds_rule(p), !p->error_indicator)  // kwds? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?")); 
-            _res = _PyPegen_star_etc ( p , a , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // '*' ',' param_maybe_default+ kwds? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (b = _loop1_67_rule(p))  // param_maybe_default+ 
-            && 
-            (c = kwds_rule(p), !p->error_indicator)  // kwds? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?")); 
-            _res = _PyPegen_star_etc ( p , NULL , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // kwds 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds")); 
-        arg_ty a; 
-        if ( 
-            (a = kwds_rule(p))  // kwds 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds")); 
-            _res = _PyPegen_star_etc ( p , NULL , NULL , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwds")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_star_etc 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc")); 
-        void *invalid_star_etc_var; 
-        if ( 
-            (invalid_star_etc_var = invalid_star_etc_rule(p))  // invalid_star_etc 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_star_etc")); 
-            _res = invalid_star_etc_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// kwds: '**' param_no_default 
-static arg_ty 
-kwds_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arg_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // '**' param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default")); 
-        Token * _literal; 
-        arg_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (a = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_no_default")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param_no_default")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')' 
-static arg_ty 
-param_no_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arg_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // param ',' TYPE_COMMENT? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?")); 
-        Token * _literal; 
-        arg_ty a; 
-        void *tc; 
-        if ( 
-            (a = param_rule(p))  // param 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?")); 
-            _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param ',' TYPE_COMMENT?")); 
-    } 
-    { // param TYPE_COMMENT? &')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'")); 
-        arg_ty a; 
-        void *tc; 
-        if ( 
-            (a = param_rule(p))  // param 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'")); 
-            _res = _PyPegen_add_type_comment_to_arg ( p , a , tc ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param TYPE_COMMENT? &')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')' 
-static NameDefaultPair* 
-param_with_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    NameDefaultPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // param default ',' TYPE_COMMENT? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?")); 
-        Token * _literal; 
-        arg_ty a; 
-        expr_ty c; 
-        void *tc; 
-        if ( 
-            (a = param_rule(p))  // param 
-            && 
-            (c = default_rule(p))  // default 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , tc ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default ',' TYPE_COMMENT?")); 
-    } 
-    { // param default TYPE_COMMENT? &')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'")); 
-        arg_ty a; 
-        expr_ty c; 
-        void *tc; 
-        if ( 
-            (a = param_rule(p))  // param 
-            && 
-            (c = default_rule(p))  // default 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , tc ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default TYPE_COMMENT? &')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// param_maybe_default: 
-//     | param default? ',' TYPE_COMMENT? 
-//     | param default? TYPE_COMMENT? &')' 
-static NameDefaultPair* 
-param_maybe_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    NameDefaultPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // param default? ',' TYPE_COMMENT? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?")); 
-        Token * _literal; 
-        arg_ty a; 
-        void *c; 
-        void *tc; 
-        if ( 
-            (a = param_rule(p))  // param 
-            && 
-            (c = default_rule(p), !p->error_indicator)  // default? 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , tc ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? ',' TYPE_COMMENT?")); 
-    } 
-    { // param default? TYPE_COMMENT? &')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'")); 
-        arg_ty a; 
-        void *c; 
-        void *tc; 
-        if ( 
-            (a = param_rule(p))  // param 
-            && 
-            (c = default_rule(p), !p->error_indicator)  // default? 
-            && 
-            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT? 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , tc ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? TYPE_COMMENT? &')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// param: NAME annotation? 
-static arg_ty 
-param_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arg_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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME annotation? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?")); 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (b = annotation_rule(p), !p->error_indicator)  // annotation? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_arg ( a -> v . Name . id , b , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s param[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME annotation?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// annotation: ':' expression 
-static expr_ty 
-annotation_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // ':' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// default: '=' expression 
-static expr_ty 
-default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // '=' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// decorators: (('@' named_expression NEWLINE))+ 
-static asdl_seq* 
-decorators_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // (('@' named_expression NEWLINE))+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+")); 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_68_rule(p))  // (('@' named_expression NEWLINE))+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s decorators[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(('@' named_expression NEWLINE))+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// class_def: decorators class_def_raw | class_def_raw 
-static stmt_ty 
-class_def_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    stmt_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // decorators class_def_raw 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw")); 
-        asdl_seq* a; 
-        stmt_ty b; 
-        if ( 
-            (a = decorators_rule(p))  // decorators 
-            && 
-            (b = class_def_raw_rule(p))  // class_def_raw 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw")); 
-            _res = _PyPegen_class_def_decorators ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // class_def_raw 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw")); 
-        stmt_ty class_def_raw_var; 
-        if ( 
-            (class_def_raw_var = class_def_raw_rule(p))  // class_def_raw 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_def_raw")); 
-            _res = class_def_raw_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// class_def_raw: 'class' NAME ['(' arguments? ')'] ':' block 
-static stmt_ty 
-class_def_raw_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'class' NAME ['(' arguments? ')'] ':' block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block")); 
-        Token * _keyword; 
-        Token * _literal; 
-        expr_ty a; 
-        void *b; 
-        asdl_seq* c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 524))  // token='class' 
-            && 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (b = _tmp_69_rule(p), !p->error_indicator)  // ['(' arguments? ')'] 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (c = block_rule(p))  // block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// block: NEWLINE INDENT statements DEDENT | simple_stmt | invalid_block 
-static asdl_seq* 
-block_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    if (_PyPegen_is_memoized(p, block_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    { // NEWLINE INDENT statements DEDENT 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT")); 
-        asdl_seq* a; 
-        Token * dedent_var; 
-        Token * indent_var; 
-        Token * newline_var; 
-        if ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-            && 
-            (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT' 
-            && 
-            (a = statements_rule(p))  // statements 
-            && 
-            (dedent_var = _PyPegen_expect_token(p, DEDENT))  // token='DEDENT' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT")); 
-    } 
-    { // simple_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt")); 
-        asdl_seq* simple_stmt_var; 
-        if ( 
-            (simple_stmt_var = simple_stmt_rule(p))  // simple_stmt 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt")); 
-            _res = simple_stmt_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block")); 
-        void *invalid_block_var; 
-        if ( 
-            (invalid_block_var = invalid_block_rule(p))  // invalid_block 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_block")); 
-            _res = invalid_block_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, block_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_expressions: 
-//     | star_expression ((',' star_expression))+ ','? 
-//     | star_expression ',' 
-//     | star_expression 
-static expr_ty 
-star_expressions_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // star_expression ((',' star_expression))+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = star_expression_rule(p))  // star_expression 
-            && 
-            (b = _loop1_70_rule(p))  // ((',' star_expression))+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ((',' star_expression))+ ','?")); 
-    } 
-    { // star_expression ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ','")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (a = star_expression_rule(p))  // star_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ','")); 
-    } 
-    { // star_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression")); 
-        expr_ty star_expression_var; 
-        if ( 
-            (star_expression_var = star_expression_rule(p))  // star_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression")); 
-            _res = star_expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_expression: '*' bitwise_or | expression 
-static expr_ty 
-star_expression_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, star_expression_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '*' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Starred ( a , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); 
-    } 
-    { // expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); 
-        expr_ty expression_var; 
-        if ( 
-            (expression_var = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); 
-            _res = expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, star_expression_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_named_expressions: ','.star_named_expression+ ','? 
-static asdl_seq* 
-star_named_expressions_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.star_named_expression+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_71_rule(p))  // ','.star_named_expression+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_named_expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression+ ','?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_named_expression: '*' bitwise_or | named_expression 
-static expr_ty 
-star_named_expression_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '*' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Starred ( a , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or")); 
-    } 
-    { // named_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); 
-        expr_ty named_expression_var; 
-        if ( 
-            (named_expression_var = named_expression_rule(p))  // named_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); 
-            _res = named_expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// named_expression: NAME ':=' ~ expression | expression !':=' | invalid_named_expression 
-static expr_ty 
-named_expression_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME ':=' ~ expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression")); 
-        int _cut_var = 0; 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 53))  // token=':=' 
-            && 
-            (_cut_var = 1) 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_NamedExpr ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    { // expression !':=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='")); 
-        expr_ty expression_var; 
-        if ( 
-            (expression_var = expression_rule(p))  // expression 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)  // token=':=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='")); 
-            _res = expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_named_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_named_expression")); 
-        void *invalid_named_expression_var; 
-        if ( 
-            (invalid_named_expression_var = invalid_named_expression_rule(p))  // invalid_named_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_named_expression")); 
-            _res = invalid_named_expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// annotated_rhs: yield_expr | star_expressions 
-static expr_ty 
-annotated_rhs_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // yield_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-        expr_ty yield_expr_var; 
-        if ( 
-            (yield_expr_var = yield_expr_rule(p))  // yield_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-            _res = yield_expr_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); 
-    } 
-    { // star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-        expr_ty star_expressions_var; 
-        if ( 
-            (star_expressions_var = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-            _res = star_expressions_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// expressions: expression ((',' expression))+ ','? | expression ',' | expression 
-static expr_ty 
-expressions_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // expression ((',' expression))+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-            && 
-            (b = _loop1_73_rule(p))  // ((',' expression))+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ((',' expression))+ ','?")); 
-    } 
-    { // expression ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ','")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ','")); 
-    } 
-    { // expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); 
-        expr_ty expression_var; 
-        if ( 
-            (expression_var = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); 
-            _res = expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// expression: disjunction 'if' disjunction 'else' expression | disjunction | lambdef 
-static expr_ty 
-expression_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, expression_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // disjunction 'if' disjunction 'else' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        expr_ty a; 
-        expr_ty b; 
-        expr_ty c; 
-        if ( 
-            (a = disjunction_rule(p))  // disjunction 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 510))  // token='if' 
-            && 
-            (b = disjunction_rule(p))  // disjunction 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 516))  // token='else' 
-            && 
-            (c = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_IfExp ( b , a , c , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression")); 
-    } 
-    { // disjunction 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction")); 
-        expr_ty disjunction_var; 
-        if ( 
-            (disjunction_var = disjunction_rule(p))  // disjunction 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction")); 
-            _res = disjunction_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction")); 
-    } 
-    { // lambdef 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef")); 
-        expr_ty lambdef_var; 
-        if ( 
-            (lambdef_var = lambdef_rule(p))  // lambdef 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef")); 
-            _res = lambdef_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, expression_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambdef: 'lambda' lambda_params? ':' expression 
-static expr_ty 
-lambdef_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'lambda' lambda_params? ':' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression")); 
-        Token * _keyword; 
-        Token * _literal; 
-        void *a; 
-        expr_ty b; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 525))  // token='lambda' 
-            && 
-            (a = lambda_params_rule(p), !p->error_indicator)  // lambda_params? 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Lambda ( ( a ) ? a : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambdef[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_params: invalid_lambda_parameters | lambda_parameters 
-static arguments_ty 
-lambda_params_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arguments_ty _res = NULL; 
-    int _mark = p->mark; 
-    if (p->call_invalid_rules) { // invalid_lambda_parameters 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters")); 
-        void *invalid_lambda_parameters_var; 
-        if ( 
-            (invalid_lambda_parameters_var = invalid_lambda_parameters_rule(p))  // invalid_lambda_parameters 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters")); 
-            _res = invalid_lambda_parameters_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_parameters")); 
-    } 
-    { // lambda_parameters 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parameters")); 
-        arguments_ty lambda_parameters_var; 
-        if ( 
-            (lambda_parameters_var = lambda_parameters_rule(p))  // lambda_parameters 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_parameters")); 
-            _res = lambda_parameters_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_parameters")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_parameters: 
-//     | lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? 
-//     | lambda_slash_with_default lambda_param_with_default* lambda_star_etc? 
-//     | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? 
-//     | lambda_param_with_default+ lambda_star_etc? 
-//     | lambda_star_etc 
-static arguments_ty 
-lambda_parameters_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arguments_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?")); 
-        asdl_seq* a; 
-        asdl_seq * b; 
-        asdl_seq * c; 
-        void *d; 
-        if ( 
-            (a = lambda_slash_no_default_rule(p))  // lambda_slash_no_default 
-            && 
-            (b = _loop0_74_rule(p))  // lambda_param_no_default* 
-            && 
-            (c = _loop0_75_rule(p))  // lambda_param_with_default* 
-            && 
-            (d = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // lambda_slash_with_default lambda_param_with_default* lambda_star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?")); 
-        SlashWithDefault* a; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (a = lambda_slash_with_default_rule(p))  // lambda_slash_with_default 
-            && 
-            (b = _loop0_76_rule(p))  // lambda_param_with_default* 
-            && 
-            (c = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?")); 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (a = _loop1_77_rule(p))  // lambda_param_no_default+ 
-            && 
-            (b = _loop0_78_rule(p))  // lambda_param_with_default* 
-            && 
-            (c = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // lambda_param_with_default+ lambda_star_etc? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?")); 
-        asdl_seq * a; 
-        void *b; 
-        if ( 
-            (a = _loop1_79_rule(p))  // lambda_param_with_default+ 
-            && 
-            (b = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?")); 
-            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // lambda_star_etc 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_star_etc")); 
-        StarEtc* a; 
-        if ( 
-            (a = lambda_star_etc_rule(p))  // lambda_star_etc 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_star_etc")); 
-            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_star_etc")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_slash_no_default: 
-//     | lambda_param_no_default+ '/' ',' 
-//     | lambda_param_no_default+ '/' &':' 
-static asdl_seq* 
-lambda_slash_no_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_param_no_default+ '/' ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_80_rule(p))  // lambda_param_no_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' ','")); 
-    } 
-    { // lambda_param_no_default+ '/' &':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'")); 
-        Token * _literal; 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_81_rule(p))  // lambda_param_no_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' &':'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_slash_with_default: 
-//     | lambda_param_no_default* lambda_param_with_default+ '/' ',' 
-//     | lambda_param_no_default* lambda_param_with_default+ '/' &':' 
-static SlashWithDefault* 
-lambda_slash_with_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    SlashWithDefault* _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_param_no_default* lambda_param_with_default+ '/' ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        if ( 
-            (a = _loop0_82_rule(p))  // lambda_param_no_default* 
-            && 
-            (b = _loop1_83_rule(p))  // lambda_param_with_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','")); 
-            _res = _PyPegen_slash_with_default ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','")); 
-    } 
-    { // lambda_param_no_default* lambda_param_with_default+ '/' &':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'")); 
-        Token * _literal; 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        if ( 
-            (a = _loop0_84_rule(p))  // lambda_param_no_default* 
-            && 
-            (b = _loop1_85_rule(p))  // lambda_param_with_default+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'")); 
-            _res = _PyPegen_slash_with_default ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_star_etc: 
-//     | '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? 
-//     | '*' ',' lambda_param_maybe_default+ lambda_kwds? 
-//     | lambda_kwds 
-//     | invalid_lambda_star_etc 
-static StarEtc* 
-lambda_star_etc_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    StarEtc* _res = NULL; 
-    int _mark = p->mark; 
-    { // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?")); 
-        Token * _literal; 
-        arg_ty a; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-            && 
-            (b = _loop0_86_rule(p))  // lambda_param_maybe_default* 
-            && 
-            (c = lambda_kwds_rule(p), !p->error_indicator)  // lambda_kwds? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?")); 
-            _res = _PyPegen_star_etc ( p , a , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // '*' ',' lambda_param_maybe_default+ lambda_kwds? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * b; 
-        void *c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (b = _loop1_87_rule(p))  // lambda_param_maybe_default+ 
-            && 
-            (c = lambda_kwds_rule(p), !p->error_indicator)  // lambda_kwds? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?")); 
-            _res = _PyPegen_star_etc ( p , NULL , b , c ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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?")); 
-    } 
-    { // lambda_kwds 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds")); 
-        arg_ty a; 
-        if ( 
-            (a = lambda_kwds_rule(p))  // lambda_kwds 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_kwds")); 
-            _res = _PyPegen_star_etc ( p , NULL , NULL , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_kwds")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_lambda_star_etc 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc")); 
-        void *invalid_lambda_star_etc_var; 
-        if ( 
-            (invalid_lambda_star_etc_var = invalid_lambda_star_etc_rule(p))  // invalid_lambda_star_etc 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc")); 
-            _res = invalid_lambda_star_etc_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_kwds: '**' lambda_param_no_default 
-static arg_ty 
-lambda_kwds_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arg_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // '**' lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default")); 
-        Token * _literal; 
-        arg_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (a = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param_no_default")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_param_no_default: lambda_param ',' | lambda_param &':' 
-static arg_ty 
-lambda_param_no_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arg_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_param ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param ','")); 
-        Token * _literal; 
-        arg_ty a; 
-        if ( 
-            (a = lambda_param_rule(p))  // lambda_param 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param ','")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param ','")); 
-    } 
-    { // lambda_param &':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param &':'")); 
-        arg_ty a; 
-        if ( 
-            (a = lambda_param_rule(p))  // lambda_param 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param &':'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param &':'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_param_with_default: lambda_param default ',' | lambda_param default &':' 
-static NameDefaultPair* 
-lambda_param_with_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    NameDefaultPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_param default ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default ','")); 
-        Token * _literal; 
-        arg_ty a; 
-        expr_ty c; 
-        if ( 
-            (a = lambda_param_rule(p))  // lambda_param 
-            && 
-            (c = default_rule(p))  // default 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default ','")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , NULL ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default ','")); 
-    } 
-    { // lambda_param default &':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'")); 
-        arg_ty a; 
-        expr_ty c; 
-        if ( 
-            (a = lambda_param_rule(p))  // lambda_param 
-            && 
-            (c = default_rule(p))  // default 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , NULL ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default &':'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':' 
-static NameDefaultPair* 
-lambda_param_maybe_default_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    NameDefaultPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_param default? ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','")); 
-        Token * _literal; 
-        arg_ty a; 
-        void *c; 
-        if ( 
-            (a = lambda_param_rule(p))  // lambda_param 
-            && 
-            (c = default_rule(p), !p->error_indicator)  // default? 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , NULL ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? ','")); 
-    } 
-    { // lambda_param default? &':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'")); 
-        arg_ty a; 
-        void *c; 
-        if ( 
-            (a = lambda_param_rule(p))  // lambda_param 
-            && 
-            (c = default_rule(p), !p->error_indicator)  // default? 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'")); 
-            _res = _PyPegen_name_default_pair ( p , a , c , NULL ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? &':'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lambda_param: NAME 
-static arg_ty 
-lambda_param_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    arg_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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); 
-        expr_ty a; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_arg ( a -> v . Name . id , NULL , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lambda_param[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// disjunction: conjunction (('or' conjunction))+ | conjunction 
-static expr_ty 
-disjunction_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, disjunction_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // conjunction (('or' conjunction))+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+")); 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = conjunction_rule(p))  // conjunction 
-            && 
-            (b = _loop1_88_rule(p))  // (('or' conjunction))+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BoolOp ( Or , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction (('or' conjunction))+")); 
-    } 
-    { // conjunction 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction")); 
-        expr_ty conjunction_var; 
-        if ( 
-            (conjunction_var = conjunction_rule(p))  // conjunction 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction")); 
-            _res = conjunction_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, disjunction_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// conjunction: inversion (('and' inversion))+ | inversion 
-static expr_ty 
-conjunction_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, conjunction_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // inversion (('and' inversion))+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+")); 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = inversion_rule(p))  // inversion 
-            && 
-            (b = _loop1_89_rule(p))  // (('and' inversion))+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BoolOp ( And , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion (('and' inversion))+")); 
-    } 
-    { // inversion 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion")); 
-        expr_ty inversion_var; 
-        if ( 
-            (inversion_var = inversion_rule(p))  // inversion 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion")); 
-            _res = inversion_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, conjunction_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// inversion: 'not' inversion | comparison 
-static expr_ty 
-inversion_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, inversion_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'not' inversion 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion")); 
-        Token * _keyword; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 526))  // token='not' 
-            && 
-            (a = inversion_rule(p))  // inversion 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_UnaryOp ( Not , a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion")); 
-    } 
-    { // comparison 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison")); 
-        expr_ty comparison_var; 
-        if ( 
-            (comparison_var = comparison_rule(p))  // comparison 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "comparison")); 
-            _res = comparison_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, inversion_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or 
-static expr_ty 
-comparison_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // bitwise_or compare_op_bitwise_or_pair+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-            && 
-            (b = _loop1_90_rule(p))  // compare_op_bitwise_or_pair+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Compare ( a , CHECK ( _PyPegen_get_cmpops ( p , b ) ) , CHECK ( _PyPegen_get_exprs ( p , b ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+")); 
-    } 
-    { // bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or")); 
-        expr_ty bitwise_or_var; 
-        if ( 
-            (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or")); 
-            _res = bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// compare_op_bitwise_or_pair: 
-//     | eq_bitwise_or 
-//     | noteq_bitwise_or 
-//     | lte_bitwise_or 
-//     | lt_bitwise_or 
-//     | gte_bitwise_or 
-//     | gt_bitwise_or 
-//     | notin_bitwise_or 
-//     | in_bitwise_or 
-//     | isnot_bitwise_or 
-//     | is_bitwise_or 
-static CmpopExprPair* 
-compare_op_bitwise_or_pair_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // eq_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or")); 
-        CmpopExprPair* eq_bitwise_or_var; 
-        if ( 
-            (eq_bitwise_or_var = eq_bitwise_or_rule(p))  // eq_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or")); 
-            _res = eq_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "eq_bitwise_or")); 
-    } 
-    { // noteq_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or")); 
-        CmpopExprPair* noteq_bitwise_or_var; 
-        if ( 
-            (noteq_bitwise_or_var = noteq_bitwise_or_rule(p))  // noteq_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or")); 
-            _res = noteq_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "noteq_bitwise_or")); 
-    } 
-    { // lte_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or")); 
-        CmpopExprPair* lte_bitwise_or_var; 
-        if ( 
-            (lte_bitwise_or_var = lte_bitwise_or_rule(p))  // lte_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or")); 
-            _res = lte_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lte_bitwise_or")); 
-    } 
-    { // lt_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or")); 
-        CmpopExprPair* lt_bitwise_or_var; 
-        if ( 
-            (lt_bitwise_or_var = lt_bitwise_or_rule(p))  // lt_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or")); 
-            _res = lt_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lt_bitwise_or")); 
-    } 
-    { // gte_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or")); 
-        CmpopExprPair* gte_bitwise_or_var; 
-        if ( 
-            (gte_bitwise_or_var = gte_bitwise_or_rule(p))  // gte_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or")); 
-            _res = gte_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gte_bitwise_or")); 
-    } 
-    { // gt_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or")); 
-        CmpopExprPair* gt_bitwise_or_var; 
-        if ( 
-            (gt_bitwise_or_var = gt_bitwise_or_rule(p))  // gt_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or")); 
-            _res = gt_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gt_bitwise_or")); 
-    } 
-    { // notin_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or")); 
-        CmpopExprPair* notin_bitwise_or_var; 
-        if ( 
-            (notin_bitwise_or_var = notin_bitwise_or_rule(p))  // notin_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or")); 
-            _res = notin_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "notin_bitwise_or")); 
-    } 
-    { // in_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "in_bitwise_or")); 
-        CmpopExprPair* in_bitwise_or_var; 
-        if ( 
-            (in_bitwise_or_var = in_bitwise_or_rule(p))  // in_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in_bitwise_or")); 
-            _res = in_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // isnot_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or")); 
-        CmpopExprPair* isnot_bitwise_or_var; 
-        if ( 
-            (isnot_bitwise_or_var = isnot_bitwise_or_rule(p))  // isnot_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or")); 
-            _res = isnot_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "isnot_bitwise_or")); 
-    } 
-    { // is_bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "is_bitwise_or")); 
-        CmpopExprPair* is_bitwise_or_var; 
-        if ( 
-            (is_bitwise_or_var = is_bitwise_or_rule(p))  // is_bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "is_bitwise_or")); 
-            _res = is_bitwise_or_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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_bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// eq_bitwise_or: '==' bitwise_or 
-static CmpopExprPair* 
-eq_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // '==' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 27))  // token='==' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , Eq , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s eq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// noteq_bitwise_or: ('!=') bitwise_or 
-static CmpopExprPair* 
-noteq_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // ('!=') bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or")); 
-        void *_tmp_91_var; 
-        expr_ty a; 
-        if ( 
-            (_tmp_91_var = _tmp_91_rule(p))  // '!=' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s noteq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lte_bitwise_or: '<=' bitwise_or 
-static CmpopExprPair* 
-lte_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // '<=' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 29))  // token='<=' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , LtE , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// lt_bitwise_or: '<' bitwise_or 
-static CmpopExprPair* 
-lt_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // '<' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 20))  // token='<' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , Lt , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s lt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// gte_bitwise_or: '>=' bitwise_or 
-static CmpopExprPair* 
-gte_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // '>=' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 30))  // token='>=' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , GtE , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s gte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// gt_bitwise_or: '>' bitwise_or 
-static CmpopExprPair* 
-gt_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // '>' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 21))  // token='>' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , Gt , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s gt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// notin_bitwise_or: 'not' 'in' bitwise_or 
-static CmpopExprPair* 
-notin_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // 'not' 'in' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or")); 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 526))  // token='not' 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s notin_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// in_bitwise_or: 'in' bitwise_or 
-static CmpopExprPair* 
-in_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // 'in' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or")); 
-        Token * _keyword; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 518))  // token='in' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , In , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s in_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// isnot_bitwise_or: 'is' 'not' bitwise_or 
-static CmpopExprPair* 
-isnot_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // 'is' 'not' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or")); 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 527))  // token='is' 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 526))  // token='not' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s isnot_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// is_bitwise_or: 'is' bitwise_or 
-static CmpopExprPair* 
-is_bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    CmpopExprPair* _res = NULL; 
-    int _mark = p->mark; 
-    { // 'is' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or")); 
-        Token * _keyword; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 527))  // token='is' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or")); 
-            _res = _PyPegen_cmpop_expr_pair ( p , Is , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s is_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' bitwise_or")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor 
-static expr_ty bitwise_or_raw(Parser *); 
-static expr_ty 
-bitwise_or_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_1 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res); 
-        if (tmpvar_1) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = bitwise_or_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-bitwise_or_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // bitwise_or '|' bitwise_xor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-            && 
-            (_literal = _PyPegen_expect_token(p, 18))  // token='|' 
-            && 
-            (b = bitwise_xor_rule(p))  // bitwise_xor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , BitOr , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or '|' bitwise_xor")); 
-    } 
-    { // bitwise_xor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor")); 
-        expr_ty bitwise_xor_var; 
-        if ( 
-            (bitwise_xor_var = bitwise_xor_rule(p))  // bitwise_xor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor")); 
-            _res = bitwise_xor_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and 
-static expr_ty bitwise_xor_raw(Parser *); 
-static expr_ty 
-bitwise_xor_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res); 
-        if (tmpvar_2) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = bitwise_xor_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-bitwise_xor_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // bitwise_xor '^' bitwise_and 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = bitwise_xor_rule(p))  // bitwise_xor 
-            && 
-            (_literal = _PyPegen_expect_token(p, 32))  // token='^' 
-            && 
-            (b = bitwise_and_rule(p))  // bitwise_and 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , BitXor , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor '^' bitwise_and")); 
-    } 
-    { // bitwise_and 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and")); 
-        expr_ty bitwise_and_var; 
-        if ( 
-            (bitwise_and_var = bitwise_and_rule(p))  // bitwise_and 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and")); 
-            _res = bitwise_and_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// bitwise_and: bitwise_and '&' shift_expr | shift_expr 
-static expr_ty bitwise_and_raw(Parser *); 
-static expr_ty 
-bitwise_and_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res); 
-        if (tmpvar_3) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = bitwise_and_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-bitwise_and_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // bitwise_and '&' shift_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = bitwise_and_rule(p))  // bitwise_and 
-            && 
-            (_literal = _PyPegen_expect_token(p, 19))  // token='&' 
-            && 
-            (b = shift_expr_rule(p))  // shift_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , BitAnd , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and '&' shift_expr")); 
-    } 
-    { // shift_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr")); 
-        expr_ty shift_expr_var; 
-        if ( 
-            (shift_expr_var = shift_expr_rule(p))  // shift_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr")); 
-            _res = shift_expr_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | sum 
-static expr_ty shift_expr_raw(Parser *); 
-static expr_ty 
-shift_expr_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_4 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res); 
-        if (tmpvar_4) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = shift_expr_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-shift_expr_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // shift_expr '<<' sum 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = shift_expr_rule(p))  // shift_expr 
-            && 
-            (_literal = _PyPegen_expect_token(p, 33))  // token='<<' 
-            && 
-            (b = sum_rule(p))  // sum 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , LShift , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '<<' sum")); 
-    } 
-    { // shift_expr '>>' sum 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = shift_expr_rule(p))  // shift_expr 
-            && 
-            (_literal = _PyPegen_expect_token(p, 34))  // token='>>' 
-            && 
-            (b = sum_rule(p))  // sum 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , RShift , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '>>' sum")); 
-    } 
-    { // sum 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum")); 
-        expr_ty sum_var; 
-        if ( 
-            (sum_var = sum_rule(p))  // sum 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum")); 
-            _res = sum_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// sum: sum '+' term | sum '-' term | term 
-static expr_ty sum_raw(Parser *); 
-static expr_ty 
-sum_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, sum_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_5 = _PyPegen_update_memo(p, _mark, sum_type, _res); 
-        if (tmpvar_5) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = sum_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-sum_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // sum '+' term 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = sum_rule(p))  // sum 
-            && 
-            (_literal = _PyPegen_expect_token(p, 14))  // token='+' 
-            && 
-            (b = term_rule(p))  // term 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , Add , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '+' term")); 
-    } 
-    { // sum '-' term 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = sum_rule(p))  // sum 
-            && 
-            (_literal = _PyPegen_expect_token(p, 15))  // token='-' 
-            && 
-            (b = term_rule(p))  // term 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , Sub , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '-' term")); 
-    } 
-    { // term 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term")); 
-        expr_ty term_var; 
-        if ( 
-            (term_var = term_rule(p))  // term 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term")); 
-            _res = term_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// term: 
-//     | term '*' factor 
-//     | term '/' factor 
-//     | term '//' factor 
-//     | term '%' factor 
-//     | term '@' factor 
-//     | factor 
-static expr_ty term_raw(Parser *); 
-static expr_ty 
-term_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, term_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_6 = _PyPegen_update_memo(p, _mark, term_type, _res); 
-        if (tmpvar_6) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = term_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-term_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // term '*' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = term_rule(p))  // term 
-            && 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (b = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , Mult , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '*' factor")); 
-    } 
-    { // term '/' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = term_rule(p))  // term 
-            && 
-            (_literal = _PyPegen_expect_token(p, 17))  // token='/' 
-            && 
-            (b = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , Div , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '/' factor")); 
-    } 
-    { // term '//' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = term_rule(p))  // term 
-            && 
-            (_literal = _PyPegen_expect_token(p, 47))  // token='//' 
-            && 
-            (b = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , FloorDiv , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '//' factor")); 
-    } 
-    { // term '%' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = term_rule(p))  // term 
-            && 
-            (_literal = _PyPegen_expect_token(p, 24))  // token='%' 
-            && 
-            (b = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , Mod , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '%' factor")); 
-    } 
-    { // term '@' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = term_rule(p))  // term 
-            && 
-            (_literal = _PyPegen_expect_token(p, 49))  // token='@' 
-            && 
-            (b = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 5 , "The '@' operator is" , _Py_BinOp ( a , MatMult , b , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '@' factor")); 
-    } 
-    { // factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor")); 
-        expr_ty factor_var; 
-        if ( 
-            (factor_var = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor")); 
-            _res = factor_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// factor: '+' factor | '-' factor | '~' factor | power 
-static expr_ty 
-factor_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, factor_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '+' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 14))  // token='+' 
-            && 
-            (a = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_UnaryOp ( UAdd , a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor")); 
-    } 
-    { // '-' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 15))  // token='-' 
-            && 
-            (a = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_UnaryOp ( USub , a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor")); 
-    } 
-    { // '~' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 31))  // token='~' 
-            && 
-            (a = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_UnaryOp ( Invert , a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor")); 
-    } 
-    { // power 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power")); 
-        expr_ty power_var; 
-        if ( 
-            (power_var = power_rule(p))  // power 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power")); 
-            _res = power_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, factor_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// power: await_primary '**' factor | await_primary 
-static expr_ty 
-power_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // await_primary '**' factor 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = await_primary_rule(p))  // await_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (b = factor_rule(p))  // factor 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_BinOp ( a , Pow , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary '**' factor")); 
-    } 
-    { // await_primary 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary")); 
-        expr_ty await_primary_var; 
-        if ( 
-            (await_primary_var = await_primary_rule(p))  // await_primary 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary")); 
-            _res = await_primary_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// await_primary: AWAIT primary | primary 
-static expr_ty 
-await_primary_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, await_primary_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // AWAIT primary 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AWAIT primary")); 
-        expr_ty a; 
-        Token * await_var; 
-        if ( 
-            (await_var = _PyPegen_expect_token(p, AWAIT))  // token='AWAIT' 
-            && 
-            (a = primary_rule(p))  // primary 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AWAIT primary")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = CHECK_VERSION ( 5 , "Await expressions are" , _Py_Await ( a , EXTRA ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "AWAIT primary")); 
-    } 
-    { // primary 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary")); 
-        expr_ty primary_var; 
-        if ( 
-            (primary_var = primary_rule(p))  // primary 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary")); 
-            _res = primary_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, await_primary_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// primary: 
-//     | invalid_primary 
-//     | primary '.' NAME 
-//     | primary genexp 
-//     | primary '(' arguments? ')' 
-//     | primary '[' slices ']' 
-//     | atom 
-static expr_ty primary_raw(Parser *); 
-static expr_ty 
-primary_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, primary_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_7 = _PyPegen_update_memo(p, _mark, primary_type, _res); 
-        if (tmpvar_7) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = primary_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-primary_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    if (p->call_invalid_rules) { // invalid_primary 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_primary")); 
-        void *invalid_primary_var; 
-        if ( 
-            (invalid_primary_var = invalid_primary_rule(p))  // invalid_primary 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_primary")); 
-            _res = invalid_primary_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_primary")); 
-    } 
-    { // primary '.' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = primary_rule(p))  // primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-            && 
-            (b = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '.' NAME")); 
-    } 
-    { // primary genexp 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp")); 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = primary_rule(p))  // primary 
-            && 
-            (b = genexp_rule(p))  // genexp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary genexp")); 
-    } 
-    { // primary '(' arguments? ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (a = primary_rule(p))  // primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (b = arguments_rule(p), !p->error_indicator)  // arguments? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '(' arguments? ')'")); 
-    } 
-    { // primary '[' slices ']' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = primary_rule(p))  // primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (b = slices_rule(p))  // slices 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Subscript ( a , b , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '[' slices ']'")); 
-    } 
-    { // atom 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom")); 
-        expr_ty atom_var; 
-        if ( 
-            (atom_var = atom_rule(p))  // atom 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom")); 
-            _res = atom_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// slices: slice !',' | ','.slice+ ','? 
-static expr_ty 
-slices_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // slice !',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','")); 
-        expr_ty a; 
-        if ( 
-            (a = slice_rule(p))  // slice 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !','")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','")); 
-    } 
-    { // ','.slice+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_92_rule(p))  // ','.slice+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( a , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.slice+ ','?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// slice: expression? ':' expression? [':' expression?] | expression 
-static expr_ty 
-slice_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // expression? ':' expression? [':' expression?] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]")); 
-        Token * _literal; 
-        void *a; 
-        void *b; 
-        void *c; 
-        if ( 
-            (a = expression_rule(p), !p->error_indicator)  // expression? 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = expression_rule(p), !p->error_indicator)  // expression? 
-            && 
-            (c = _tmp_94_rule(p), !p->error_indicator)  // [':' expression?] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Slice ( a , b , c , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]")); 
-    } 
-    { // expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression")); 
-        expr_ty a; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// atom: 
-//     | NAME 
-//     | 'True' 
-//     | 'False' 
-//     | 'None' 
-//     | '__peg_parser__' 
-//     | &STRING strings 
-//     | NUMBER 
-//     | &'(' (tuple | group | genexp) 
-//     | &'[' (list | listcomp) 
-//     | &'{' (dict | set | dictcomp | setcomp) 
-//     | '...' 
-static expr_ty 
-atom_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); 
-        expr_ty name_var; 
-        if ( 
-            (name_var = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); 
-            _res = name_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); 
-    } 
-    { // 'True' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 528))  // token='True' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Constant ( Py_True , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'")); 
-    } 
-    { // 'False' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 529))  // token='False' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Constant ( Py_False , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'")); 
-    } 
-    { // 'None' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 530))  // token='None' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Constant ( Py_None , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'")); 
-    } 
-    { // '__peg_parser__' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'__peg_parser__'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 531))  // token='__peg_parser__' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'__peg_parser__'")); 
-            _res = RAISE_SYNTAX_ERROR ( "You found it!" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'__peg_parser__'")); 
-    } 
-    { // &STRING strings 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings")); 
-        expr_ty strings_var; 
-        if ( 
-            _PyPegen_lookahead(1, _PyPegen_string_token, p) 
-            && 
-            (strings_var = strings_rule(p))  // strings 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING strings")); 
-            _res = strings_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&STRING strings")); 
-    } 
-    { // NUMBER 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER")); 
-        expr_ty number_var; 
-        if ( 
-            (number_var = _PyPegen_number_token(p))  // NUMBER 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER")); 
-            _res = number_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER")); 
-    } 
-    { // &'(' (tuple | group | genexp) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)")); 
-        void *_tmp_95_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7)  // token='(' 
-            && 
-            (_tmp_95_var = _tmp_95_rule(p))  // tuple | group | genexp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)")); 
-            _res = _tmp_95_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)")); 
-    } 
-    { // &'[' (list | listcomp) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)")); 
-        void *_tmp_96_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9)  // token='[' 
-            && 
-            (_tmp_96_var = _tmp_96_rule(p))  // list | listcomp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)")); 
-            _res = _tmp_96_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)")); 
-    } 
-    { // &'{' (dict | set | dictcomp | setcomp) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); 
-        void *_tmp_97_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25)  // token='{' 
-            && 
-            (_tmp_97_var = _tmp_97_rule(p))  // dict | set | dictcomp | setcomp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); 
-            _res = _tmp_97_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)")); 
-    } 
-    { // '...' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 52))  // token='...' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Constant ( Py_Ellipsis , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// strings: STRING+ 
-static expr_ty 
-strings_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, strings_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    { // STRING+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+")); 
-        asdl_seq * a; 
-        if ( 
-            (a = _loop1_98_rule(p))  // STRING+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+")); 
-            _res = _PyPegen_concatenate_strings ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING+")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, strings_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// list: '[' star_named_expressions? ']' 
-static expr_ty 
-list_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '[' star_named_expressions? ']' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (a = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_List ( a , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// listcomp: '[' named_expression ~ for_if_clauses ']' | invalid_comprehension 
-static expr_ty 
-listcomp_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '[' named_expression ~ for_if_clauses ']' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'")); 
-        int _cut_var = 0; 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        asdl_seq* b; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_cut_var = 1) 
-            && 
-            (b = for_if_clauses_rule(p))  // for_if_clauses 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_ListComp ( a , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    if (p->call_invalid_rules) { // invalid_comprehension 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); 
-        void *invalid_comprehension_var; 
-        if ( 
-            (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); 
-            _res = invalid_comprehension_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// tuple: '(' [star_named_expression ',' star_named_expressions?] ')' 
-static expr_ty 
-tuple_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '(' [star_named_expression ',' star_named_expressions?] ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = _tmp_99_rule(p), !p->error_indicator)  // [star_named_expression ',' star_named_expressions?] 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( a , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// group: '(' (yield_expr | named_expression) ')' | invalid_group 
-static expr_ty 
-group_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' (yield_expr | named_expression) ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = _tmp_100_rule(p))  // yield_expr | named_expression 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (yield_expr | named_expression) ')'")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_group 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group")); 
-        void *invalid_group_var; 
-        if ( 
-            (invalid_group_var = invalid_group_rule(p))  // invalid_group 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_group")); 
-            _res = invalid_group_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_group")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// genexp: '(' named_expression ~ for_if_clauses ')' | invalid_comprehension 
-static expr_ty 
-genexp_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '(' named_expression ~ for_if_clauses ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'")); 
-        int _cut_var = 0; 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        asdl_seq* b; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_cut_var = 1) 
-            && 
-            (b = for_if_clauses_rule(p))  // for_if_clauses 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_GeneratorExp ( a , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    if (p->call_invalid_rules) { // invalid_comprehension 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); 
-        void *invalid_comprehension_var; 
-        if ( 
-            (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); 
-            _res = invalid_comprehension_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// set: '{' star_named_expressions '}' 
-static expr_ty 
-set_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '{' star_named_expressions '}' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq* a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 25))  // token='{' 
-            && 
-            (a = star_named_expressions_rule(p))  // star_named_expressions 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Set ( a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// setcomp: '{' named_expression ~ for_if_clauses '}' | invalid_comprehension 
-static expr_ty 
-setcomp_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '{' named_expression ~ for_if_clauses '}' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'")); 
-        int _cut_var = 0; 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        asdl_seq* b; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 25))  // token='{' 
-            && 
-            (a = named_expression_rule(p))  // named_expression 
-            && 
-            (_cut_var = 1) 
-            && 
-            (b = for_if_clauses_rule(p))  // for_if_clauses 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_SetComp ( a , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    if (p->call_invalid_rules) { // invalid_comprehension 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); 
-        void *invalid_comprehension_var; 
-        if ( 
-            (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension")); 
-            _res = invalid_comprehension_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// dict: '{' double_starred_kvpairs? '}' 
-static expr_ty 
-dict_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '{' double_starred_kvpairs? '}' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 25))  // token='{' 
-            && 
-            (a = double_starred_kvpairs_rule(p), !p->error_indicator)  // double_starred_kvpairs? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Dict ( CHECK ( _PyPegen_get_keys ( p , a ) ) , CHECK ( _PyPegen_get_values ( p , a ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_starred_kvpairs? '}'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension 
-static expr_ty 
-dictcomp_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '{' kvpair for_if_clauses '}' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        KeyValuePair* a; 
-        asdl_seq* b; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 25))  // token='{' 
-            && 
-            (a = kvpair_rule(p))  // kvpair 
-            && 
-            (b = for_if_clauses_rule(p))  // for_if_clauses 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_DictComp ( a -> key , a -> value , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_dict_comprehension 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension")); 
-        void *invalid_dict_comprehension_var; 
-        if ( 
-            (invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p))  // invalid_dict_comprehension 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension")); 
-            _res = invalid_dict_comprehension_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// double_starred_kvpairs: ','.double_starred_kvpair+ ','? 
-static asdl_seq* 
-double_starred_kvpairs_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.double_starred_kvpair+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_101_rule(p))  // ','.double_starred_kvpair+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ','?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// double_starred_kvpair: '**' bitwise_or | kvpair 
-static KeyValuePair* 
-double_starred_kvpair_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    KeyValuePair* _res = NULL; 
-    int _mark = p->mark; 
-    { // '**' bitwise_or 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (a = bitwise_or_rule(p))  // bitwise_or 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or")); 
-            _res = _PyPegen_key_value_pair ( p , NULL , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or")); 
-    } 
-    { // kvpair 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpair")); 
-        KeyValuePair* kvpair_var; 
-        if ( 
-            (kvpair_var = kvpair_rule(p))  // kvpair 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kvpair")); 
-            _res = kvpair_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// kvpair: expression ':' expression 
-static KeyValuePair* 
-kvpair_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    KeyValuePair* _res = NULL; 
-    int _mark = p->mark; 
-    { // expression ':' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); 
-            _res = _PyPegen_key_value_pair ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s kvpair[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// for_if_clauses: for_if_clause+ 
-static asdl_seq* 
-for_if_clauses_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // for_if_clause+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); 
-        asdl_seq * _loop1_103_var; 
-        if ( 
-            (_loop1_103_var = _loop1_103_rule(p))  // for_if_clause+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+")); 
-            _res = _loop1_103_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s for_if_clauses[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// for_if_clause: 
-//     | ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* 
-//     | 'for' star_targets 'in' ~ disjunction (('if' disjunction))* 
-//     | invalid_for_target 
-static comprehension_ty 
-for_if_clause_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    comprehension_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); 
-        int _cut_var = 0; 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        expr_ty a; 
-        Token * async_var; 
-        expr_ty b; 
-        asdl_seq * c; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 517))  // token='for' 
-            && 
-            (a = star_targets_rule(p))  // star_targets 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in' 
-            && 
-            (_cut_var = 1) 
-            && 
-            (b = disjunction_rule(p))  // disjunction 
-            && 
-            (c = _loop0_104_rule(p))  // (('if' disjunction))* 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); 
-            _res = CHECK_VERSION ( 6 , "Async comprehensions are" , _Py_comprehension ( a , b , c , 1 , p -> arena ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))* 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); 
-        int _cut_var = 0; 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        expr_ty a; 
-        expr_ty b; 
-        asdl_seq * c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 517))  // token='for' 
-            && 
-            (a = star_targets_rule(p))  // star_targets 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in' 
-            && 
-            (_cut_var = 1) 
-            && 
-            (b = disjunction_rule(p))  // disjunction 
-            && 
-            (c = _loop0_105_rule(p))  // (('if' disjunction))* 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); 
-            _res = _Py_comprehension ( a , b , c , 0 , p -> arena ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*")); 
-        if (_cut_var) { 
-            p->level--; 
-            return NULL; 
-        } 
-    } 
-    if (p->call_invalid_rules) { // invalid_for_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); 
-        void *invalid_for_target_var; 
-        if ( 
-            (invalid_for_target_var = invalid_for_target_rule(p))  // invalid_for_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target")); 
-            _res = invalid_for_target_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// yield_expr: 'yield' 'from' expression | 'yield' star_expressions? 
-static expr_ty 
-yield_expr_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // 'yield' 'from' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression")); 
-        Token * _keyword; 
-        Token * _keyword_1; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 504))  // token='yield' 
-            && 
-            (_keyword_1 = _PyPegen_expect_token(p, 514))  // token='from' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_YieldFrom ( a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' 'from' expression")); 
-    } 
-    { // 'yield' star_expressions? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?")); 
-        Token * _keyword; 
-        void *a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 504))  // token='yield' 
-            && 
-            (a = star_expressions_rule(p), !p->error_indicator)  // star_expressions? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Yield ( a , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' star_expressions?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// arguments: args ','? &')' | invalid_arguments 
-static expr_ty 
-arguments_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, arguments_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    { // args ','? &')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        if ( 
-            (a = args_rule(p))  // args 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-            && 
-            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','? &')'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'")); 
-    } 
-    if (p->call_invalid_rules) { // invalid_arguments 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments")); 
-        void *invalid_arguments_var; 
-        if ( 
-            (invalid_arguments_var = invalid_arguments_rule(p))  // invalid_arguments 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_arguments")); 
-            _res = invalid_arguments_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arguments")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, arguments_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// args: ','.(starred_expression | named_expression !'=')+ [',' kwargs] | kwargs 
-static expr_ty 
-args_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // ','.(starred_expression | named_expression !'=')+ [',' kwargs] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]")); 
-        asdl_seq * a; 
-        void *b; 
-        if ( 
-            (a = _gather_106_rule(p))  // ','.(starred_expression | named_expression !'=')+ 
-            && 
-            (b = _tmp_108_rule(p), !p->error_indicator)  // [',' kwargs] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]")); 
-    } 
-    { // kwargs 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs")); 
-        asdl_seq* a; 
-        if ( 
-            (a = kwargs_rule(p))  // kwargs 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// kwargs: 
-//     | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+ 
-//     | ','.kwarg_or_starred+ 
-//     | ','.kwarg_or_double_starred+ 
-static asdl_seq* 
-kwargs_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); 
-        Token * _literal; 
-        asdl_seq * a; 
-        asdl_seq * b; 
-        if ( 
-            (a = _gather_109_rule(p))  // ','.kwarg_or_starred+ 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (b = _gather_111_rule(p))  // ','.kwarg_or_double_starred+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+")); 
-            _res = _PyPegen_join_sequences ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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+")); 
-    } 
-    { // ','.kwarg_or_starred+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); 
-        asdl_seq * _gather_113_var; 
-        if ( 
-            (_gather_113_var = _gather_113_rule(p))  // ','.kwarg_or_starred+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+")); 
-            _res = _gather_113_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); 
-        asdl_seq * _gather_115_var; 
-        if ( 
-            (_gather_115_var = _gather_115_rule(p))  // ','.kwarg_or_double_starred+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+")); 
-            _res = _gather_115_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_double_starred+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// starred_expression: '*' expression 
-static expr_ty 
-starred_expression_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '*' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Starred ( a , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// kwarg_or_starred: NAME '=' expression | starred_expression | invalid_kwarg 
-static KeywordOrStarred* 
-kwarg_or_starred_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    KeywordOrStarred* _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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME '=' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression")); 
-    } 
-    { // starred_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); 
-        expr_ty a; 
-        if ( 
-            (a = starred_expression_rule(p))  // starred_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); 
-            _res = _PyPegen_keyword_or_starred ( p , a , 0 ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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) { // invalid_kwarg 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); 
-        void *invalid_kwarg_var; 
-        if ( 
-            (invalid_kwarg_var = invalid_kwarg_rule(p))  // invalid_kwarg 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); 
-            _res = invalid_kwarg_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// kwarg_or_double_starred: NAME '=' expression | '**' expression | invalid_kwarg 
-static KeywordOrStarred* 
-kwarg_or_double_starred_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    KeywordOrStarred* _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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME '=' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-            && 
-            (b = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // '**' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( NULL , a , EXTRA ) ) , 1 ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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) { // invalid_kwarg 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); 
-        void *invalid_kwarg_var; 
-        if ( 
-            (invalid_kwarg_var = invalid_kwarg_rule(p))  // invalid_kwarg 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg")); 
-            _res = invalid_kwarg_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_targets: star_target !',' | star_target ((',' star_target))* ','? 
-static expr_ty 
-star_targets_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // star_target !',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !','")); 
-        expr_ty a; 
-        if ( 
-            (a = star_target_rule(p))  // star_target 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target !','")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target !','")); 
-    } 
-    { // star_target ((',' star_target))* ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = star_target_rule(p))  // star_target 
-            && 
-            (b = _loop0_117_rule(p))  // ((',' star_target))* 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))* ','?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_targets_list_seq: ','.star_target+ ','? 
-static asdl_seq* 
-star_targets_list_seq_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.star_target+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_118_rule(p))  // ','.star_target+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_targets_list_seq[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_target+ ','?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ',' 
-static asdl_seq* 
-star_targets_tuple_seq_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // star_target ((',' star_target))+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        asdl_seq * b; 
-        if ( 
-            (a = star_target_rule(p))  // star_target 
-            && 
-            (b = _loop1_120_rule(p))  // ((',' star_target))+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?")); 
-            _res = _PyPegen_seq_insert_in_front ( p , a , b ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))+ ','?")); 
-    } 
-    { // star_target ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ','")); 
-        Token * _literal; 
-        expr_ty a; 
-        if ( 
-            (a = star_target_rule(p))  // star_target 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ','")); 
-            _res = _PyPegen_singleton_seq ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ','")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_target: '*' (!'*' star_target) | target_with_star_atom 
-static expr_ty 
-star_target_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, star_target_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // '*' (!'*' star_target) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); 
-        Token * _literal; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (a = _tmp_121_rule(p))  // !'*' star_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Starred ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)")); 
-    } 
-    { // target_with_star_atom 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_star_atom")); 
-        expr_ty target_with_star_atom_var; 
-        if ( 
-            (target_with_star_atom_var = target_with_star_atom_rule(p))  // target_with_star_atom 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "target_with_star_atom")); 
-            _res = target_with_star_atom_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target_with_star_atom")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, star_target_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// target_with_star_atom: 
-//     | t_primary '.' NAME !t_lookahead 
-//     | t_primary '[' slices ']' !t_lookahead 
-//     | star_atom 
-static expr_ty 
-target_with_star_atom_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // t_primary '.' NAME !t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-            && 
-            (b = _PyPegen_name_token(p))  // NAME 
-            && 
-            _PyPegen_lookahead(0, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-    } 
-    { // t_primary '[' slices ']' !t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (b = slices_rule(p))  // slices 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-            && 
-            _PyPegen_lookahead(0, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Subscript ( a , b , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-    } 
-    { // star_atom 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_atom")); 
-        expr_ty star_atom_var; 
-        if ( 
-            (star_atom_var = star_atom_rule(p))  // star_atom 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_atom")); 
-            _res = star_atom_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_atom")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// star_atom: 
-//     | NAME 
-//     | '(' target_with_star_atom ')' 
-//     | '(' star_targets_tuple_seq? ')' 
-//     | '[' star_targets_list_seq? ']' 
-static expr_ty 
-star_atom_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); 
-        expr_ty a; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); 
-            _res = _PyPegen_set_expr_context ( p , a , Store ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); 
-    } 
-    { // '(' target_with_star_atom ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = target_with_star_atom_rule(p))  // target_with_star_atom 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'")); 
-            _res = _PyPegen_set_expr_context ( p , a , Store ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' target_with_star_atom ')'")); 
-    } 
-    { // '(' star_targets_tuple_seq? ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = star_targets_tuple_seq_rule(p), !p->error_indicator)  // star_targets_tuple_seq? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( a , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' star_targets_tuple_seq? ')'")); 
-    } 
-    { // '[' star_targets_list_seq? ']' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (a = star_targets_list_seq_rule(p), !p->error_indicator)  // star_targets_list_seq? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_List ( a , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_targets_list_seq? ']'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// single_target: single_subscript_attribute_target | NAME | '(' single_target ')' 
-static expr_ty 
-single_target_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // single_subscript_attribute_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); 
-        expr_ty single_subscript_attribute_target_var; 
-        if ( 
-            (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p))  // single_subscript_attribute_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); 
-            _res = single_subscript_attribute_target_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target")); 
-    } 
-    { // NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); 
-        expr_ty a; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); 
-            _res = _PyPegen_set_expr_context ( p , a , Store ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); 
-    } 
-    { // '(' single_target ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = single_target_rule(p))  // single_target 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// single_subscript_attribute_target: 
-//     | t_primary '.' NAME !t_lookahead 
-//     | t_primary '[' slices ']' !t_lookahead 
-static expr_ty 
-single_subscript_attribute_target_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // t_primary '.' NAME !t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-            && 
-            (b = _PyPegen_name_token(p))  // NAME 
-            && 
-            _PyPegen_lookahead(0, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-    } 
-    { // t_primary '[' slices ']' !t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (b = slices_rule(p))  // slices 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-            && 
-            _PyPegen_lookahead(0, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Subscript ( a , b , Store , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// del_targets: ','.del_target+ ','? 
-static asdl_seq* 
-del_targets_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq* _res = NULL; 
-    int _mark = p->mark; 
-    { // ','.del_target+ ','? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?")); 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        asdl_seq * a; 
-        if ( 
-            (a = _gather_122_rule(p))  // ','.del_target+ 
-            && 
-            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_targets[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.del_target+ ','?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// del_target: 
-//     | t_primary '.' NAME !t_lookahead 
-//     | t_primary '[' slices ']' !t_lookahead 
-//     | del_t_atom 
-static expr_ty 
-del_target_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, del_target_type, &_res)) { 
-        p->level--; 
-        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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // t_primary '.' NAME !t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-            && 
-            (b = _PyPegen_name_token(p))  // NAME 
-            && 
-            _PyPegen_lookahead(0, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Attribute ( a , b -> v . Name . id , Del , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead")); 
-    } 
-    { // t_primary '[' slices ']' !t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (b = slices_rule(p))  // slices 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-            && 
-            _PyPegen_lookahead(0, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Subscript ( a , b , Del , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead")); 
-    } 
-    { // del_t_atom 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom")); 
-        expr_ty del_t_atom_var; 
-        if ( 
-            (del_t_atom_var = del_t_atom_rule(p))  // del_t_atom 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t_atom")); 
-            _res = del_t_atom_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_t_atom")); 
-    } 
-    _res = NULL; 
-  done: 
-    _PyPegen_insert_memo(p, _mark, del_target_type, _res); 
-    p->level--; 
-    return _res; 
-} 
- 
-// del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']' 
-static expr_ty 
-del_t_atom_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME")); 
-        expr_ty a; 
-        if ( 
-            (a = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME")); 
-            _res = _PyPegen_set_expr_context ( p , a , Del ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME")); 
-    } 
-    { // '(' del_target ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = del_target_rule(p))  // del_target 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'")); 
-            _res = _PyPegen_set_expr_context ( p , a , Del ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_target ')'")); 
-    } 
-    { // '(' del_targets? ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = del_targets_rule(p), !p->error_indicator)  // del_targets? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Tuple ( a , Del , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_targets? ')'")); 
-    } 
-    { // '[' del_targets? ']' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (a = del_targets_rule(p), !p->error_indicator)  // del_targets? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_List ( a , Del , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' del_targets? ']'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// t_primary: 
-//     | t_primary '.' NAME &t_lookahead 
-//     | t_primary '[' slices ']' &t_lookahead 
-//     | t_primary genexp &t_lookahead 
-//     | t_primary '(' arguments? ')' &t_lookahead 
-//     | atom &t_lookahead 
-static expr_ty t_primary_raw(Parser *); 
-static expr_ty 
-t_primary_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    expr_ty _res = NULL; 
-    if (_PyPegen_is_memoized(p, t_primary_type, &_res)) { 
-        p->level--; 
-        return _res; 
-    } 
-    int _mark = p->mark; 
-    int _resmark = p->mark; 
-    while (1) { 
-        int tmpvar_8 = _PyPegen_update_memo(p, _mark, t_primary_type, _res); 
-        if (tmpvar_8) { 
-            p->level--; 
-            return _res; 
-        } 
-        p->mark = _mark; 
-        void *_raw = t_primary_raw(p); 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        if (_raw == NULL || p->mark <= _resmark) 
-            break; 
-        _resmark = p->mark; 
-        _res = _raw; 
-    } 
-    p->mark = _resmark; 
-    p->level--; 
-    return _res; 
-} 
-static expr_ty 
-t_primary_raw(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    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 _start_lineno = p->tokens[_mark]->lineno; 
-    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 
-    { // t_primary '.' NAME &t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-            && 
-            (b = _PyPegen_name_token(p))  // NAME 
-            && 
-            _PyPegen_lookahead(1, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME &t_lookahead")); 
-    } 
-    { // t_primary '[' slices ']' &t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-            && 
-            (b = slices_rule(p))  // slices 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']' 
-            && 
-            _PyPegen_lookahead(1, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Subscript ( a , b , Load , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' &t_lookahead")); 
-    } 
-    { // t_primary genexp &t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead")); 
-        expr_ty a; 
-        expr_ty b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (b = genexp_rule(p))  // genexp 
-            && 
-            _PyPegen_lookahead(1, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary genexp &t_lookahead")); 
-    } 
-    { // t_primary '(' arguments? ')' &t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        void *b; 
-        if ( 
-            (a = t_primary_rule(p))  // t_primary 
-            && 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (b = arguments_rule(p), !p->error_indicator)  // arguments? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-            && 
-            _PyPegen_lookahead(1, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); 
-            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); 
-            if (_token == NULL) { 
-                p->level--; 
-                return NULL; 
-            } 
-            int _end_lineno = _token->end_lineno; 
-            UNUSED(_end_lineno); // Only used by EXTRA macro 
-            int _end_col_offset = _token->end_col_offset; 
-            UNUSED(_end_col_offset); // Only used by EXTRA macro 
-            _res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead")); 
-    } 
-    { // atom &t_lookahead 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead")); 
-        expr_ty a; 
-        if ( 
-            (a = atom_rule(p))  // atom 
-            && 
-            _PyPegen_lookahead(1, t_lookahead_rule, p) 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom &t_lookahead")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// t_lookahead: '(' | '[' | '.' 
-static void * 
-t_lookahead_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); 
-    } 
-    { // '[' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); 
-    } 
-    { // '.' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_arguments: 
-//     | args ',' '*' 
-//     | expression for_if_clauses ',' [args | expression for_if_clauses] 
-//     | args for_if_clauses 
-//     | args ',' expression for_if_clauses 
-//     | args ',' args 
-static void * 
-invalid_arguments_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // args ',' '*' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' '*'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty args_var; 
-        if ( 
-            (args_var = args_rule(p))  // args 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' '*'")); 
-            _res = RAISE_SYNTAX_ERROR ( "iterable argument unpacking follows keyword argument unpacking" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 ',' [args | expression for_if_clauses] 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); 
-        Token * _literal; 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        asdl_seq* for_if_clauses_var; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-            && 
-            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_opt_var = _tmp_124_rule(p), !p->error_indicator)  // [args | expression for_if_clauses] 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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]")); 
-    } 
-    { // args for_if_clauses 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_if_clauses")); 
-        expr_ty a; 
-        asdl_seq* for_if_clauses_var; 
-        if ( 
-            (a = args_rule(p))  // args 
-            && 
-            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args for_if_clauses")); 
-            _res = _PyPegen_nonparen_genexp_in_call ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // args ',' expression for_if_clauses 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty args_var; 
-        asdl_seq* for_if_clauses_var; 
-        if ( 
-            (args_var = args_rule(p))  // args 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (a = expression_rule(p))  // expression 
-            && 
-            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // args ',' args 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' args")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty args_var; 
-        if ( 
-            (a = args_rule(p))  // args 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (args_var = args_rule(p))  // args 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' args")); 
-            _res = _PyPegen_arguments_parsing_error ( p , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' args")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_kwarg: !(NAME '=') expression '=' 
-static void * 
-invalid_kwarg_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // !(NAME '=') expression '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='")); 
-        expr_ty a; 
-        Token * b; 
-        if ( 
-            _PyPegen_lookahead(0, _tmp_125_rule, p) 
-            && 
-            (a = expression_rule(p))  // expression 
-            && 
-            (b = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression cannot contain assignment, perhaps you meant \"==\"?" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_named_expression: expression ':=' expression 
-static void * 
-invalid_named_expression_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // expression ':=' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':=' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty expression_var; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 53))  // token=':=' 
-            && 
-            (expression_var = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':=' expression")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_assignment: 
-//     | invalid_ann_assign_target ':' expression 
-//     | star_named_expression ',' star_named_expressions* ':' expression 
-//     | expression ':' expression 
-//     | ((star_targets '='))* star_expressions '=' 
-//     | ((star_targets '='))* yield_expr '=' 
-//     | star_expressions augassign (yield_expr | star_expressions) 
-static void * 
-invalid_assignment_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // invalid_ann_assign_target ':' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty expression_var; 
-        if ( 
-            (a = invalid_ann_assign_target_rule(p))  // invalid_ann_assign_target 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (expression_var = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // star_named_expression ',' star_named_expressions* ':' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        asdl_seq * _loop0_126_var; 
-        expr_ty a; 
-        expr_ty expression_var; 
-        if ( 
-            (a = star_named_expression_rule(p))  // star_named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_loop0_126_var = _loop0_126_rule(p))  // star_named_expressions* 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (expression_var = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    { // expression ':' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); 
-        Token * _literal; 
-        expr_ty a; 
-        expr_ty expression_var; 
-        if ( 
-            (a = expression_rule(p))  // expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (expression_var = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression")); 
-    } 
-    { // ((star_targets '='))* star_expressions '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='")); 
-        Token * _literal; 
-        asdl_seq * _loop0_127_var; 
-        expr_ty a; 
-        if ( 
-            (_loop0_127_var = _loop0_127_rule(p))  // ((star_targets '='))* 
-            && 
-            (a = star_expressions_rule(p))  // star_expressions 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='")); 
-            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 '='")); 
-    } 
-    { // ((star_targets '='))* yield_expr '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='")); 
-        Token * _literal; 
-        asdl_seq * _loop0_128_var; 
-        expr_ty a; 
-        if ( 
-            (_loop0_128_var = _loop0_128_rule(p))  // ((star_targets '='))* 
-            && 
-            (a = yield_expr_rule(p))  // yield_expr 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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 '='")); 
-    } 
-    { // star_expressions augassign (yield_expr | star_expressions) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)")); 
-        void *_tmp_129_var; 
-        expr_ty a; 
-        AugOperator* augassign_var; 
-        if ( 
-            (a = star_expressions_rule(p))  // star_expressions 
-            && 
-            (augassign_var = augassign_rule(p))  // augassign 
-            && 
-            (_tmp_129_var = _tmp_129_rule(p))  // yield_expr | star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')' 
-static expr_ty 
-invalid_ann_assign_target_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    expr_ty _res = NULL; 
-    int _mark = p->mark; 
-    { // list 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); 
-        expr_ty list_var; 
-        if ( 
-            (list_var = list_rule(p))  // list 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); 
-            _res = list_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); 
-    } 
-    { // tuple 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); 
-        expr_ty tuple_var; 
-        if ( 
-            (tuple_var = tuple_rule(p))  // tuple 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); 
-            _res = tuple_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); 
-    } 
-    { // '(' invalid_ann_assign_target ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = invalid_ann_assign_target_rule(p))  // invalid_ann_assign_target 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'")); 
-            _res = a; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' invalid_ann_assign_target ')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_del_stmt: 'del' star_expressions 
-static void * 
-invalid_del_stmt_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'del' star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star_expressions")); 
-        Token * _keyword; 
-        expr_ty a; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 503))  // token='del' 
-            && 
-            (a = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' star_expressions")); 
-            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_del_stmt[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_block: NEWLINE !INDENT 
-static void * 
-invalid_block_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // NEWLINE !INDENT 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT")); 
-        Token * newline_var; 
-        if ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT")); 
-            _res = RAISE_INDENTATION_ERROR ( "expected an indented block" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_block[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE !INDENT")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// Left-recursive 
-// invalid_primary: primary '{' 
-static void * 
-invalid_primary_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // primary '{' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '{'")); 
-        Token * a; 
-        expr_ty primary_var; 
-        if ( 
-            (primary_var = primary_rule(p))  // primary 
-            && 
-            (a = _PyPegen_expect_token(p, 25))  // token='{' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '{'")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid syntax" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_primary[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '{'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_comprehension: ('[' | '(' | '{') starred_expression for_if_clauses 
-static void * 
-invalid_comprehension_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ('[' | '(' | '{') starred_expression for_if_clauses 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); 
-        void *_tmp_130_var; 
-        expr_ty a; 
-        asdl_seq* for_if_clauses_var; 
-        if ( 
-            (_tmp_130_var = _tmp_130_rule(p))  // '[' | '(' | '{' 
-            && 
-            (a = starred_expression_rule(p))  // starred_expression 
-            && 
-            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}' 
-static void * 
-invalid_dict_comprehension_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '{' '**' bitwise_or for_if_clauses '}' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * a; 
-        expr_ty bitwise_or_var; 
-        asdl_seq* for_if_clauses_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 25))  // token='{' 
-            && 
-            (a = _PyPegen_expect_token(p, 35))  // token='**' 
-            && 
-            (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or 
-            && 
-            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_parameters: 
-//     | param_no_default* (slash_with_default | param_with_default+) param_no_default 
-static void * 
-invalid_parameters_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // param_no_default* (slash_with_default | param_with_default+) param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default")); 
-        asdl_seq * _loop0_131_var; 
-        void *_tmp_132_var; 
-        arg_ty param_no_default_var; 
-        if ( 
-            (_loop0_131_var = _loop0_131_rule(p))  // param_no_default* 
-            && 
-            (_tmp_132_var = _tmp_132_rule(p))  // slash_with_default | param_with_default+ 
-            && 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default")); 
-            _res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_lambda_parameters: 
-//     | lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default 
-static void * 
-invalid_lambda_parameters_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default")); 
-        asdl_seq * _loop0_133_var; 
-        void *_tmp_134_var; 
-        arg_ty lambda_param_no_default_var; 
-        if ( 
-            (_loop0_133_var = _loop0_133_rule(p))  // lambda_param_no_default* 
-            && 
-            (_tmp_134_var = _tmp_134_rule(p))  // lambda_slash_with_default | lambda_param_with_default+ 
-            && 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default")); 
-            _res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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_slash_with_default | lambda_param_with_default+) lambda_param_no_default")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_star_etc: '*' (')' | ',' (')' | '**')) | '*' ',' TYPE_COMMENT 
-static void * 
-invalid_star_etc_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '*' (')' | ',' (')' | '**')) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); 
-        Token * _literal; 
-        void *_tmp_135_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (_tmp_135_var = _tmp_135_rule(p))  // ')' | ',' (')' | '**') 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); 
-            _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (')' | ',' (')' | '**'))")); 
-    } 
-    { // '*' ',' TYPE_COMMENT 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        Token * type_comment_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT")); 
-            _res = RAISE_SYNTAX_ERROR ( "bare * has associated type comment" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' TYPE_COMMENT")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_lambda_star_etc: '*' (':' | ',' (':' | '**')) 
-static void * 
-invalid_lambda_star_etc_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '*' (':' | ',' (':' | '**')) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); 
-        Token * _literal; 
-        void *_tmp_136_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 16))  // token='*' 
-            && 
-            (_tmp_136_var = _tmp_136_rule(p))  // ':' | ',' (':' | '**') 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); 
-            _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (':' | ',' (':' | '**'))")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT 
-static void * 
-invalid_double_type_comments_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT")); 
-        Token * indent_var; 
-        Token * newline_var; 
-        Token * newline_var_1; 
-        Token * type_comment_var; 
-        Token * type_comment_var_1; 
-        if ( 
-            (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT' 
-            && 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-            && 
-            (type_comment_var_1 = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT' 
-            && 
-            (newline_var_1 = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-            && 
-            (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_double_type_comments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT")); 
-            _res = RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_double_type_comments[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_with_item: expression 'as' expression 
-static void * 
-invalid_with_item_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // expression 'as' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' expression")); 
-        Token * _keyword; 
-        expr_ty a; 
-        expr_ty expression_var; 
-        if ( 
-            (expression_var = expression_rule(p))  // expression 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 520))  // token='as' 
-            && 
-            (a = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' expression")); 
-            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_with_item[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_for_target: ASYNC? 'for' star_expressions 
-static void * 
-invalid_for_target_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ASYNC? 'for' star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions")); 
-        Token * _keyword; 
-        void *_opt_var; 
-        UNUSED(_opt_var); // Silence compiler warnings 
-        expr_ty a; 
-        if ( 
-            (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC? 
-            && 
-            (_keyword = _PyPegen_expect_token(p, 517))  // token='for' 
-            && 
-            (a = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_for_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions")); 
-            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_for_target[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_group: '(' starred_expression ')' 
-static void * 
-invalid_group_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' starred_expression ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty a; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (a = starred_expression_rule(p))  // starred_expression 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'")); 
-            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "can't use starred expression here" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' starred_expression ')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// invalid_import_from_targets: import_from_as_names ',' NEWLINE 
-static void * 
-invalid_import_from_targets_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // import_from_as_names ',' NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE")); 
-        Token * _literal; 
-        asdl_seq* import_from_as_names_var; 
-        Token * newline_var; 
-        if ( 
-            (import_from_as_names_var = import_from_as_names_rule(p))  // import_from_as_names 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE")); 
-            _res = RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        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")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_1: NEWLINE 
-static asdl_seq * 
-_loop0_1_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); 
-        Token * newline_var; 
-        while ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            _res = newline_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_1[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_2: NEWLINE 
-static asdl_seq * 
-_loop0_2_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); 
-        Token * newline_var; 
-        while ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            _res = newline_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_2[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_4: ',' expression 
-static asdl_seq * 
-_loop0_4_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = expression_rule(p))  // expression 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_4[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_4_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_3: expression _loop0_4 
-static asdl_seq * 
-_gather_3_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // expression _loop0_4 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_4")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = expression_rule(p))  // expression 
-            && 
-            (seq = _loop0_4_rule(p))  // _loop0_4 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_3[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_4")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_3[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_4")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_6: ',' expression 
-static asdl_seq * 
-_loop0_6_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = expression_rule(p))  // expression 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_6[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_6_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_5: expression _loop0_6 
-static asdl_seq * 
-_gather_5_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // expression _loop0_6 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_6")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = expression_rule(p))  // expression 
-            && 
-            (seq = _loop0_6_rule(p))  // _loop0_6 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_6")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_5[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_6")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_8: ',' expression 
-static asdl_seq * 
-_loop0_8_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = expression_rule(p))  // expression 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_8[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_8_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_7: expression _loop0_8 
-static asdl_seq * 
-_gather_7_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // expression _loop0_8 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_8")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = expression_rule(p))  // expression 
-            && 
-            (seq = _loop0_8_rule(p))  // _loop0_8 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_8")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_7[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_8")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_10: ',' expression 
-static asdl_seq * 
-_loop0_10_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = expression_rule(p))  // expression 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_10[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_10_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_9: expression _loop0_10 
-static asdl_seq * 
-_gather_9_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // expression _loop0_10 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_10")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = expression_rule(p))  // expression 
-            && 
-            (seq = _loop0_10_rule(p))  // _loop0_10 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_10")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_9[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_10")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_11: statement 
-static asdl_seq * 
-_loop1_11_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // statement 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement")); 
-        asdl_seq* statement_var; 
-        while ( 
-            (statement_var = statement_rule(p))  // statement 
-        ) 
-        { 
-            _res = statement_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_11[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_11_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_13: ';' small_stmt 
-static asdl_seq * 
-_loop0_13_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ';' small_stmt 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' small_stmt")); 
-        Token * _literal; 
-        stmt_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 13))  // token=';' 
-            && 
-            (elem = small_stmt_rule(p))  // small_stmt 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_13[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';' small_stmt")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_13_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_12: small_stmt _loop0_13 
-static asdl_seq * 
-_gather_12_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // small_stmt _loop0_13 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "small_stmt _loop0_13")); 
-        stmt_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = small_stmt_rule(p))  // small_stmt 
-            && 
-            (seq = _loop0_13_rule(p))  // _loop0_13 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "small_stmt _loop0_13")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_12[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "small_stmt _loop0_13")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_14: 'import' | 'from' 
-static void * 
-_tmp_14_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'import' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 513))  // token='import' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_14[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'")); 
-            _res = _keyword; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_14[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'")); 
-    } 
-    { // 'from' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 514))  // token='from' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_14[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'")); 
-            _res = _keyword; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_14[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_15: 'def' | '@' | ASYNC 
-static void * 
-_tmp_15_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'def' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 523))  // token='def' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'")); 
-            _res = _keyword; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'")); 
-    } 
-    { // '@' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 49))  // token='@' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); 
-    } 
-    { // ASYNC 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); 
-        Token * async_var; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); 
-            _res = async_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_16: 'class' | '@' 
-static void * 
-_tmp_16_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'class' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 524))  // token='class' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'")); 
-            _res = _keyword; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'")); 
-    } 
-    { // '@' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 49))  // token='@' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_17: 'with' | ASYNC 
-static void * 
-_tmp_17_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'with' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 519))  // token='with' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'")); 
-            _res = _keyword; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'")); 
-    } 
-    { // ASYNC 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); 
-        Token * async_var; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); 
-            _res = async_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_18: 'for' | ASYNC 
-static void * 
-_tmp_18_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'for' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'")); 
-        Token * _keyword; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 517))  // token='for' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'")); 
-            _res = _keyword; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_18[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'")); 
-    } 
-    { // ASYNC 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC")); 
-        Token * async_var; 
-        if ( 
-            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC")); 
-            _res = async_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_18[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_19: '=' annotated_rhs 
-static void * 
-_tmp_19_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '=' annotated_rhs 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); 
-        Token * _literal; 
-        expr_ty d; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-            && 
-            (d = annotated_rhs_rule(p))  // annotated_rhs 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_19[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); 
-            _res = d; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_19[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_20: '(' single_target ')' | single_subscript_attribute_target 
-static void * 
-_tmp_20_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' single_target ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        expr_ty b; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (b = single_target_rule(p))  // single_target 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'")); 
-            _res = b; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_20[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'")); 
-    } 
-    { // single_subscript_attribute_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); 
-        expr_ty single_subscript_attribute_target_var; 
-        if ( 
-            (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p))  // single_subscript_attribute_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target")); 
-            _res = single_subscript_attribute_target_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_20[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_21: '=' annotated_rhs 
-static void * 
-_tmp_21_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '=' annotated_rhs 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); 
-        Token * _literal; 
-        expr_ty d; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-            && 
-            (d = annotated_rhs_rule(p))  // annotated_rhs 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_21[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs")); 
-            _res = d; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_21[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_22: (star_targets '=') 
-static asdl_seq * 
-_loop1_22_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (star_targets '=') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); 
-        void *_tmp_137_var; 
-        while ( 
-            (_tmp_137_var = _tmp_137_rule(p))  // star_targets '=' 
-        ) 
-        { 
-            _res = _tmp_137_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_22[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_22_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_23: yield_expr | star_expressions 
-static void * 
-_tmp_23_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // yield_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-        expr_ty yield_expr_var; 
-        if ( 
-            (yield_expr_var = yield_expr_rule(p))  // yield_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-            _res = yield_expr_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); 
-    } 
-    { // star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-        expr_ty star_expressions_var; 
-        if ( 
-            (star_expressions_var = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-            _res = star_expressions_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_24: yield_expr | star_expressions 
-static void * 
-_tmp_24_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // yield_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-        expr_ty yield_expr_var; 
-        if ( 
-            (yield_expr_var = yield_expr_rule(p))  // yield_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_24[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-            _res = yield_expr_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_24[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); 
-    } 
-    { // star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-        expr_ty star_expressions_var; 
-        if ( 
-            (star_expressions_var = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_24[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-            _res = star_expressions_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_24[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_26: ',' NAME 
-static asdl_seq * 
-_loop0_26_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_26[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_26_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_25: NAME _loop0_26 
-static asdl_seq * 
-_gather_25_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // NAME _loop0_26 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_26")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = _PyPegen_name_token(p))  // NAME 
-            && 
-            (seq = _loop0_26_rule(p))  // _loop0_26 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_25[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_26")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_25[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_26")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_28: ',' NAME 
-static asdl_seq * 
-_loop0_28_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_28[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_28_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_27: NAME _loop0_28 
-static asdl_seq * 
-_gather_27_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // NAME _loop0_28 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_28")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = _PyPegen_name_token(p))  // NAME 
-            && 
-            (seq = _loop0_28_rule(p))  // _loop0_28 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_27[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_28")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_27[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_28")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_29: ',' expression 
-static void * 
-_tmp_29_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-        Token * _literal; 
-        expr_ty z; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (z = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_29[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_30: ';' | NEWLINE 
-static void * 
-_tmp_30_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ';' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 13))  // token=';' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_30[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_30[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'")); 
-    } 
-    { // NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE")); 
-        Token * newline_var; 
-        if ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_30[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE")); 
-            _res = newline_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_30[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_31: ('.' | '...') 
-static asdl_seq * 
-_loop0_31_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('.' | '...') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); 
-        void *_tmp_138_var; 
-        while ( 
-            (_tmp_138_var = _tmp_138_rule(p))  // '.' | '...' 
-        ) 
-        { 
-            _res = _tmp_138_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_31[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_31_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_32: ('.' | '...') 
-static asdl_seq * 
-_loop1_32_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('.' | '...') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')")); 
-        void *_tmp_139_var; 
-        while ( 
-            (_tmp_139_var = _tmp_139_rule(p))  // '.' | '...' 
-        ) 
-        { 
-            _res = _tmp_139_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_32[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_34: ',' import_from_as_name 
-static asdl_seq * 
-_loop0_34_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' import_from_as_name 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_as_name")); 
-        Token * _literal; 
-        alias_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = import_from_as_name_rule(p))  // import_from_as_name 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_34[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' import_from_as_name")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_34_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_33: import_from_as_name _loop0_34 
-static asdl_seq * 
-_gather_33_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // import_from_as_name _loop0_34 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_34")); 
-        alias_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = import_from_as_name_rule(p))  // import_from_as_name 
-            && 
-            (seq = _loop0_34_rule(p))  // _loop0_34 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_34")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_33[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_name _loop0_34")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_35: 'as' NAME 
-static void * 
-_tmp_35_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'as' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); 
-        Token * _keyword; 
-        expr_ty z; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 520))  // token='as' 
-            && 
-            (z = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_37: ',' dotted_as_name 
-static asdl_seq * 
-_loop0_37_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' dotted_as_name 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_name")); 
-        Token * _literal; 
-        alias_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = dotted_as_name_rule(p))  // dotted_as_name 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_37[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_as_name")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_36: dotted_as_name _loop0_37 
-static asdl_seq * 
-_gather_36_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // dotted_as_name _loop0_37 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_37")); 
-        alias_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = dotted_as_name_rule(p))  // dotted_as_name 
-            && 
-            (seq = _loop0_37_rule(p))  // _loop0_37 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_36[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_37")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_36[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_as_name _loop0_37")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_38: 'as' NAME 
-static void * 
-_tmp_38_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'as' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); 
-        Token * _keyword; 
-        expr_ty z; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 520))  // token='as' 
-            && 
-            (z = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_38[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_38[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_40: ',' with_item 
-static asdl_seq * 
-_loop0_40_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' with_item 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); 
-        Token * _literal; 
-        withitem_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = with_item_rule(p))  // with_item 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_40[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_39: with_item _loop0_40 
-static asdl_seq * 
-_gather_39_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // with_item _loop0_40 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_40")); 
-        withitem_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = with_item_rule(p))  // with_item 
-            && 
-            (seq = _loop0_40_rule(p))  // _loop0_40 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_39[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_40")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_39[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_40")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_42: ',' with_item 
-static asdl_seq * 
-_loop0_42_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' with_item 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); 
-        Token * _literal; 
-        withitem_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = with_item_rule(p))  // with_item 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_42[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_42_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_41: with_item _loop0_42 
-static asdl_seq * 
-_gather_41_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // with_item _loop0_42 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_42")); 
-        withitem_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = with_item_rule(p))  // with_item 
-            && 
-            (seq = _loop0_42_rule(p))  // _loop0_42 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_41[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_42")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_41[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_42")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_44: ',' with_item 
-static asdl_seq * 
-_loop0_44_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' with_item 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); 
-        Token * _literal; 
-        withitem_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = with_item_rule(p))  // with_item 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_43: with_item _loop0_44 
-static asdl_seq * 
-_gather_43_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // with_item _loop0_44 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_44")); 
-        withitem_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = with_item_rule(p))  // with_item 
-            && 
-            (seq = _loop0_44_rule(p))  // _loop0_44 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_44")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_43[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_44")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_46: ',' with_item 
-static asdl_seq * 
-_loop0_46_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' with_item 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item")); 
-        Token * _literal; 
-        withitem_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = with_item_rule(p))  // with_item 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_45: with_item _loop0_46 
-static asdl_seq * 
-_gather_45_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // with_item _loop0_46 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_46")); 
-        withitem_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = with_item_rule(p))  // with_item 
-            && 
-            (seq = _loop0_46_rule(p))  // _loop0_46 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_45[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_46")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_45[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_46")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_47: ',' | ')' | ':' 
-static void * 
-_tmp_47_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','")); 
-    } 
-    { // ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); 
-    } 
-    { // ':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_48: except_block 
-static asdl_seq * 
-_loop1_48_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // except_block 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block")); 
-        excepthandler_ty except_block_var; 
-        while ( 
-            (except_block_var = except_block_rule(p))  // except_block 
-        ) 
-        { 
-            _res = except_block_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_48[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_48_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_49: 'as' NAME 
-static void * 
-_tmp_49_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'as' NAME 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME")); 
-        Token * _keyword; 
-        expr_ty z; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 520))  // token='as' 
-            && 
-            (z = _PyPegen_name_token(p))  // NAME 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_49[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_49[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_50: 'from' expression 
-static void * 
-_tmp_50_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'from' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression")); 
-        Token * _keyword; 
-        expr_ty z; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 514))  // token='from' 
-            && 
-            (z = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_50[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' expression")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_50[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_51: '->' expression 
-static void * 
-_tmp_51_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '->' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); 
-        Token * _literal; 
-        expr_ty z; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 51))  // token='->' 
-            && 
-            (z = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_51[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_52: '->' expression 
-static void * 
-_tmp_52_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '->' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression")); 
-        Token * _literal; 
-        expr_ty z; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 51))  // token='->' 
-            && 
-            (z = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_52[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_52[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_53: NEWLINE INDENT 
-static void * 
-_tmp_53_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // NEWLINE INDENT 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); 
-        Token * indent_var; 
-        Token * newline_var; 
-        if ( 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-            && 
-            (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT")); 
-            _res = _PyPegen_dummy_name(p, newline_var, indent_var); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_53[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_54: param_no_default 
-static asdl_seq * 
-_loop0_54_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_54[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_55: param_with_default 
-static asdl_seq * 
-_loop0_55_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_55[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_55_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_56: param_with_default 
-static asdl_seq * 
-_loop0_56_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_56[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_57: param_no_default 
-static asdl_seq * 
-_loop1_57_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_57[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_57_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_58: param_with_default 
-static asdl_seq * 
-_loop0_58_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_59: param_with_default 
-static asdl_seq * 
-_loop1_59_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_59[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_59_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_60: param_no_default 
-static asdl_seq * 
-_loop1_60_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_61: param_no_default 
-static asdl_seq * 
-_loop1_61_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_62: param_no_default 
-static asdl_seq * 
-_loop0_62_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_62[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_62_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_63: param_with_default 
-static asdl_seq * 
-_loop1_63_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_63[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_63_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_64: param_no_default 
-static asdl_seq * 
-_loop0_64_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_64[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_64_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_65: param_with_default 
-static asdl_seq * 
-_loop1_65_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_65[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_65_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_66: param_maybe_default 
-static asdl_seq * 
-_loop0_66_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_maybe_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); 
-        NameDefaultPair* param_maybe_default_var; 
-        while ( 
-            (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default 
-        ) 
-        { 
-            _res = param_maybe_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_66[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_67: param_maybe_default 
-static asdl_seq * 
-_loop1_67_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_maybe_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default")); 
-        NameDefaultPair* param_maybe_default_var; 
-        while ( 
-            (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default 
-        ) 
-        { 
-            _res = param_maybe_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_67[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_67_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_68: ('@' named_expression NEWLINE) 
-static asdl_seq * 
-_loop1_68_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('@' named_expression NEWLINE) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)")); 
-        void *_tmp_140_var; 
-        while ( 
-            (_tmp_140_var = _tmp_140_rule(p))  // '@' named_expression NEWLINE 
-        ) 
-        { 
-            _res = _tmp_140_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_68[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('@' named_expression NEWLINE)")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_68_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_69: '(' arguments? ')' 
-static void * 
-_tmp_69_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '(' arguments? ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); 
-        Token * _literal; 
-        Token * _literal_1; 
-        void *z; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-            && 
-            (z = arguments_rule(p), !p->error_indicator)  // arguments? 
-            && 
-            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_70: (',' star_expression) 
-static asdl_seq * 
-_loop1_70_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (',' star_expression) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)")); 
-        void *_tmp_141_var; 
-        while ( 
-            (_tmp_141_var = _tmp_141_rule(p))  // ',' star_expression 
-        ) 
-        { 
-            _res = _tmp_141_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_70[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_70_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_72: ',' star_named_expression 
-static asdl_seq * 
-_loop0_72_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' star_named_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = star_named_expression_rule(p))  // star_named_expression 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_71: star_named_expression _loop0_72 
-static asdl_seq * 
-_gather_71_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // star_named_expression _loop0_72 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_72")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = star_named_expression_rule(p))  // star_named_expression 
-            && 
-            (seq = _loop0_72_rule(p))  // _loop0_72 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_72")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_71[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_72")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_73: (',' expression) 
-static asdl_seq * 
-_loop1_73_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (',' expression) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)")); 
-        void *_tmp_142_var; 
-        while ( 
-            (_tmp_142_var = _tmp_142_rule(p))  // ',' expression 
-        ) 
-        { 
-            _res = _tmp_142_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_73[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_73_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_74: lambda_param_no_default 
-static asdl_seq * 
-_loop0_74_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_75: lambda_param_with_default 
-static asdl_seq * 
-_loop0_75_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_75[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_75_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_76: lambda_param_with_default 
-static asdl_seq * 
-_loop0_76_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_76[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_76_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_77: lambda_param_no_default 
-static asdl_seq * 
-_loop1_77_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_77[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_77_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_78: lambda_param_with_default 
-static asdl_seq * 
-_loop0_78_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_78[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_78_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_79: lambda_param_with_default 
-static asdl_seq * 
-_loop1_79_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_79[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_79_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_80: lambda_param_no_default 
-static asdl_seq * 
-_loop1_80_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_81: lambda_param_no_default 
-static asdl_seq * 
-_loop1_81_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_81[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_82: lambda_param_no_default 
-static asdl_seq * 
-_loop0_82_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_82[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_82_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_83: lambda_param_with_default 
-static asdl_seq * 
-_loop1_83_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_83_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_84: lambda_param_no_default 
-static asdl_seq * 
-_loop0_84_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_84[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_84_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_85: lambda_param_with_default 
-static asdl_seq * 
-_loop1_85_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_85[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_86: lambda_param_maybe_default 
-static asdl_seq * 
-_loop0_86_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_maybe_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); 
-        NameDefaultPair* lambda_param_maybe_default_var; 
-        while ( 
-            (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default 
-        ) 
-        { 
-            _res = lambda_param_maybe_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_86[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_86_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_87: lambda_param_maybe_default 
-static asdl_seq * 
-_loop1_87_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_maybe_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default")); 
-        NameDefaultPair* lambda_param_maybe_default_var; 
-        while ( 
-            (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default 
-        ) 
-        { 
-            _res = lambda_param_maybe_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_87[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_87_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_88: ('or' conjunction) 
-static asdl_seq * 
-_loop1_88_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('or' conjunction) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)")); 
-        void *_tmp_143_var; 
-        while ( 
-            (_tmp_143_var = _tmp_143_rule(p))  // 'or' conjunction 
-        ) 
-        { 
-            _res = _tmp_143_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_88[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_88_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_89: ('and' inversion) 
-static asdl_seq * 
-_loop1_89_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('and' inversion) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)")); 
-        void *_tmp_144_var; 
-        while ( 
-            (_tmp_144_var = _tmp_144_rule(p))  // 'and' inversion 
-        ) 
-        { 
-            _res = _tmp_144_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_89[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_89_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_90: compare_op_bitwise_or_pair 
-static asdl_seq * 
-_loop1_90_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // compare_op_bitwise_or_pair 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair")); 
-        CmpopExprPair* compare_op_bitwise_or_pair_var; 
-        while ( 
-            (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p))  // compare_op_bitwise_or_pair 
-        ) 
-        { 
-            _res = compare_op_bitwise_or_pair_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_90[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_90_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_91: '!=' 
-static void * 
-_tmp_91_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '!=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='")); 
-        Token * tok; 
-        if ( 
-            (tok = _PyPegen_expect_token(p, 28))  // token='!=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='")); 
-            _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_93: ',' slice 
-static asdl_seq * 
-_loop0_93_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' slice 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' slice")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = slice_rule(p))  // slice 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_93[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' slice")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_93_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_92: slice _loop0_93 
-static asdl_seq * 
-_gather_92_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // slice _loop0_93 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice _loop0_93")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = slice_rule(p))  // slice 
-            && 
-            (seq = _loop0_93_rule(p))  // _loop0_93 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice _loop0_93")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice _loop0_93")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_94: ':' expression? 
-static void * 
-_tmp_94_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ':' expression? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?")); 
-        Token * _literal; 
-        void *d; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-            && 
-            (d = expression_rule(p), !p->error_indicator)  // expression? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?")); 
-            _res = d; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_95: tuple | group | genexp 
-static void * 
-_tmp_95_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // tuple 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple")); 
-        expr_ty tuple_var; 
-        if ( 
-            (tuple_var = tuple_rule(p))  // tuple 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple")); 
-            _res = tuple_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple")); 
-    } 
-    { // group 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group")); 
-        expr_ty group_var; 
-        if ( 
-            (group_var = group_rule(p))  // group 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group")); 
-            _res = group_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group")); 
-    } 
-    { // genexp 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp")); 
-        expr_ty genexp_var; 
-        if ( 
-            (genexp_var = genexp_rule(p))  // genexp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp")); 
-            _res = genexp_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_96: list | listcomp 
-static void * 
-_tmp_96_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // list 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list")); 
-        expr_ty list_var; 
-        if ( 
-            (list_var = list_rule(p))  // list 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list")); 
-            _res = list_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list")); 
-    } 
-    { // listcomp 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp")); 
-        expr_ty listcomp_var; 
-        if ( 
-            (listcomp_var = listcomp_rule(p))  // listcomp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp")); 
-            _res = listcomp_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_97: dict | set | dictcomp | setcomp 
-static void * 
-_tmp_97_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // dict 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict")); 
-        expr_ty dict_var; 
-        if ( 
-            (dict_var = dict_rule(p))  // dict 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict")); 
-            _res = dict_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict")); 
-    } 
-    { // set 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set")); 
-        expr_ty set_var; 
-        if ( 
-            (set_var = set_rule(p))  // set 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set")); 
-            _res = set_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set")); 
-    } 
-    { // dictcomp 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp")); 
-        expr_ty dictcomp_var; 
-        if ( 
-            (dictcomp_var = dictcomp_rule(p))  // dictcomp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp")); 
-            _res = dictcomp_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp")); 
-    } 
-    { // setcomp 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp")); 
-        expr_ty setcomp_var; 
-        if ( 
-            (setcomp_var = setcomp_rule(p))  // setcomp 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp")); 
-            _res = setcomp_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_98: STRING 
-static asdl_seq * 
-_loop1_98_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // STRING 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING")); 
-        expr_ty string_var; 
-        while ( 
-            (string_var = _PyPegen_string_token(p))  // STRING 
-        ) 
-        { 
-            _res = string_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_98[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_99: star_named_expression ',' star_named_expressions? 
-static void * 
-_tmp_99_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // star_named_expression ',' star_named_expressions? 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); 
-        Token * _literal; 
-        expr_ty y; 
-        void *z; 
-        if ( 
-            (y = star_named_expression_rule(p))  // star_named_expression 
-            && 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (z = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions? 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_99[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?")); 
-            _res = _PyPegen_seq_insert_in_front ( p , y , z ); 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_99[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_100: yield_expr | named_expression 
-static void * 
-_tmp_100_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // yield_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-        expr_ty yield_expr_var; 
-        if ( 
-            (yield_expr_var = yield_expr_rule(p))  // yield_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-            _res = yield_expr_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); 
-    } 
-    { // named_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression")); 
-        expr_ty named_expression_var; 
-        if ( 
-            (named_expression_var = named_expression_rule(p))  // named_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression")); 
-            _res = named_expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_102: ',' double_starred_kvpair 
-static asdl_seq * 
-_loop0_102_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' double_starred_kvpair 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair")); 
-        Token * _literal; 
-        KeyValuePair* elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_102_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_101: double_starred_kvpair _loop0_102 
-static asdl_seq * 
-_gather_101_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // double_starred_kvpair _loop0_102 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_102")); 
-        KeyValuePair* elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair 
-            && 
-            (seq = _loop0_102_rule(p))  // _loop0_102 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_102")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_102")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_103: for_if_clause 
-static asdl_seq * 
-_loop1_103_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // for_if_clause 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause")); 
-        comprehension_ty for_if_clause_var; 
-        while ( 
-            (for_if_clause_var = for_if_clause_rule(p))  // for_if_clause 
-        ) 
-        { 
-            _res = for_if_clause_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_103[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_103_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_104: ('if' disjunction) 
-static asdl_seq * 
-_loop0_104_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('if' disjunction) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); 
-        void *_tmp_145_var; 
-        while ( 
-            (_tmp_145_var = _tmp_145_rule(p))  // 'if' disjunction 
-        ) 
-        { 
-            _res = _tmp_145_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_104[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_104_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_105: ('if' disjunction) 
-static asdl_seq * 
-_loop0_105_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ('if' disjunction) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)")); 
-        void *_tmp_146_var; 
-        while ( 
-            (_tmp_146_var = _tmp_146_rule(p))  // 'if' disjunction 
-        ) 
-        { 
-            _res = _tmp_146_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_107: ',' (starred_expression | named_expression !'=') 
-static asdl_seq * 
-_loop0_107_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' (starred_expression | named_expression !'=') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | named_expression !'=')")); 
-        Token * _literal; 
-        void *elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = _tmp_147_rule(p))  // starred_expression | named_expression !'=' 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_107[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | named_expression !'=')")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_106: (starred_expression | named_expression !'=') _loop0_107 
-static asdl_seq * 
-_gather_106_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // (starred_expression | named_expression !'=') _loop0_107 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107")); 
-        void *elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = _tmp_147_rule(p))  // starred_expression | named_expression !'=' 
-            && 
-            (seq = _loop0_107_rule(p))  // _loop0_107 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_108: ',' kwargs 
-static void * 
-_tmp_108_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' kwargs 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs")); 
-        Token * _literal; 
-        asdl_seq* k; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (k = kwargs_rule(p))  // kwargs 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs")); 
-            _res = k; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_110: ',' kwarg_or_starred 
-static asdl_seq * 
-_loop0_110_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' kwarg_or_starred 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); 
-        Token * _literal; 
-        KeywordOrStarred* elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_110[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_110_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_109: kwarg_or_starred _loop0_110 
-static asdl_seq * 
-_gather_109_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // kwarg_or_starred _loop0_110 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_110")); 
-        KeywordOrStarred* elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred 
-            && 
-            (seq = _loop0_110_rule(p))  // _loop0_110 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_110")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_109[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_110")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_112: ',' kwarg_or_double_starred 
-static asdl_seq * 
-_loop0_112_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' kwarg_or_double_starred 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); 
-        Token * _literal; 
-        KeywordOrStarred* elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_112[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_111: kwarg_or_double_starred _loop0_112 
-static asdl_seq * 
-_gather_111_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // kwarg_or_double_starred _loop0_112 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_112")); 
-        KeywordOrStarred* elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred 
-            && 
-            (seq = _loop0_112_rule(p))  // _loop0_112 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_112")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_111[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_112")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_114: ',' kwarg_or_starred 
-static asdl_seq * 
-_loop0_114_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' kwarg_or_starred 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred")); 
-        Token * _literal; 
-        KeywordOrStarred* elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_114[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_113: kwarg_or_starred _loop0_114 
-static asdl_seq * 
-_gather_113_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // kwarg_or_starred _loop0_114 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_114")); 
-        KeywordOrStarred* elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred 
-            && 
-            (seq = _loop0_114_rule(p))  // _loop0_114 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_114")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_113[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_114")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_116: ',' kwarg_or_double_starred 
-static asdl_seq * 
-_loop0_116_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' kwarg_or_double_starred 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred")); 
-        Token * _literal; 
-        KeywordOrStarred* elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_116[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_116_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_115: kwarg_or_double_starred _loop0_116 
-static asdl_seq * 
-_gather_115_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // kwarg_or_double_starred _loop0_116 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_116")); 
-        KeywordOrStarred* elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred 
-            && 
-            (seq = _loop0_116_rule(p))  // _loop0_116 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_116")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_115[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_116")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_117: (',' star_target) 
-static asdl_seq * 
-_loop0_117_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (',' star_target) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); 
-        void *_tmp_148_var; 
-        while ( 
-            (_tmp_148_var = _tmp_148_rule(p))  // ',' star_target 
-        ) 
-        { 
-            _res = _tmp_148_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_117[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_117_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_119: ',' star_target 
-static asdl_seq * 
-_loop0_119_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' star_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = star_target_rule(p))  // star_target 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_119[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_119_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_118: star_target _loop0_119 
-static asdl_seq * 
-_gather_118_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // star_target _loop0_119 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_119")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = star_target_rule(p))  // star_target 
-            && 
-            (seq = _loop0_119_rule(p))  // _loop0_119 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_119")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_118[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_119")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_120: (',' star_target) 
-static asdl_seq * 
-_loop1_120_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (',' star_target) 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)")); 
-        void *_tmp_149_var; 
-        while ( 
-            (_tmp_149_var = _tmp_149_rule(p))  // ',' star_target 
-        ) 
-        { 
-            _res = _tmp_149_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_120[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_120_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_121: !'*' star_target 
-static void * 
-_tmp_121_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // !'*' star_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); 
-        expr_ty star_target_var; 
-        if ( 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16)  // token='*' 
-            && 
-            (star_target_var = star_target_rule(p))  // star_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target")); 
-            _res = star_target_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_123: ',' del_target 
-static asdl_seq * 
-_loop0_123_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // ',' del_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target")); 
-        Token * _literal; 
-        expr_ty elem; 
-        while ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (elem = del_target_rule(p))  // del_target 
-        ) 
-        { 
-            _res = elem; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                PyMem_Free(_children); 
-                p->level--; 
-                return NULL; 
-            } 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_123[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _gather_122: del_target _loop0_123 
-static asdl_seq * 
-_gather_122_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq * _res = NULL; 
-    int _mark = p->mark; 
-    { // del_target _loop0_123 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _gather_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_123")); 
-        expr_ty elem; 
-        asdl_seq * seq; 
-        if ( 
-            (elem = del_target_rule(p))  // del_target 
-            && 
-            (seq = _loop0_123_rule(p))  // _loop0_123 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _gather_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_123")); 
-            _res = _PyPegen_seq_insert_in_front(p, elem, seq); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _gather_122[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_123")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_124: args | expression for_if_clauses 
-static void * 
-_tmp_124_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // args 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args")); 
-        expr_ty args_var; 
-        if ( 
-            (args_var = args_rule(p))  // args 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args")); 
-            _res = args_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args")); 
-    } 
-    { // expression for_if_clauses 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); 
-        expr_ty expression_var; 
-        asdl_seq* for_if_clauses_var; 
-        if ( 
-            (expression_var = expression_rule(p))  // expression 
-            && 
-            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses")); 
-            _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_125: NAME '=' 
-static void * 
-_tmp_125_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // NAME '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='")); 
-        Token * _literal; 
-        expr_ty name_var; 
-        if ( 
-            (name_var = _PyPegen_name_token(p))  // NAME 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='")); 
-            _res = _PyPegen_dummy_name(p, name_var, _literal); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_126: star_named_expressions 
-static asdl_seq * 
-_loop0_126_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // star_named_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions")); 
-        asdl_seq* star_named_expressions_var; 
-        while ( 
-            (star_named_expressions_var = star_named_expressions_rule(p))  // star_named_expressions 
-        ) 
-        { 
-            _res = star_named_expressions_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_126[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_126_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_127: (star_targets '=') 
-static asdl_seq * 
-_loop0_127_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (star_targets '=') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); 
-        void *_tmp_150_var; 
-        while ( 
-            (_tmp_150_var = _tmp_150_rule(p))  // star_targets '=' 
-        ) 
-        { 
-            _res = _tmp_150_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop0_128: (star_targets '=') 
-static asdl_seq * 
-_loop0_128_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // (star_targets '=') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')")); 
-        void *_tmp_151_var; 
-        while ( 
-            (_tmp_151_var = _tmp_151_rule(p))  // star_targets '=' 
-        ) 
-        { 
-            _res = _tmp_151_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_128[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_129: yield_expr | star_expressions 
-static void * 
-_tmp_129_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // yield_expr 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-        expr_ty yield_expr_var; 
-        if ( 
-            (yield_expr_var = yield_expr_rule(p))  // yield_expr 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr")); 
-            _res = yield_expr_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr")); 
-    } 
-    { // star_expressions 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-        expr_ty star_expressions_var; 
-        if ( 
-            (star_expressions_var = star_expressions_rule(p))  // star_expressions 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions")); 
-            _res = star_expressions_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_130: '[' | '(' | '{' 
-static void * 
-_tmp_130_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '[' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 9))  // token='[' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['")); 
-    } 
-    { // '(' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 7))  // token='(' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('")); 
-    } 
-    { // '{' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 25))  // token='{' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_131: param_no_default 
-static asdl_seq * 
-_loop0_131_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default")); 
-        arg_ty param_no_default_var; 
-        while ( 
-            (param_no_default_var = param_no_default_rule(p))  // param_no_default 
-        ) 
-        { 
-            _res = param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_131[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_131_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_132: slash_with_default | param_with_default+ 
-static void * 
-_tmp_132_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // slash_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default")); 
-        SlashWithDefault* slash_with_default_var; 
-        if ( 
-            (slash_with_default_var = slash_with_default_rule(p))  // slash_with_default 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default")); 
-            _res = slash_with_default_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default")); 
-    } 
-    { // param_with_default+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+")); 
-        asdl_seq * _loop1_152_var; 
-        if ( 
-            (_loop1_152_var = _loop1_152_rule(p))  // param_with_default+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+")); 
-            _res = _loop1_152_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop0_133: lambda_param_no_default 
-static asdl_seq * 
-_loop0_133_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_no_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default")); 
-        arg_ty lambda_param_no_default_var; 
-        while ( 
-            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default 
-        ) 
-        { 
-            _res = lambda_param_no_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop0_133[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default")); 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop0_133_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_134: lambda_slash_with_default | lambda_param_with_default+ 
-static void * 
-_tmp_134_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // lambda_slash_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); 
-        SlashWithDefault* lambda_slash_with_default_var; 
-        if ( 
-            (lambda_slash_with_default_var = lambda_slash_with_default_rule(p))  // lambda_slash_with_default 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default")); 
-            _res = lambda_slash_with_default_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default")); 
-    } 
-    { // lambda_param_with_default+ 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); 
-        asdl_seq * _loop1_153_var; 
-        if ( 
-            (_loop1_153_var = _loop1_153_rule(p))  // lambda_param_with_default+ 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+")); 
-            _res = _loop1_153_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_135: ')' | ',' (')' | '**') 
-static void * 
-_tmp_135_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); 
-    } 
-    { // ',' (')' | '**') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); 
-        Token * _literal; 
-        void *_tmp_154_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_tmp_154_var = _tmp_154_rule(p))  // ')' | '**' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')")); 
-            _res = _PyPegen_dummy_name(p, _literal, _tmp_154_var); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_136: ':' | ',' (':' | '**') 
-static void * 
-_tmp_136_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); 
-    } 
-    { // ',' (':' | '**') 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); 
-        Token * _literal; 
-        void *_tmp_155_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (_tmp_155_var = _tmp_155_rule(p))  // ':' | '**' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')")); 
-            _res = _PyPegen_dummy_name(p, _literal, _tmp_155_var); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_137: star_targets '=' 
-static void * 
-_tmp_137_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // star_targets '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); 
-        Token * _literal; 
-        expr_ty z; 
-        if ( 
-            (z = star_targets_rule(p))  // star_targets 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_137[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_138: '.' | '...' 
-static void * 
-_tmp_138_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '.' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); 
-    } 
-    { // '...' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 52))  // token='...' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_139: '.' | '...' 
-static void * 
-_tmp_139_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '.' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 23))  // token='.' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'")); 
-    } 
-    { // '...' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 52))  // token='...' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_140: '@' named_expression NEWLINE 
-static void * 
-_tmp_140_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // '@' named_expression NEWLINE 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); 
-        Token * _literal; 
-        expr_ty f; 
-        Token * newline_var; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 49))  // token='@' 
-            && 
-            (f = named_expression_rule(p))  // named_expression 
-            && 
-            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE")); 
-            _res = f; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_140[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_141: ',' star_expression 
-static void * 
-_tmp_141_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' star_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression")); 
-        Token * _literal; 
-        expr_ty c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (c = star_expression_rule(p))  // star_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression")); 
-            _res = c; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_142: ',' expression 
-static void * 
-_tmp_142_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-        Token * _literal; 
-        expr_ty c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (c = expression_rule(p))  // expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression")); 
-            _res = c; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_143: 'or' conjunction 
-static void * 
-_tmp_143_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'or' conjunction 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); 
-        Token * _keyword; 
-        expr_ty c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 532))  // token='or' 
-            && 
-            (c = conjunction_rule(p))  // conjunction 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction")); 
-            _res = c; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_144: 'and' inversion 
-static void * 
-_tmp_144_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'and' inversion 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion")); 
-        Token * _keyword; 
-        expr_ty c; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 533))  // token='and' 
-            && 
-            (c = inversion_rule(p))  // inversion 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion")); 
-            _res = c; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_145: 'if' disjunction 
-static void * 
-_tmp_145_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'if' disjunction 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); 
-        Token * _keyword; 
-        expr_ty z; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 510))  // token='if' 
-            && 
-            (z = disjunction_rule(p))  // disjunction 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_146: 'if' disjunction 
-static void * 
-_tmp_146_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // 'if' disjunction 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); 
-        Token * _keyword; 
-        expr_ty z; 
-        if ( 
-            (_keyword = _PyPegen_expect_token(p, 510))  // token='if' 
-            && 
-            (z = disjunction_rule(p))  // disjunction 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction")); 
-            _res = z; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_147: starred_expression | named_expression !'=' 
-static void * 
-_tmp_147_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // starred_expression 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression")); 
-        expr_ty starred_expression_var; 
-        if ( 
-            (starred_expression_var = starred_expression_rule(p))  // starred_expression 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression")); 
-            _res = starred_expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression")); 
-    } 
-    { // named_expression !'=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression !'='")); 
-        expr_ty named_expression_var; 
-        if ( 
-            (named_expression_var = named_expression_rule(p))  // named_expression 
-            && 
-            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression !'='")); 
-            _res = named_expression_var; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression !'='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_148: ',' star_target 
-static void * 
-_tmp_148_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' star_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); 
-        Token * _literal; 
-        expr_ty c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (c = star_target_rule(p))  // star_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); 
-            _res = c; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_149: ',' star_target 
-static void * 
-_tmp_149_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ',' star_target 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target")); 
-        Token * _literal; 
-        expr_ty c; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 12))  // token=',' 
-            && 
-            (c = star_target_rule(p))  // star_target 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target")); 
-            _res = c; 
-            if (_res == NULL && PyErr_Occurred()) { 
-                p->error_indicator = 1; 
-                p->level--; 
-                return NULL; 
-            } 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_150: star_targets '=' 
-static void * 
-_tmp_150_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // star_targets '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); 
-        Token * _literal; 
-        expr_ty star_targets_var; 
-        if ( 
-            (star_targets_var = star_targets_rule(p))  // star_targets 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); 
-            _res = _PyPegen_dummy_name(p, star_targets_var, _literal); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_151: star_targets '=' 
-static void * 
-_tmp_151_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // star_targets '=' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='")); 
-        Token * _literal; 
-        expr_ty star_targets_var; 
-        if ( 
-            (star_targets_var = star_targets_rule(p))  // star_targets 
-            && 
-            (_literal = _PyPegen_expect_token(p, 22))  // token='=' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='")); 
-            _res = _PyPegen_dummy_name(p, star_targets_var, _literal); 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _loop1_152: param_with_default 
-static asdl_seq * 
-_loop1_152_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default")); 
-        NameDefaultPair* param_with_default_var; 
-        while ( 
-            (param_with_default_var = param_with_default_rule(p))  // param_with_default 
-        ) 
-        { 
-            _res = param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_152[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_152_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _loop1_153: lambda_param_with_default 
-static asdl_seq * 
-_loop1_153_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void *_res = NULL; 
-    int _mark = p->mark; 
-    int _start_mark = p->mark; 
-    void **_children = PyMem_Malloc(sizeof(void *)); 
-    if (!_children) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    ssize_t _children_capacity = 1; 
-    ssize_t _n = 0; 
-    { // lambda_param_with_default 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _loop1_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default")); 
-        NameDefaultPair* lambda_param_with_default_var; 
-        while ( 
-            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default 
-        ) 
-        { 
-            _res = lambda_param_with_default_var; 
-            if (_n == _children_capacity) { 
-                _children_capacity *= 2; 
-                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); 
-                if (!_new_children) { 
-                    p->error_indicator = 1; 
-                    PyErr_NoMemory(); 
-                    p->level--; 
-                    return NULL; 
-                } 
-                _children = _new_children; 
-            } 
-            _children[_n++] = _res; 
-            _mark = p->mark; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _loop1_153[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default")); 
-    } 
-    if (_n == 0 || p->error_indicator) { 
-        PyMem_Free(_children); 
-        p->level--; 
-        return NULL; 
-    } 
-    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); 
-    if (!_seq) { 
-        PyMem_Free(_children); 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-        p->level--; 
-        return NULL; 
-    } 
-    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); 
-    PyMem_Free(_children); 
-    _PyPegen_insert_memo(p, _start_mark, _loop1_153_type, _seq); 
-    p->level--; 
-    return _seq; 
-} 
- 
-// _tmp_154: ')' | '**' 
-static void * 
-_tmp_154_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ')' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 8))  // token=')' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'")); 
-    } 
-    { // '**' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-// _tmp_155: ':' | '**' 
-static void * 
-_tmp_155_rule(Parser *p) 
-{ 
-    if (p->level++ == MAXSTACK) { 
-        p->error_indicator = 1; 
-        PyErr_NoMemory(); 
-    } 
-    if (p->error_indicator) { 
-        p->level--; 
-        return NULL; 
-    } 
-    void * _res = NULL; 
-    int _mark = p->mark; 
-    { // ':' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 11))  // token=':' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'")); 
-    } 
-    { // '**' 
-        if (p->error_indicator) { 
-            p->level--; 
-            return NULL; 
-        } 
-        D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'")); 
-        Token * _literal; 
-        if ( 
-            (_literal = _PyPegen_expect_token(p, 35))  // token='**' 
-        ) 
-        { 
-            D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'")); 
-            _res = _literal; 
-            goto done; 
-        } 
-        p->mark = _mark; 
-        D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ', 
-                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'")); 
-    } 
-    _res = NULL; 
-  done: 
-    p->level--; 
-    return _res; 
-} 
- 
-void * 
-_PyPegen_parse(Parser *p) 
-{ 
-    // Initialize keywords 
-    p->keywords = reserved_keywords; 
-    p->n_keyword_lists = n_keyword_lists; 
- 
-    // Run parser 
-    void *result = NULL; 
-    if (p->start_rule == Py_file_input) { 
-        result = file_rule(p); 
-    } else if (p->start_rule == Py_single_input) { 
-        result = interactive_rule(p); 
-    } else if (p->start_rule == Py_eval_input) { 
-        result = eval_rule(p); 
-    } else if (p->start_rule == Py_func_type_input) { 
-        result = func_type_rule(p); 
-    } else if (p->start_rule == Py_fstring_input) { 
-        result = fstring_rule(p); 
-    } 
- 
-    return result; 
-} 
- 
-// The end 
+// @generated by pegen.py from python.gram
+#include "pegen.h"
+
+#if defined(Py_DEBUG) && defined(Py_BUILD_CORE)
+extern int Py_DebugFlag;
+#define D(x) if (Py_DebugFlag) x;
+#else
+#define D(x)
+#endif
+
+# define MAXSTACK 6000
+static const int n_keyword_lists = 15;
+static KeywordToken *reserved_keywords[] = {
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {
+        {"if", 510},
+        {"in", 518},
+        {"as", 520},
+        {"is", 527},
+        {"or", 532},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"del", 503},
+        {"try", 511},
+        {"for", 517},
+        {"def", 523},
+        {"not", 526},
+        {"and", 533},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"pass", 502},
+        {"from", 514},
+        {"elif", 515},
+        {"else", 516},
+        {"with", 519},
+        {"True", 528},
+        {"None", 530},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"raise", 501},
+        {"yield", 504},
+        {"break", 506},
+        {"while", 512},
+        {"class", 524},
+        {"False", 529},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"return", 500},
+        {"assert", 505},
+        {"global", 508},
+        {"import", 513},
+        {"except", 521},
+        {"lambda", 525},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"finally", 522},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {
+        {"continue", 507},
+        {"nonlocal", 509},
+        {NULL, -1},
+    },
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {{NULL, -1}},
+    (KeywordToken[]) {
+        {"__peg_parser__", 531},
+        {NULL, -1},
+    },
+};
+#define file_type 1000
+#define interactive_type 1001
+#define eval_type 1002
+#define func_type_type 1003
+#define fstring_type 1004
+#define type_expressions_type 1005
+#define statements_type 1006
+#define statement_type 1007
+#define statement_newline_type 1008
+#define simple_stmt_type 1009
+#define small_stmt_type 1010
+#define compound_stmt_type 1011
+#define assignment_type 1012
+#define augassign_type 1013
+#define global_stmt_type 1014
+#define nonlocal_stmt_type 1015
+#define yield_stmt_type 1016
+#define assert_stmt_type 1017
+#define del_stmt_type 1018
+#define import_stmt_type 1019
+#define import_name_type 1020
+#define import_from_type 1021
+#define import_from_targets_type 1022
+#define import_from_as_names_type 1023
+#define import_from_as_name_type 1024
+#define dotted_as_names_type 1025
+#define dotted_as_name_type 1026
+#define dotted_name_type 1027  // Left-recursive
+#define if_stmt_type 1028
+#define elif_stmt_type 1029
+#define else_block_type 1030
+#define while_stmt_type 1031
+#define for_stmt_type 1032
+#define with_stmt_type 1033
+#define with_item_type 1034
+#define try_stmt_type 1035
+#define except_block_type 1036
+#define finally_block_type 1037
+#define return_stmt_type 1038
+#define raise_stmt_type 1039
+#define function_def_type 1040
+#define function_def_raw_type 1041
+#define func_type_comment_type 1042
+#define params_type 1043
+#define parameters_type 1044
+#define slash_no_default_type 1045
+#define slash_with_default_type 1046
+#define star_etc_type 1047
+#define kwds_type 1048
+#define param_no_default_type 1049
+#define param_with_default_type 1050
+#define param_maybe_default_type 1051
+#define param_type 1052
+#define annotation_type 1053
+#define default_type 1054
+#define decorators_type 1055
+#define class_def_type 1056
+#define class_def_raw_type 1057
+#define block_type 1058
+#define star_expressions_type 1059
+#define star_expression_type 1060
+#define star_named_expressions_type 1061
+#define star_named_expression_type 1062
+#define named_expression_type 1063
+#define annotated_rhs_type 1064
+#define expressions_type 1065
+#define expression_type 1066
+#define lambdef_type 1067
+#define lambda_params_type 1068
+#define lambda_parameters_type 1069
+#define lambda_slash_no_default_type 1070
+#define lambda_slash_with_default_type 1071
+#define lambda_star_etc_type 1072
+#define lambda_kwds_type 1073
+#define lambda_param_no_default_type 1074
+#define lambda_param_with_default_type 1075
+#define lambda_param_maybe_default_type 1076
+#define lambda_param_type 1077
+#define disjunction_type 1078
+#define conjunction_type 1079
+#define inversion_type 1080
+#define comparison_type 1081
+#define compare_op_bitwise_or_pair_type 1082
+#define eq_bitwise_or_type 1083
+#define noteq_bitwise_or_type 1084
+#define lte_bitwise_or_type 1085
+#define lt_bitwise_or_type 1086
+#define gte_bitwise_or_type 1087
+#define gt_bitwise_or_type 1088
+#define notin_bitwise_or_type 1089
+#define in_bitwise_or_type 1090
+#define isnot_bitwise_or_type 1091
+#define is_bitwise_or_type 1092
+#define bitwise_or_type 1093  // Left-recursive
+#define bitwise_xor_type 1094  // Left-recursive
+#define bitwise_and_type 1095  // Left-recursive
+#define shift_expr_type 1096  // Left-recursive
+#define sum_type 1097  // Left-recursive
+#define term_type 1098  // Left-recursive
+#define factor_type 1099
+#define power_type 1100
+#define await_primary_type 1101
+#define primary_type 1102  // Left-recursive
+#define slices_type 1103
+#define slice_type 1104
+#define atom_type 1105
+#define strings_type 1106
+#define list_type 1107
+#define listcomp_type 1108
+#define tuple_type 1109
+#define group_type 1110
+#define genexp_type 1111
+#define set_type 1112
+#define setcomp_type 1113
+#define dict_type 1114
+#define dictcomp_type 1115
+#define double_starred_kvpairs_type 1116
+#define double_starred_kvpair_type 1117
+#define kvpair_type 1118
+#define for_if_clauses_type 1119
+#define for_if_clause_type 1120
+#define yield_expr_type 1121
+#define arguments_type 1122
+#define args_type 1123
+#define kwargs_type 1124
+#define starred_expression_type 1125
+#define kwarg_or_starred_type 1126
+#define kwarg_or_double_starred_type 1127
+#define star_targets_type 1128
+#define star_targets_list_seq_type 1129
+#define star_targets_tuple_seq_type 1130
+#define star_target_type 1131
+#define target_with_star_atom_type 1132
+#define star_atom_type 1133
+#define single_target_type 1134
+#define single_subscript_attribute_target_type 1135
+#define del_targets_type 1136
+#define del_target_type 1137
+#define del_t_atom_type 1138
+#define t_primary_type 1139  // Left-recursive
+#define t_lookahead_type 1140
+#define invalid_arguments_type 1141
+#define invalid_kwarg_type 1142
+#define invalid_named_expression_type 1143
+#define invalid_assignment_type 1144
+#define invalid_ann_assign_target_type 1145
+#define invalid_del_stmt_type 1146
+#define invalid_block_type 1147
+#define invalid_primary_type 1148  // Left-recursive
+#define invalid_comprehension_type 1149
+#define invalid_dict_comprehension_type 1150
+#define invalid_parameters_type 1151
+#define invalid_lambda_parameters_type 1152
+#define invalid_star_etc_type 1153
+#define invalid_lambda_star_etc_type 1154
+#define invalid_double_type_comments_type 1155
+#define invalid_with_item_type 1156
+#define invalid_for_target_type 1157
+#define invalid_group_type 1158
+#define invalid_import_from_targets_type 1159
+#define _loop0_1_type 1160
+#define _loop0_2_type 1161
+#define _loop0_4_type 1162
+#define _gather_3_type 1163
+#define _loop0_6_type 1164
+#define _gather_5_type 1165
+#define _loop0_8_type 1166
+#define _gather_7_type 1167
+#define _loop0_10_type 1168
+#define _gather_9_type 1169
+#define _loop1_11_type 1170
+#define _loop0_13_type 1171
+#define _gather_12_type 1172
+#define _tmp_14_type 1173
+#define _tmp_15_type 1174
+#define _tmp_16_type 1175
+#define _tmp_17_type 1176
+#define _tmp_18_type 1177
+#define _tmp_19_type 1178
+#define _tmp_20_type 1179
+#define _tmp_21_type 1180
+#define _loop1_22_type 1181
+#define _tmp_23_type 1182
+#define _tmp_24_type 1183
+#define _loop0_26_type 1184
+#define _gather_25_type 1185
+#define _loop0_28_type 1186
+#define _gather_27_type 1187
+#define _tmp_29_type 1188
+#define _tmp_30_type 1189
+#define _loop0_31_type 1190
+#define _loop1_32_type 1191
+#define _loop0_34_type 1192
+#define _gather_33_type 1193
+#define _tmp_35_type 1194
+#define _loop0_37_type 1195
+#define _gather_36_type 1196
+#define _tmp_38_type 1197
+#define _loop0_40_type 1198
+#define _gather_39_type 1199
+#define _loop0_42_type 1200
+#define _gather_41_type 1201
+#define _loop0_44_type 1202
+#define _gather_43_type 1203
+#define _loop0_46_type 1204
+#define _gather_45_type 1205
+#define _tmp_47_type 1206
+#define _loop1_48_type 1207
+#define _tmp_49_type 1208
+#define _tmp_50_type 1209
+#define _tmp_51_type 1210
+#define _tmp_52_type 1211
+#define _tmp_53_type 1212
+#define _loop0_54_type 1213
+#define _loop0_55_type 1214
+#define _loop0_56_type 1215
+#define _loop1_57_type 1216
+#define _loop0_58_type 1217
+#define _loop1_59_type 1218
+#define _loop1_60_type 1219
+#define _loop1_61_type 1220
+#define _loop0_62_type 1221
+#define _loop1_63_type 1222
+#define _loop0_64_type 1223
+#define _loop1_65_type 1224
+#define _loop0_66_type 1225
+#define _loop1_67_type 1226
+#define _loop1_68_type 1227
+#define _tmp_69_type 1228
+#define _loop1_70_type 1229
+#define _loop0_72_type 1230
+#define _gather_71_type 1231
+#define _loop1_73_type 1232
+#define _loop0_74_type 1233
+#define _loop0_75_type 1234
+#define _loop0_76_type 1235
+#define _loop1_77_type 1236
+#define _loop0_78_type 1237
+#define _loop1_79_type 1238
+#define _loop1_80_type 1239
+#define _loop1_81_type 1240
+#define _loop0_82_type 1241
+#define _loop1_83_type 1242
+#define _loop0_84_type 1243
+#define _loop1_85_type 1244
+#define _loop0_86_type 1245
+#define _loop1_87_type 1246
+#define _loop1_88_type 1247
+#define _loop1_89_type 1248
+#define _loop1_90_type 1249
+#define _tmp_91_type 1250
+#define _loop0_93_type 1251
+#define _gather_92_type 1252
+#define _tmp_94_type 1253
+#define _tmp_95_type 1254
+#define _tmp_96_type 1255
+#define _tmp_97_type 1256
+#define _loop1_98_type 1257
+#define _tmp_99_type 1258
+#define _tmp_100_type 1259
+#define _loop0_102_type 1260
+#define _gather_101_type 1261
+#define _loop1_103_type 1262
+#define _loop0_104_type 1263
+#define _loop0_105_type 1264
+#define _loop0_107_type 1265
+#define _gather_106_type 1266
+#define _tmp_108_type 1267
+#define _loop0_110_type 1268
+#define _gather_109_type 1269
+#define _loop0_112_type 1270
+#define _gather_111_type 1271
+#define _loop0_114_type 1272
+#define _gather_113_type 1273
+#define _loop0_116_type 1274
+#define _gather_115_type 1275
+#define _loop0_117_type 1276
+#define _loop0_119_type 1277
+#define _gather_118_type 1278
+#define _loop1_120_type 1279
+#define _tmp_121_type 1280
+#define _loop0_123_type 1281
+#define _gather_122_type 1282
+#define _tmp_124_type 1283
+#define _tmp_125_type 1284
+#define _loop0_126_type 1285
+#define _loop0_127_type 1286
+#define _loop0_128_type 1287
+#define _tmp_129_type 1288
+#define _tmp_130_type 1289
+#define _loop0_131_type 1290
+#define _tmp_132_type 1291
+#define _loop0_133_type 1292
+#define _tmp_134_type 1293
+#define _tmp_135_type 1294
+#define _tmp_136_type 1295
+#define _tmp_137_type 1296
+#define _tmp_138_type 1297
+#define _tmp_139_type 1298
+#define _tmp_140_type 1299
+#define _tmp_141_type 1300
+#define _tmp_142_type 1301
+#define _tmp_143_type 1302
+#define _tmp_144_type 1303
+#define _tmp_145_type 1304
+#define _tmp_146_type 1305
+#define _tmp_147_type 1306
+#define _tmp_148_type 1307
+#define _tmp_149_type 1308
+#define _tmp_150_type 1309
+#define _tmp_151_type 1310
+#define _loop1_152_type 1311
+#define _loop1_153_type 1312
+#define _tmp_154_type 1313
+#define _tmp_155_type 1314
+
+static mod_ty file_rule(Parser *p);
+static mod_ty interactive_rule(Parser *p);
+static mod_ty eval_rule(Parser *p);
+static mod_ty func_type_rule(Parser *p);
+static expr_ty fstring_rule(Parser *p);
+static asdl_seq* type_expressions_rule(Parser *p);
+static asdl_seq* statements_rule(Parser *p);
+static asdl_seq* statement_rule(Parser *p);
+static asdl_seq* statement_newline_rule(Parser *p);
+static asdl_seq* simple_stmt_rule(Parser *p);
+static stmt_ty small_stmt_rule(Parser *p);
+static stmt_ty compound_stmt_rule(Parser *p);
+static stmt_ty assignment_rule(Parser *p);
+static AugOperator* augassign_rule(Parser *p);
+static stmt_ty global_stmt_rule(Parser *p);
+static stmt_ty nonlocal_stmt_rule(Parser *p);
+static stmt_ty yield_stmt_rule(Parser *p);
+static stmt_ty assert_stmt_rule(Parser *p);
+static stmt_ty del_stmt_rule(Parser *p);
+static stmt_ty import_stmt_rule(Parser *p);
+static stmt_ty import_name_rule(Parser *p);
+static stmt_ty import_from_rule(Parser *p);
+static asdl_seq* import_from_targets_rule(Parser *p);
+static asdl_seq* import_from_as_names_rule(Parser *p);
+static alias_ty import_from_as_name_rule(Parser *p);
+static asdl_seq* dotted_as_names_rule(Parser *p);
+static alias_ty dotted_as_name_rule(Parser *p);
+static expr_ty dotted_name_rule(Parser *p);
+static stmt_ty if_stmt_rule(Parser *p);
+static stmt_ty elif_stmt_rule(Parser *p);
+static asdl_seq* else_block_rule(Parser *p);
+static stmt_ty while_stmt_rule(Parser *p);
+static stmt_ty for_stmt_rule(Parser *p);
+static stmt_ty with_stmt_rule(Parser *p);
+static withitem_ty with_item_rule(Parser *p);
+static stmt_ty try_stmt_rule(Parser *p);
+static excepthandler_ty except_block_rule(Parser *p);
+static asdl_seq* finally_block_rule(Parser *p);
+static stmt_ty return_stmt_rule(Parser *p);
+static stmt_ty raise_stmt_rule(Parser *p);
+static stmt_ty function_def_rule(Parser *p);
+static stmt_ty function_def_raw_rule(Parser *p);
+static Token* func_type_comment_rule(Parser *p);
+static arguments_ty params_rule(Parser *p);
+static arguments_ty parameters_rule(Parser *p);
+static asdl_seq* slash_no_default_rule(Parser *p);
+static SlashWithDefault* slash_with_default_rule(Parser *p);
+static StarEtc* star_etc_rule(Parser *p);
+static arg_ty kwds_rule(Parser *p);
+static arg_ty param_no_default_rule(Parser *p);
+static NameDefaultPair* param_with_default_rule(Parser *p);
+static NameDefaultPair* param_maybe_default_rule(Parser *p);
+static arg_ty param_rule(Parser *p);
+static expr_ty annotation_rule(Parser *p);
+static expr_ty default_rule(Parser *p);
+static asdl_seq* decorators_rule(Parser *p);
+static stmt_ty class_def_rule(Parser *p);
+static stmt_ty class_def_raw_rule(Parser *p);
+static asdl_seq* block_rule(Parser *p);
+static expr_ty star_expressions_rule(Parser *p);
+static expr_ty star_expression_rule(Parser *p);
+static asdl_seq* star_named_expressions_rule(Parser *p);
+static expr_ty star_named_expression_rule(Parser *p);
+static expr_ty named_expression_rule(Parser *p);
+static expr_ty annotated_rhs_rule(Parser *p);
+static expr_ty expressions_rule(Parser *p);
+static expr_ty expression_rule(Parser *p);
+static expr_ty lambdef_rule(Parser *p);
+static arguments_ty lambda_params_rule(Parser *p);
+static arguments_ty lambda_parameters_rule(Parser *p);
+static asdl_seq* lambda_slash_no_default_rule(Parser *p);
+static SlashWithDefault* lambda_slash_with_default_rule(Parser *p);
+static StarEtc* lambda_star_etc_rule(Parser *p);
+static arg_ty lambda_kwds_rule(Parser *p);
+static arg_ty lambda_param_no_default_rule(Parser *p);
+static NameDefaultPair* lambda_param_with_default_rule(Parser *p);
+static NameDefaultPair* lambda_param_maybe_default_rule(Parser *p);
+static arg_ty lambda_param_rule(Parser *p);
+static expr_ty disjunction_rule(Parser *p);
+static expr_ty conjunction_rule(Parser *p);
+static expr_ty inversion_rule(Parser *p);
+static expr_ty comparison_rule(Parser *p);
+static CmpopExprPair* compare_op_bitwise_or_pair_rule(Parser *p);
+static CmpopExprPair* eq_bitwise_or_rule(Parser *p);
+static CmpopExprPair* noteq_bitwise_or_rule(Parser *p);
+static CmpopExprPair* lte_bitwise_or_rule(Parser *p);
+static CmpopExprPair* lt_bitwise_or_rule(Parser *p);
+static CmpopExprPair* gte_bitwise_or_rule(Parser *p);
+static CmpopExprPair* gt_bitwise_or_rule(Parser *p);
+static CmpopExprPair* notin_bitwise_or_rule(Parser *p);
+static CmpopExprPair* in_bitwise_or_rule(Parser *p);
+static CmpopExprPair* isnot_bitwise_or_rule(Parser *p);
+static CmpopExprPair* is_bitwise_or_rule(Parser *p);
+static expr_ty bitwise_or_rule(Parser *p);
+static expr_ty bitwise_xor_rule(Parser *p);
+static expr_ty bitwise_and_rule(Parser *p);
+static expr_ty shift_expr_rule(Parser *p);
+static expr_ty sum_rule(Parser *p);
+static expr_ty term_rule(Parser *p);
+static expr_ty factor_rule(Parser *p);
+static expr_ty power_rule(Parser *p);
+static expr_ty await_primary_rule(Parser *p);
+static expr_ty primary_rule(Parser *p);
+static expr_ty slices_rule(Parser *p);
+static expr_ty slice_rule(Parser *p);
+static expr_ty atom_rule(Parser *p);
+static expr_ty strings_rule(Parser *p);
+static expr_ty list_rule(Parser *p);
+static expr_ty listcomp_rule(Parser *p);
+static expr_ty tuple_rule(Parser *p);
+static expr_ty group_rule(Parser *p);
+static expr_ty genexp_rule(Parser *p);
+static expr_ty set_rule(Parser *p);
+static expr_ty setcomp_rule(Parser *p);
+static expr_ty dict_rule(Parser *p);
+static expr_ty dictcomp_rule(Parser *p);
+static asdl_seq* double_starred_kvpairs_rule(Parser *p);
+static KeyValuePair* double_starred_kvpair_rule(Parser *p);
+static KeyValuePair* kvpair_rule(Parser *p);
+static asdl_seq* for_if_clauses_rule(Parser *p);
+static comprehension_ty for_if_clause_rule(Parser *p);
+static expr_ty yield_expr_rule(Parser *p);
+static expr_ty arguments_rule(Parser *p);
+static expr_ty args_rule(Parser *p);
+static asdl_seq* kwargs_rule(Parser *p);
+static expr_ty starred_expression_rule(Parser *p);
+static KeywordOrStarred* kwarg_or_starred_rule(Parser *p);
+static KeywordOrStarred* kwarg_or_double_starred_rule(Parser *p);
+static expr_ty star_targets_rule(Parser *p);
+static asdl_seq* star_targets_list_seq_rule(Parser *p);
+static asdl_seq* star_targets_tuple_seq_rule(Parser *p);
+static expr_ty star_target_rule(Parser *p);
+static expr_ty target_with_star_atom_rule(Parser *p);
+static expr_ty star_atom_rule(Parser *p);
+static expr_ty single_target_rule(Parser *p);
+static expr_ty single_subscript_attribute_target_rule(Parser *p);
+static asdl_seq* del_targets_rule(Parser *p);
+static expr_ty del_target_rule(Parser *p);
+static expr_ty del_t_atom_rule(Parser *p);
+static expr_ty t_primary_rule(Parser *p);
+static void *t_lookahead_rule(Parser *p);
+static void *invalid_arguments_rule(Parser *p);
+static void *invalid_kwarg_rule(Parser *p);
+static void *invalid_named_expression_rule(Parser *p);
+static void *invalid_assignment_rule(Parser *p);
+static expr_ty invalid_ann_assign_target_rule(Parser *p);
+static void *invalid_del_stmt_rule(Parser *p);
+static void *invalid_block_rule(Parser *p);
+static void *invalid_primary_rule(Parser *p);
+static void *invalid_comprehension_rule(Parser *p);
+static void *invalid_dict_comprehension_rule(Parser *p);
+static void *invalid_parameters_rule(Parser *p);
+static void *invalid_lambda_parameters_rule(Parser *p);
+static void *invalid_star_etc_rule(Parser *p);
+static void *invalid_lambda_star_etc_rule(Parser *p);
+static void *invalid_double_type_comments_rule(Parser *p);
+static void *invalid_with_item_rule(Parser *p);
+static void *invalid_for_target_rule(Parser *p);
+static void *invalid_group_rule(Parser *p);
+static void *invalid_import_from_targets_rule(Parser *p);
+static asdl_seq *_loop0_1_rule(Parser *p);
+static asdl_seq *_loop0_2_rule(Parser *p);
+static asdl_seq *_loop0_4_rule(Parser *p);
+static asdl_seq *_gather_3_rule(Parser *p);
+static asdl_seq *_loop0_6_rule(Parser *p);
+static asdl_seq *_gather_5_rule(Parser *p);
+static asdl_seq *_loop0_8_rule(Parser *p);
+static asdl_seq *_gather_7_rule(Parser *p);
+static asdl_seq *_loop0_10_rule(Parser *p);
+static asdl_seq *_gather_9_rule(Parser *p);
+static asdl_seq *_loop1_11_rule(Parser *p);
+static asdl_seq *_loop0_13_rule(Parser *p);
+static asdl_seq *_gather_12_rule(Parser *p);
+static void *_tmp_14_rule(Parser *p);
+static void *_tmp_15_rule(Parser *p);
+static void *_tmp_16_rule(Parser *p);
+static void *_tmp_17_rule(Parser *p);
+static void *_tmp_18_rule(Parser *p);
+static void *_tmp_19_rule(Parser *p);
+static void *_tmp_20_rule(Parser *p);
+static void *_tmp_21_rule(Parser *p);
+static asdl_seq *_loop1_22_rule(Parser *p);
+static void *_tmp_23_rule(Parser *p);
+static void *_tmp_24_rule(Parser *p);
+static asdl_seq *_loop0_26_rule(Parser *p);
+static asdl_seq *_gather_25_rule(Parser *p);
+static asdl_seq *_loop0_28_rule(Parser *p);
+static asdl_seq *_gather_27_rule(Parser *p);
+static void *_tmp_29_rule(Parser *p);
+static void *_tmp_30_rule(Parser *p);
+static asdl_seq *_loop0_31_rule(Parser *p);
+static asdl_seq *_loop1_32_rule(Parser *p);
+static asdl_seq *_loop0_34_rule(Parser *p);
+static asdl_seq *_gather_33_rule(Parser *p);
+static void *_tmp_35_rule(Parser *p);
+static asdl_seq *_loop0_37_rule(Parser *p);
+static asdl_seq *_gather_36_rule(Parser *p);
+static void *_tmp_38_rule(Parser *p);
+static asdl_seq *_loop0_40_rule(Parser *p);
+static asdl_seq *_gather_39_rule(Parser *p);
+static asdl_seq *_loop0_42_rule(Parser *p);
+static asdl_seq *_gather_41_rule(Parser *p);
+static asdl_seq *_loop0_44_rule(Parser *p);
+static asdl_seq *_gather_43_rule(Parser *p);
+static asdl_seq *_loop0_46_rule(Parser *p);
+static asdl_seq *_gather_45_rule(Parser *p);
+static void *_tmp_47_rule(Parser *p);
+static asdl_seq *_loop1_48_rule(Parser *p);
+static void *_tmp_49_rule(Parser *p);
+static void *_tmp_50_rule(Parser *p);
+static void *_tmp_51_rule(Parser *p);
+static void *_tmp_52_rule(Parser *p);
+static void *_tmp_53_rule(Parser *p);
+static asdl_seq *_loop0_54_rule(Parser *p);
+static asdl_seq *_loop0_55_rule(Parser *p);
+static asdl_seq *_loop0_56_rule(Parser *p);
+static asdl_seq *_loop1_57_rule(Parser *p);
+static asdl_seq *_loop0_58_rule(Parser *p);
+static asdl_seq *_loop1_59_rule(Parser *p);
+static asdl_seq *_loop1_60_rule(Parser *p);
+static asdl_seq *_loop1_61_rule(Parser *p);
+static asdl_seq *_loop0_62_rule(Parser *p);
+static asdl_seq *_loop1_63_rule(Parser *p);
+static asdl_seq *_loop0_64_rule(Parser *p);
+static asdl_seq *_loop1_65_rule(Parser *p);
+static asdl_seq *_loop0_66_rule(Parser *p);
+static asdl_seq *_loop1_67_rule(Parser *p);
+static asdl_seq *_loop1_68_rule(Parser *p);
+static void *_tmp_69_rule(Parser *p);
+static asdl_seq *_loop1_70_rule(Parser *p);
+static asdl_seq *_loop0_72_rule(Parser *p);
+static asdl_seq *_gather_71_rule(Parser *p);
+static asdl_seq *_loop1_73_rule(Parser *p);
+static asdl_seq *_loop0_74_rule(Parser *p);
+static asdl_seq *_loop0_75_rule(Parser *p);
+static asdl_seq *_loop0_76_rule(Parser *p);
+static asdl_seq *_loop1_77_rule(Parser *p);
+static asdl_seq *_loop0_78_rule(Parser *p);
+static asdl_seq *_loop1_79_rule(Parser *p);
+static asdl_seq *_loop1_80_rule(Parser *p);
+static asdl_seq *_loop1_81_rule(Parser *p);
+static asdl_seq *_loop0_82_rule(Parser *p);
+static asdl_seq *_loop1_83_rule(Parser *p);
+static asdl_seq *_loop0_84_rule(Parser *p);
+static asdl_seq *_loop1_85_rule(Parser *p);
+static asdl_seq *_loop0_86_rule(Parser *p);
+static asdl_seq *_loop1_87_rule(Parser *p);
+static asdl_seq *_loop1_88_rule(Parser *p);
+static asdl_seq *_loop1_89_rule(Parser *p);
+static asdl_seq *_loop1_90_rule(Parser *p);
+static void *_tmp_91_rule(Parser *p);
+static asdl_seq *_loop0_93_rule(Parser *p);
+static asdl_seq *_gather_92_rule(Parser *p);
+static void *_tmp_94_rule(Parser *p);
+static void *_tmp_95_rule(Parser *p);
+static void *_tmp_96_rule(Parser *p);
+static void *_tmp_97_rule(Parser *p);
+static asdl_seq *_loop1_98_rule(Parser *p);
+static void *_tmp_99_rule(Parser *p);
+static void *_tmp_100_rule(Parser *p);
+static asdl_seq *_loop0_102_rule(Parser *p);
+static asdl_seq *_gather_101_rule(Parser *p);
+static asdl_seq *_loop1_103_rule(Parser *p);
+static asdl_seq *_loop0_104_rule(Parser *p);
+static asdl_seq *_loop0_105_rule(Parser *p);
+static asdl_seq *_loop0_107_rule(Parser *p);
+static asdl_seq *_gather_106_rule(Parser *p);
+static void *_tmp_108_rule(Parser *p);
+static asdl_seq *_loop0_110_rule(Parser *p);
+static asdl_seq *_gather_109_rule(Parser *p);
+static asdl_seq *_loop0_112_rule(Parser *p);
+static asdl_seq *_gather_111_rule(Parser *p);
+static asdl_seq *_loop0_114_rule(Parser *p);
+static asdl_seq *_gather_113_rule(Parser *p);
+static asdl_seq *_loop0_116_rule(Parser *p);
+static asdl_seq *_gather_115_rule(Parser *p);
+static asdl_seq *_loop0_117_rule(Parser *p);
+static asdl_seq *_loop0_119_rule(Parser *p);
+static asdl_seq *_gather_118_rule(Parser *p);
+static asdl_seq *_loop1_120_rule(Parser *p);
+static void *_tmp_121_rule(Parser *p);
+static asdl_seq *_loop0_123_rule(Parser *p);
+static asdl_seq *_gather_122_rule(Parser *p);
+static void *_tmp_124_rule(Parser *p);
+static void *_tmp_125_rule(Parser *p);
+static asdl_seq *_loop0_126_rule(Parser *p);
+static asdl_seq *_loop0_127_rule(Parser *p);
+static asdl_seq *_loop0_128_rule(Parser *p);
+static void *_tmp_129_rule(Parser *p);
+static void *_tmp_130_rule(Parser *p);
+static asdl_seq *_loop0_131_rule(Parser *p);
+static void *_tmp_132_rule(Parser *p);
+static asdl_seq *_loop0_133_rule(Parser *p);
+static void *_tmp_134_rule(Parser *p);
+static void *_tmp_135_rule(Parser *p);
+static void *_tmp_136_rule(Parser *p);
+static void *_tmp_137_rule(Parser *p);
+static void *_tmp_138_rule(Parser *p);
+static void *_tmp_139_rule(Parser *p);
+static void *_tmp_140_rule(Parser *p);
+static void *_tmp_141_rule(Parser *p);
+static void *_tmp_142_rule(Parser *p);
+static void *_tmp_143_rule(Parser *p);
+static void *_tmp_144_rule(Parser *p);
+static void *_tmp_145_rule(Parser *p);
+static void *_tmp_146_rule(Parser *p);
+static void *_tmp_147_rule(Parser *p);
+static void *_tmp_148_rule(Parser *p);
+static void *_tmp_149_rule(Parser *p);
+static void *_tmp_150_rule(Parser *p);
+static void *_tmp_151_rule(Parser *p);
+static asdl_seq *_loop1_152_rule(Parser *p);
+static asdl_seq *_loop1_153_rule(Parser *p);
+static void *_tmp_154_rule(Parser *p);
+static void *_tmp_155_rule(Parser *p);
+
+
+// file: statements? $
+static mod_ty
+file_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    mod_ty _res = NULL;
+    int _mark = p->mark;
+    { // statements? $
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $"));
+        void *a;
+        Token * endmarker_var;
+        if (
+            (a = statements_rule(p), !p->error_indicator)  // statements?
+            &&
+            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'
+        )
+        {
+            D(fprintf(stderr, "%*c+ file[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statements? $"));
+            _res = _PyPegen_make_module ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s file[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statements? $"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// interactive: statement_newline
+static mod_ty
+interactive_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    mod_ty _res = NULL;
+    int _mark = p->mark;
+    { // statement_newline
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline"));
+        asdl_seq* a;
+        if (
+            (a = statement_newline_rule(p))  // statement_newline
+        )
+        {
+            D(fprintf(stderr, "%*c+ interactive[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement_newline"));
+            _res = Interactive ( a , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s interactive[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement_newline"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// eval: expressions NEWLINE* $
+static mod_ty
+eval_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    mod_ty _res = NULL;
+    int _mark = p->mark;
+    { // expressions NEWLINE* $
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
+        asdl_seq * _loop0_1_var;
+        expr_ty a;
+        Token * endmarker_var;
+        if (
+            (a = expressions_rule(p))  // expressions
+            &&
+            (_loop0_1_var = _loop0_1_rule(p))  // NEWLINE*
+            &&
+            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'
+        )
+        {
+            D(fprintf(stderr, "%*c+ eval[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
+            _res = Expression ( a , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s eval[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expressions NEWLINE* $"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// func_type: '(' type_expressions? ')' '->' expression NEWLINE* $
+static mod_ty
+func_type_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    mod_ty _res = NULL;
+    int _mark = p->mark;
+    { // '(' type_expressions? ')' '->' expression NEWLINE* $
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        asdl_seq * _loop0_2_var;
+        void *a;
+        expr_ty b;
+        Token * endmarker_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = type_expressions_rule(p), !p->error_indicator)  // type_expressions?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 51))  // token='->'
+            &&
+            (b = expression_rule(p))  // expression
+            &&
+            (_loop0_2_var = _loop0_2_rule(p))  // NEWLINE*
+            &&
+            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'
+        )
+        {
+            D(fprintf(stderr, "%*c+ func_type[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
+            _res = FunctionType ( a , b , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s func_type[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// fstring: star_expressions
+static expr_ty
+fstring_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ fstring[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+            _res = star_expressions_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s fstring[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// type_expressions:
+//     | ','.expression+ ',' '*' expression ',' '**' expression
+//     | ','.expression+ ',' '*' expression
+//     | ','.expression+ ',' '**' expression
+//     | '*' expression ',' '**' expression
+//     | '*' expression
+//     | '**' expression
+//     | ','.expression+
+static asdl_seq*
+type_expressions_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.expression+ ',' '*' expression ',' '**' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        Token * _literal_3;
+        asdl_seq * a;
+        expr_ty b;
+        expr_ty c;
+        if (
+            (a = _gather_3_rule(p))  // ','.expression+
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (b = expression_rule(p))  // expression
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_literal_3 = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (c = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
+            _res = _PyPegen_seq_append_to_end ( p , CHECK ( _PyPegen_seq_append_to_end ( p , a , b ) ) , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
+    }
+    { // ','.expression+ ',' '*' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * a;
+        expr_ty b;
+        if (
+            (a = _gather_5_rule(p))  // ','.expression+
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression"));
+            _res = _PyPegen_seq_append_to_end ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '*' expression"));
+    }
+    { // ','.expression+ ',' '**' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * a;
+        expr_ty b;
+        if (
+            (a = _gather_7_rule(p))  // ','.expression+
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression"));
+            _res = _PyPegen_seq_append_to_end ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+ ',' '**' expression"));
+    }
+    { // '*' expression ',' '**' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression"));
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = expression_rule(p))  // expression
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression"));
+            _res = _PyPegen_seq_append_to_end ( p , CHECK ( _PyPegen_singleton_seq ( p , a ) ) , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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 (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
+            _res = _PyPegen_singleton_seq ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));
+    }
+    { // '**' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
+            _res = _PyPegen_singleton_seq ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' expression"));
+    }
+    { // ','.expression+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+"));
+        asdl_seq * _gather_9_var;
+        if (
+            (_gather_9_var = _gather_9_rule(p))  // ','.expression+
+        )
+        {
+            D(fprintf(stderr, "%*c+ type_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.expression+"));
+            _res = _gather_9_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s type_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.expression+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// statements: statement+
+static asdl_seq*
+statements_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // statement+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+"));
+        asdl_seq * a;
+        if (
+            (a = _loop1_11_rule(p))  // statement+
+        )
+        {
+            D(fprintf(stderr, "%*c+ statements[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "statement+"));
+            _res = _PyPegen_seq_flatten ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statements[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// statement: compound_stmt | simple_stmt
+static asdl_seq*
+statement_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // compound_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
+        stmt_ty a;
+        if (
+            (a = compound_stmt_rule(p))  // compound_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
+            _res = _PyPegen_singleton_seq ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt"));
+    }
+    { // simple_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
+        asdl_seq* simple_stmt_var;
+        if (
+            (simple_stmt_var = simple_stmt_rule(p))  // simple_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ statement[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
+            _res = simple_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statement[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// statement_newline: compound_stmt NEWLINE | simple_stmt | NEWLINE | $
+static asdl_seq*
+statement_newline_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // compound_stmt NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE"));
+        stmt_ty a;
+        Token * newline_var;
+        if (
+            (a = compound_stmt_rule(p))  // compound_stmt
+            &&
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE"));
+            _res = _PyPegen_singleton_seq ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compound_stmt NEWLINE"));
+    }
+    { // simple_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
+        asdl_seq* simple_stmt_var;
+        if (
+            (simple_stmt_var = simple_stmt_rule(p))  // simple_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
+            _res = simple_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt"));
+    }
+    { // NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
+        Token * newline_var;
+        if (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _PyPegen_singleton_seq ( p , CHECK ( _Py_Pass ( EXTRA ) ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
+    }
+    { // $
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$"));
+        Token * endmarker_var;
+        if (
+            (endmarker_var = _PyPegen_expect_token(p, ENDMARKER))  // token='ENDMARKER'
+        )
+        {
+            D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "$"));
+            _res = _PyPegen_interactive_exit ( p );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s statement_newline[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "$"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// simple_stmt: small_stmt !';' NEWLINE | ';'.small_stmt+ ';'? NEWLINE
+static asdl_seq*
+simple_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // small_stmt !';' NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "small_stmt !';' NEWLINE"));
+        stmt_ty a;
+        Token * newline_var;
+        if (
+            (a = small_stmt_rule(p))  // small_stmt
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 13)  // token=';'
+            &&
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "small_stmt !';' NEWLINE"));
+            _res = _PyPegen_singleton_seq ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "small_stmt !';' NEWLINE"));
+    }
+    { // ';'.small_stmt+ ';'? NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        Token * newline_var;
+        if (
+            (a = _gather_12_rule(p))  // ';'.small_stmt+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 13), !p->error_indicator)  // ';'?
+            &&
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ simple_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s simple_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// small_stmt:
+//     | assignment
+//     | star_expressions
+//     | &'return' return_stmt
+//     | &('import' | 'from') import_stmt
+//     | &'raise' raise_stmt
+//     | 'pass'
+//     | &'del' del_stmt
+//     | &'yield' yield_stmt
+//     | &'assert' assert_stmt
+//     | 'break'
+//     | 'continue'
+//     | &'global' global_stmt
+//     | &'nonlocal' nonlocal_stmt
+static stmt_ty
+small_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    stmt_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, small_stmt_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // assignment
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment"));
+        stmt_ty assignment_var;
+        if (
+            (assignment_var = assignment_rule(p))  // assignment
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "assignment"));
+            _res = assignment_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "assignment"));
+    }
+    { // star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+        expr_ty e;
+        if (
+            (e = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Expr ( e , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
+    }
+    { // &'return' return_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
+        stmt_ty return_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 500)  // token='return'
+            &&
+            (return_stmt_var = return_stmt_rule(p))  // return_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
+            _res = return_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'return' return_stmt"));
+    }
+    { // &('import' | 'from') import_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
+        stmt_ty import_stmt_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_14_rule, p)
+            &&
+            (import_stmt_var = import_stmt_rule(p))  // import_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
+            _res = import_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('import' | 'from') import_stmt"));
+    }
+    { // &'raise' raise_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
+        stmt_ty raise_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 501)  // token='raise'
+            &&
+            (raise_stmt_var = raise_stmt_rule(p))  // raise_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
+            _res = raise_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'raise' raise_stmt"));
+    }
+    { // 'pass'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 502))  // token='pass'
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Pass ( EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'pass'"));
+    }
+    { // &'del' del_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
+        stmt_ty del_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 503)  // token='del'
+            &&
+            (del_stmt_var = del_stmt_rule(p))  // del_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
+            _res = del_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'del' del_stmt"));
+    }
+    { // &'yield' yield_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
+        stmt_ty yield_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 504)  // token='yield'
+            &&
+            (yield_stmt_var = yield_stmt_rule(p))  // yield_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
+            _res = yield_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'yield' yield_stmt"));
+    }
+    { // &'assert' assert_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
+        stmt_ty assert_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 505)  // token='assert'
+            &&
+            (assert_stmt_var = assert_stmt_rule(p))  // assert_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
+            _res = assert_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'assert' assert_stmt"));
+    }
+    { // 'break'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 506))  // token='break'
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Break ( EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'break'"));
+    }
+    { // 'continue'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 507))  // token='continue'
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Continue ( EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'continue'"));
+    }
+    { // &'global' global_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
+        stmt_ty global_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 508)  // token='global'
+            &&
+            (global_stmt_var = global_stmt_rule(p))  // global_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
+            _res = global_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'global' global_stmt"));
+    }
+    { // &'nonlocal' nonlocal_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
+        stmt_ty nonlocal_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 509)  // token='nonlocal'
+            &&
+            (nonlocal_stmt_var = nonlocal_stmt_rule(p))  // nonlocal_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
+            _res = nonlocal_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s small_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, small_stmt_type, _res);
+    p->level--;
+    return _res;
+}
+
+// compound_stmt:
+//     | &('def' | '@' | ASYNC) function_def
+//     | &'if' if_stmt
+//     | &('class' | '@') class_def
+//     | &('with' | ASYNC) with_stmt
+//     | &('for' | ASYNC) for_stmt
+//     | &'try' try_stmt
+//     | &'while' while_stmt
+static stmt_ty
+compound_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    stmt_ty _res = NULL;
+    int _mark = p->mark;
+    { // &('def' | '@' | ASYNC) function_def
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def"));
+        stmt_ty function_def_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_15_rule, p)
+            &&
+            (function_def_var = function_def_rule(p))  // function_def
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def"));
+            _res = function_def_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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' if_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
+        stmt_ty if_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 510)  // token='if'
+            &&
+            (if_stmt_var = if_stmt_rule(p))  // if_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
+            _res = if_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'if' if_stmt"));
+    }
+    { // &('class' | '@') class_def
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
+        stmt_ty class_def_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_16_rule, p)
+            &&
+            (class_def_var = class_def_rule(p))  // class_def
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
+            _res = class_def_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&('class' | '@') class_def"));
+    }
+    { // &('with' | ASYNC) with_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt"));
+        stmt_ty with_stmt_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_17_rule, p)
+            &&
+            (with_stmt_var = with_stmt_rule(p))  // with_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt"));
+            _res = with_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // &('for' | ASYNC) for_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt"));
+        stmt_ty for_stmt_var;
+        if (
+            _PyPegen_lookahead(1, _tmp_18_rule, p)
+            &&
+            (for_stmt_var = for_stmt_rule(p))  // for_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt"));
+            _res = for_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // &'try' try_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
+        stmt_ty try_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 511)  // token='try'
+            &&
+            (try_stmt_var = try_stmt_rule(p))  // try_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
+            _res = try_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'try' try_stmt"));
+    }
+    { // &'while' while_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
+        stmt_ty while_stmt_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 512)  // token='while'
+            &&
+            (while_stmt_var = while_stmt_rule(p))  // while_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ compound_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
+            _res = while_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compound_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'while' while_stmt"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// assignment:
+//     | NAME ':' expression ['=' annotated_rhs]
+//     | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]
+//     | ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?
+//     | single_target augassign ~ (yield_expr | star_expressions)
+//     | invalid_assignment
+static stmt_ty
+assignment_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME ':' expression ['=' annotated_rhs]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        void *c;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = expression_rule(p))  // expression
+            &&
+            (c = _tmp_19_rule(p), !p->error_indicator)  // ['=' annotated_rhs]
+        )
+        {
+            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 6 , "Variable annotation syntax is" , _Py_AnnAssign ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
+    }
+    { // ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
+        Token * _literal;
+        void *a;
+        expr_ty b;
+        void *c;
+        if (
+            (a = _tmp_20_rule(p))  // '(' single_target ')' | single_subscript_attribute_target
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = expression_rule(p))  // expression
+            &&
+            (c = _tmp_21_rule(p), !p->error_indicator)  // ['=' annotated_rhs]
+        )
+        {
+            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 6 , "Variable annotations syntax is" , _Py_AnnAssign ( a , b , c , 0 , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
+    }
+    { // ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
+        asdl_seq * a;
+        void *b;
+        void *tc;
+        if (
+            (a = _loop1_22_rule(p))  // ((star_targets '='))+
+            &&
+            (b = _tmp_23_rule(p))  // yield_expr | star_expressions
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)  // token='='
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+        )
+        {
+            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
+    }
+    { // single_target augassign ~ (yield_expr | star_expressions)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
+        int _cut_var = 0;
+        expr_ty a;
+        AugOperator* b;
+        void *c;
+        if (
+            (a = single_target_rule(p))  // single_target
+            &&
+            (b = augassign_rule(p))  // augassign
+            &&
+            (_cut_var = 1)
+            &&
+            (c = _tmp_24_rule(p))  // yield_expr | star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_AugAssign ( a , b -> kind , c , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    if (p->call_invalid_rules) { // invalid_assignment
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignment"));
+        void *invalid_assignment_var;
+        if (
+            (invalid_assignment_var = invalid_assignment_rule(p))  // invalid_assignment
+        )
+        {
+            D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_assignment"));
+            _res = invalid_assignment_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_assignment"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// augassign:
+//     | '+='
+//     | '-='
+//     | '*='
+//     | '@='
+//     | '/='
+//     | '%='
+//     | '&='
+//     | '|='
+//     | '^='
+//     | '<<='
+//     | '>>='
+//     | '**='
+//     | '//='
+static AugOperator*
+augassign_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    AugOperator* _res = NULL;
+    int _mark = p->mark;
+    { // '+='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 36))  // token='+='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+='"));
+            _res = _PyPegen_augoperator ( p , Add );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+='"));
+    }
+    { // '-='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 37))  // token='-='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-='"));
+            _res = _PyPegen_augoperator ( p , Sub );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-='"));
+    }
+    { // '*='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 38))  // token='*='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*='"));
+            _res = _PyPegen_augoperator ( p , Mult );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*='"));
+    }
+    { // '@='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 50))  // token='@='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@='"));
+            _res = CHECK_VERSION ( 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@='"));
+    }
+    { // '/='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 39))  // token='/='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'/='"));
+            _res = _PyPegen_augoperator ( p , Div );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'/='"));
+    }
+    { // '%='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 40))  // token='%='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'%='"));
+            _res = _PyPegen_augoperator ( p , Mod );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'%='"));
+    }
+    { // '&='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 41))  // token='&='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'&='"));
+            _res = _PyPegen_augoperator ( p , BitAnd );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'&='"));
+    }
+    { // '|='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 42))  // token='|='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'|='"));
+            _res = _PyPegen_augoperator ( p , BitOr );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'|='"));
+    }
+    { // '^='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 43))  // token='^='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'^='"));
+            _res = _PyPegen_augoperator ( p , BitXor );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'^='"));
+    }
+    { // '<<='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 44))  // token='<<='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<<='"));
+            _res = _PyPegen_augoperator ( p , LShift );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<<='"));
+    }
+    { // '>>='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 45))  // token='>>='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>>='"));
+            _res = _PyPegen_augoperator ( p , RShift );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>>='"));
+    }
+    { // '**='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 46))  // token='**='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**='"));
+            _res = _PyPegen_augoperator ( p , Pow );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**='"));
+    }
+    { // '//='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 48))  // token='//='
+        )
+        {
+            D(fprintf(stderr, "%*c+ augassign[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'//='"));
+            _res = _PyPegen_augoperator ( p , FloorDiv );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s augassign[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'//='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// global_stmt: 'global' ','.NAME+
+static stmt_ty
+global_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'global' ','.NAME+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
+        Token * _keyword;
+        asdl_seq * a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 508))  // token='global'
+            &&
+            (a = _gather_25_rule(p))  // ','.NAME+
+        )
+        {
+            D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Global ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s global_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'global' ','.NAME+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// nonlocal_stmt: 'nonlocal' ','.NAME+
+static stmt_ty
+nonlocal_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'nonlocal' ','.NAME+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
+        Token * _keyword;
+        asdl_seq * a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 509))  // token='nonlocal'
+            &&
+            (a = _gather_27_rule(p))  // ','.NAME+
+        )
+        {
+            D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Nonlocal ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s nonlocal_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'nonlocal' ','.NAME+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// yield_stmt: yield_expr
+static stmt_ty
+yield_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // yield_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+        expr_ty y;
+        if (
+            (y = yield_expr_rule(p))  // yield_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Expr ( y , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s yield_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// assert_stmt: 'assert' expression [',' expression]
+static stmt_ty
+assert_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'assert' expression [',' expression]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
+        Token * _keyword;
+        expr_ty a;
+        void *b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 505))  // token='assert'
+            &&
+            (a = expression_rule(p))  // expression
+            &&
+            (b = _tmp_29_rule(p), !p->error_indicator)  // [',' expression]
+        )
+        {
+            D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Assert ( a , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s assert_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'assert' expression [',' expression]"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt
+static stmt_ty
+del_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'del' del_targets &(';' | NEWLINE)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
+        Token * _keyword;
+        asdl_seq* a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 503))  // token='del'
+            &&
+            (a = del_targets_rule(p))  // del_targets
+            &&
+            _PyPegen_lookahead(1, _tmp_30_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Delete ( a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
+    }
+    if (p->call_invalid_rules) { // invalid_del_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt"));
+        void *invalid_del_stmt_var;
+        if (
+            (invalid_del_stmt_var = invalid_del_stmt_rule(p))  // invalid_del_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt"));
+            _res = invalid_del_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_del_stmt"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// import_stmt: import_name | import_from
+static stmt_ty
+import_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    stmt_ty _res = NULL;
+    int _mark = p->mark;
+    { // import_name
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name"));
+        stmt_ty import_name_var;
+        if (
+            (import_name_var = import_name_rule(p))  // import_name
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_name"));
+            _res = import_name_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_name"));
+    }
+    { // import_from
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from"));
+        stmt_ty import_from_var;
+        if (
+            (import_from_var = import_from_rule(p))  // import_from
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from"));
+            _res = import_from_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// import_name: 'import' dotted_as_names
+static stmt_ty
+import_name_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'import' dotted_as_names
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
+        Token * _keyword;
+        asdl_seq* a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 513))  // token='import'
+            &&
+            (a = dotted_as_names_rule(p))  // dotted_as_names
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Import ( a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_name[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import' dotted_as_names"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// import_from:
+//     | 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
+//     | 'from' (('.' | '...'))+ 'import' import_from_targets
+static stmt_ty
+import_from_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
+        Token * _keyword;
+        Token * _keyword_1;
+        asdl_seq * a;
+        expr_ty b;
+        asdl_seq* c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 514))  // token='from'
+            &&
+            (a = _loop0_31_rule(p))  // (('.' | '...'))*
+            &&
+            (b = dotted_name_rule(p))  // dotted_name
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 513))  // token='import'
+            &&
+            (c = import_from_targets_rule(p))  // import_from_targets
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
+    }
+    { // 'from' (('.' | '...'))+ 'import' import_from_targets
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
+        Token * _keyword;
+        Token * _keyword_1;
+        asdl_seq * a;
+        asdl_seq* b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 514))  // token='from'
+            &&
+            (a = _loop1_32_rule(p))  // (('.' | '...'))+
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 513))  // token='import'
+            &&
+            (b = import_from_targets_rule(p))  // import_from_targets
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_from[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// import_from_targets:
+//     | '(' import_from_as_names ','? ')'
+//     | import_from_as_names !','
+//     | '*'
+//     | invalid_import_from_targets
+static asdl_seq*
+import_from_targets_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // '(' import_from_as_names ','? ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq* a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = import_from_as_names_rule(p))  // import_from_as_names
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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 ','? ')'"));
+    }
+    { // import_from_as_names !','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','"));
+        asdl_seq* import_from_as_names_var;
+        if (
+            (import_from_as_names_var = import_from_as_names_rule(p))  // import_from_as_names
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','"));
+            _res = import_from_as_names_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*'"));
+            _res = _PyPegen_singleton_seq ( p , CHECK ( _PyPegen_alias_for_star ( p ) ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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) { // invalid_import_from_targets
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets"));
+        void *invalid_import_from_targets_var;
+        if (
+            (invalid_import_from_targets_var = invalid_import_from_targets_rule(p))  // invalid_import_from_targets
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets"));
+            _res = invalid_import_from_targets_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// import_from_as_names: ','.import_from_as_name+
+static asdl_seq*
+import_from_as_names_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.import_from_as_name+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+"));
+        asdl_seq * a;
+        if (
+            (a = _gather_33_rule(p))  // ','.import_from_as_name+
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_from_as_names[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.import_from_as_name+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// import_from_as_name: NAME ['as' NAME]
+static alias_ty
+import_from_as_name_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    alias_ty _res = NULL;
+    int _mark = p->mark;
+    { // NAME ['as' NAME]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]"));
+        expr_ty a;
+        void *b;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (b = _tmp_35_rule(p), !p->error_indicator)  // ['as' NAME]
+        )
+        {
+            D(fprintf(stderr, "%*c+ import_from_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]"));
+            _res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s import_from_as_name[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ['as' NAME]"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// dotted_as_names: ','.dotted_as_name+
+static asdl_seq*
+dotted_as_names_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.dotted_as_name+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
+        asdl_seq * a;
+        if (
+            (a = _gather_36_rule(p))  // ','.dotted_as_name+
+        )
+        {
+            D(fprintf(stderr, "%*c+ dotted_as_names[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dotted_as_names[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.dotted_as_name+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// dotted_as_name: dotted_name ['as' NAME]
+static alias_ty
+dotted_as_name_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    alias_ty _res = NULL;
+    int _mark = p->mark;
+    { // dotted_name ['as' NAME]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]"));
+        expr_ty a;
+        void *b;
+        if (
+            (a = dotted_name_rule(p))  // dotted_name
+            &&
+            (b = _tmp_38_rule(p), !p->error_indicator)  // ['as' NAME]
+        )
+        {
+            D(fprintf(stderr, "%*c+ dotted_as_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]"));
+            _res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dotted_as_name[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name ['as' NAME]"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// dotted_name: dotted_name '.' NAME | NAME
+static expr_ty dotted_name_raw(Parser *);
+static expr_ty
+dotted_name_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res);
+        if (tmpvar_0) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = dotted_name_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+dotted_name_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // dotted_name '.' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = dotted_name_rule(p))  // dotted_name
+            &&
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+            &&
+            (b = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
+            _res = _PyPegen_join_names_with_dot ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_name '.' NAME"));
+    }
+    { // NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
+        expr_ty name_var;
+        if (
+            (name_var = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ dotted_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
+            _res = name_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dotted_name[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// if_stmt:
+//     | 'if' named_expression ':' block elif_stmt
+//     | 'if' named_expression ':' block else_block?
+static stmt_ty
+if_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'if' named_expression ':' block elif_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
+        Token * _keyword;
+        Token * _literal;
+        expr_ty a;
+        asdl_seq* b;
+        stmt_ty c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 510))  // token='if'
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (c = elif_stmt_rule(p))  // elif_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
+    }
+    { // 'if' named_expression ':' block else_block?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
+        Token * _keyword;
+        Token * _literal;
+        expr_ty a;
+        asdl_seq* b;
+        void *c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 510))  // token='if'
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (c = else_block_rule(p), !p->error_indicator)  // else_block?
+        )
+        {
+            D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_If ( a , b , c , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s if_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' named_expression ':' block else_block?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// elif_stmt:
+//     | 'elif' named_expression ':' block elif_stmt
+//     | 'elif' named_expression ':' block else_block?
+static stmt_ty
+elif_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'elif' named_expression ':' block elif_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
+        Token * _keyword;
+        Token * _literal;
+        expr_ty a;
+        asdl_seq* b;
+        stmt_ty c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 515))  // token='elif'
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (c = elif_stmt_rule(p))  // elif_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
+    }
+    { // 'elif' named_expression ':' block else_block?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
+        Token * _keyword;
+        Token * _literal;
+        expr_ty a;
+        asdl_seq* b;
+        void *c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 515))  // token='elif'
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (c = else_block_rule(p), !p->error_indicator)  // else_block?
+        )
+        {
+            D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_If ( a , b , c , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s elif_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'elif' named_expression ':' block else_block?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// else_block: 'else' ':' block
+static asdl_seq*
+else_block_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // 'else' ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq* b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 516))  // token='else'
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ else_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'else' ':' block"));
+            _res = b;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s else_block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'else' ':' block"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// while_stmt: 'while' named_expression ':' block else_block?
+static stmt_ty
+while_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'while' named_expression ':' block else_block?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
+        Token * _keyword;
+        Token * _literal;
+        expr_ty a;
+        asdl_seq* b;
+        void *c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 512))  // token='while'
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (c = else_block_rule(p), !p->error_indicator)  // else_block?
+        )
+        {
+            D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_While ( a , b , c , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s while_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'while' named_expression ':' block else_block?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// for_stmt:
+//     | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
+//     | ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
+//     | invalid_for_target
+static stmt_ty
+for_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
+        int _cut_var = 0;
+        Token * _keyword;
+        Token * _keyword_1;
+        Token * _literal;
+        asdl_seq* b;
+        void *el;
+        expr_ty ex;
+        expr_ty t;
+        void *tc;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 517))  // token='for'
+            &&
+            (t = star_targets_rule(p))  // star_targets
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'
+            &&
+            (_cut_var = 1)
+            &&
+            (ex = star_expressions_rule(p))  // star_expressions
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (el = else_block_rule(p), !p->error_indicator)  // else_block?
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    { // ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
+        int _cut_var = 0;
+        Token * _keyword;
+        Token * _keyword_1;
+        Token * _literal;
+        Token * async_var;
+        asdl_seq* b;
+        void *el;
+        expr_ty ex;
+        expr_ty t;
+        void *tc;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+            &&
+            (_keyword = _PyPegen_expect_token(p, 517))  // token='for'
+            &&
+            (t = star_targets_rule(p))  // star_targets
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'
+            &&
+            (_cut_var = 1)
+            &&
+            (ex = star_expressions_rule(p))  // star_expressions
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (el = else_block_rule(p), !p->error_indicator)  // else_block?
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 5 , "Async for loops are" , _Py_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    if (p->call_invalid_rules) { // invalid_for_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
+        void *invalid_for_target_var;
+        if (
+            (invalid_for_target_var = invalid_for_target_rule(p))  // invalid_for_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
+            _res = invalid_for_target_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_for_target"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// with_stmt:
+//     | 'with' '(' ','.with_item+ ','? ')' ':' block
+//     | 'with' ','.with_item+ ':' TYPE_COMMENT? block
+//     | ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block
+//     | ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block
+static stmt_ty
+with_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'with' '(' ','.with_item+ ','? ')' ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        asdl_seq* b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 519))  // token='with'
+            &&
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = _gather_39_rule(p))  // ','.with_item+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_With ( a , b , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s with_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
+    }
+    { // 'with' ','.with_item+ ':' TYPE_COMMENT? block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq * a;
+        asdl_seq* b;
+        void *tc;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 519))  // token='with'
+            &&
+            (a = _gather_41_rule(p))  // ','.with_item+
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        Token * async_var;
+        asdl_seq* b;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+            &&
+            (_keyword = _PyPegen_expect_token(p, 519))  // token='with'
+            &&
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = _gather_43_rule(p))  // ','.with_item+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 5 , "Async with statements are" , _Py_AsyncWith ( a , b , NULL , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq * a;
+        Token * async_var;
+        asdl_seq* b;
+        void *tc;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+            &&
+            (_keyword = _PyPegen_expect_token(p, 519))  // token='with'
+            &&
+            (a = _gather_45_rule(p))  // ','.with_item+
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 5 , "Async with statements are" , _Py_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// with_item:
+//     | expression 'as' star_target &(',' | ')' | ':')
+//     | invalid_with_item
+//     | expression
+static withitem_ty
+with_item_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    withitem_ty _res = NULL;
+    int _mark = p->mark;
+    { // expression 'as' star_target &(',' | ')' | ':')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
+        Token * _keyword;
+        expr_ty e;
+        expr_ty t;
+        if (
+            (e = expression_rule(p))  // expression
+            &&
+            (_keyword = _PyPegen_expect_token(p, 520))  // token='as'
+            &&
+            (t = star_target_rule(p))  // star_target
+            &&
+            _PyPegen_lookahead(1, _tmp_47_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
+            _res = _Py_withitem ( e , t , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
+    }
+    if (p->call_invalid_rules) { // invalid_with_item
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item"));
+        void *invalid_with_item_var;
+        if (
+            (invalid_with_item_var = invalid_with_item_rule(p))  // invalid_with_item
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_with_item"));
+            _res = invalid_with_item_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_with_item"));
+    }
+    { // expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
+        expr_ty e;
+        if (
+            (e = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
+            _res = _Py_withitem ( e , NULL , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s with_item[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// try_stmt:
+//     | 'try' ':' block finally_block
+//     | 'try' ':' block except_block+ else_block? finally_block?
+static stmt_ty
+try_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'try' ':' block finally_block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block finally_block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq* b;
+        asdl_seq* f;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 511))  // token='try'
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (f = finally_block_rule(p))  // finally_block
+        )
+        {
+            D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block finally_block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Try ( b , NULL , NULL , f , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block finally_block"));
+    }
+    { // 'try' ':' block except_block+ else_block? finally_block?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq* b;
+        void *el;
+        asdl_seq * ex;
+        void *f;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 511))  // token='try'
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+            &&
+            (ex = _loop1_48_rule(p))  // except_block+
+            &&
+            (el = else_block_rule(p), !p->error_indicator)  // else_block?
+            &&
+            (f = finally_block_rule(p), !p->error_indicator)  // finally_block?
+        )
+        {
+            D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Try ( b , ex , el , f , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s try_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// except_block: 'except' expression ['as' NAME] ':' block | 'except' ':' block
+static excepthandler_ty
+except_block_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    excepthandler_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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'except' expression ['as' NAME] ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq* b;
+        expr_ty e;
+        void *t;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 521))  // token='except'
+            &&
+            (e = expression_rule(p))  // expression
+            &&
+            (t = _tmp_49_rule(p), !p->error_indicator)  // ['as' NAME]
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
+    }
+    { // 'except' ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq* b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 521))  // token='except'
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_ExceptHandler ( NULL , NULL , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s except_block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'except' ':' block"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// finally_block: 'finally' ':' block
+static asdl_seq*
+finally_block_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // 'finally' ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        asdl_seq* a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 522))  // token='finally'
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (a = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ finally_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'finally' ':' block"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s finally_block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'finally' ':' block"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// return_stmt: 'return' star_expressions?
+static stmt_ty
+return_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'return' star_expressions?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
+        Token * _keyword;
+        void *a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 500))  // token='return'
+            &&
+            (a = star_expressions_rule(p), !p->error_indicator)  // star_expressions?
+        )
+        {
+            D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Return ( a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s return_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'return' star_expressions?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// raise_stmt: 'raise' expression ['from' expression] | 'raise'
+static stmt_ty
+raise_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'raise' expression ['from' expression]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
+        Token * _keyword;
+        expr_ty a;
+        void *b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 501))  // token='raise'
+            &&
+            (a = expression_rule(p))  // expression
+            &&
+            (b = _tmp_50_rule(p), !p->error_indicator)  // ['from' expression]
+        )
+        {
+            D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Raise ( a , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise' expression ['from' expression]"));
+    }
+    { // 'raise'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 501))  // token='raise'
+        )
+        {
+            D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Raise ( NULL , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s raise_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'raise'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// function_def: decorators function_def_raw | function_def_raw
+static stmt_ty
+function_def_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    stmt_ty _res = NULL;
+    int _mark = p->mark;
+    { // decorators function_def_raw
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
+        asdl_seq* d;
+        stmt_ty f;
+        if (
+            (d = decorators_rule(p))  // decorators
+            &&
+            (f = function_def_raw_rule(p))  // function_def_raw
+        )
+        {
+            D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
+            _res = _PyPegen_function_def_decorators ( p , d , f );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // function_def_raw
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
+        stmt_ty function_def_raw_var;
+        if (
+            (function_def_raw_var = function_def_raw_rule(p))  // function_def_raw
+        )
+        {
+            D(fprintf(stderr, "%*c+ function_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
+            _res = function_def_raw_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s function_def[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "function_def_raw"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// function_def_raw:
+//     | 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block
+//     | ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block
+static stmt_ty
+function_def_raw_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
+        Token * _keyword;
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        void *a;
+        asdl_seq* b;
+        expr_ty n;
+        void *params;
+        void *tc;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 523))  // token='def'
+            &&
+            (n = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (params = params_rule(p), !p->error_indicator)  // params?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+            &&
+            (a = _tmp_51_rule(p), !p->error_indicator)  // ['->' expression]
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (tc = func_type_comment_rule(p), !p->error_indicator)  // func_type_comment?
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s function_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
+    }
+    { // ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
+        Token * _keyword;
+        Token * _literal;
+        Token * _literal_1;
+        Token * _literal_2;
+        void *a;
+        Token * async_var;
+        asdl_seq* b;
+        expr_ty n;
+        void *params;
+        void *tc;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+            &&
+            (_keyword = _PyPegen_expect_token(p, 523))  // token='def'
+            &&
+            (n = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (params = params_rule(p), !p->error_indicator)  // params?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+            &&
+            (a = _tmp_52_rule(p), !p->error_indicator)  // ['->' expression]
+            &&
+            (_literal_2 = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (tc = func_type_comment_rule(p), !p->error_indicator)  // func_type_comment?
+            &&
+            (b = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 5 , "Async functions are" , _Py_AsyncFunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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 '(' params? ')' ['->' expression] ':' func_type_comment? block"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// func_type_comment:
+//     | NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
+//     | invalid_double_type_comments
+//     | TYPE_COMMENT
+static Token*
+func_type_comment_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    Token* _res = NULL;
+    int _mark = p->mark;
+    { // NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
+        Token * newline_var;
+        Token * t;
+        if (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+            &&
+            (t = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'
+            &&
+            _PyPegen_lookahead(1, _tmp_53_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
+            _res = t;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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) { // invalid_double_type_comments
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments"));
+        void *invalid_double_type_comments_var;
+        if (
+            (invalid_double_type_comments_var = invalid_double_type_comments_rule(p))  // invalid_double_type_comments
+        )
+        {
+            D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments"));
+            _res = invalid_double_type_comments_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // TYPE_COMMENT
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
+        Token * type_comment_var;
+        if (
+            (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'
+        )
+        {
+            D(fprintf(stderr, "%*c+ func_type_comment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
+            _res = type_comment_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s func_type_comment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// params: invalid_parameters | parameters
+static arguments_ty
+params_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arguments_ty _res = NULL;
+    int _mark = p->mark;
+    if (p->call_invalid_rules) { // invalid_parameters
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters"));
+        void *invalid_parameters_var;
+        if (
+            (invalid_parameters_var = invalid_parameters_rule(p))  // invalid_parameters
+        )
+        {
+            D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_parameters"));
+            _res = invalid_parameters_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_parameters"));
+    }
+    { // parameters
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters"));
+        arguments_ty parameters_var;
+        if (
+            (parameters_var = parameters_rule(p))  // parameters
+        )
+        {
+            D(fprintf(stderr, "%*c+ params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "parameters"));
+            _res = parameters_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s params[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "parameters"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// parameters:
+//     | slash_no_default param_no_default* param_with_default* star_etc?
+//     | slash_with_default param_with_default* star_etc?
+//     | param_no_default+ param_with_default* star_etc?
+//     | param_with_default+ star_etc?
+//     | star_etc
+static arguments_ty
+parameters_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arguments_ty _res = NULL;
+    int _mark = p->mark;
+    { // slash_no_default param_no_default* param_with_default* star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?"));
+        asdl_seq* a;
+        asdl_seq * b;
+        asdl_seq * c;
+        void *d;
+        if (
+            (a = slash_no_default_rule(p))  // slash_no_default
+            &&
+            (b = _loop0_54_rule(p))  // param_no_default*
+            &&
+            (c = _loop0_55_rule(p))  // param_with_default*
+            &&
+            (d = star_etc_rule(p), !p->error_indicator)  // star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?"));
+            _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // slash_with_default param_with_default* star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
+        SlashWithDefault* a;
+        asdl_seq * b;
+        void *c;
+        if (
+            (a = slash_with_default_rule(p))  // slash_with_default
+            &&
+            (b = _loop0_56_rule(p))  // param_with_default*
+            &&
+            (c = star_etc_rule(p), !p->error_indicator)  // star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
+            _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // param_no_default+ param_with_default* star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
+        asdl_seq * a;
+        asdl_seq * b;
+        void *c;
+        if (
+            (a = _loop1_57_rule(p))  // param_no_default+
+            &&
+            (b = _loop0_58_rule(p))  // param_with_default*
+            &&
+            (c = star_etc_rule(p), !p->error_indicator)  // star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
+            _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // param_with_default+ star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
+        asdl_seq * a;
+        void *b;
+        if (
+            (a = _loop1_59_rule(p))  // param_with_default+
+            &&
+            (b = star_etc_rule(p), !p->error_indicator)  // star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
+            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // star_etc
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc"));
+        StarEtc* a;
+        if (
+            (a = star_etc_rule(p))  // star_etc
+        )
+        {
+            D(fprintf(stderr, "%*c+ parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_etc"));
+            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s parameters[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_etc"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')'
+static asdl_seq*
+slash_no_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // param_no_default+ '/' ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * a;
+        if (
+            (a = _loop1_60_rule(p))  // param_no_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' ','"));
+    }
+    { // param_no_default+ '/' &')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'"));
+        Token * _literal;
+        asdl_seq * a;
+        if (
+            (a = _loop1_61_rule(p))  // param_no_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default+ '/' &')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// slash_with_default:
+//     | param_no_default* param_with_default+ '/' ','
+//     | param_no_default* param_with_default+ '/' &')'
+static SlashWithDefault*
+slash_with_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    SlashWithDefault* _res = NULL;
+    int _mark = p->mark;
+    { // param_no_default* param_with_default+ '/' ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * a;
+        asdl_seq * b;
+        if (
+            (a = _loop0_62_rule(p))  // param_no_default*
+            &&
+            (b = _loop1_63_rule(p))  // param_with_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
+            _res = _PyPegen_slash_with_default ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
+    }
+    { // param_no_default* param_with_default+ '/' &')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
+        Token * _literal;
+        asdl_seq * a;
+        asdl_seq * b;
+        if (
+            (a = _loop0_64_rule(p))  // param_no_default*
+            &&
+            (b = _loop1_65_rule(p))  // param_with_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
+            _res = _PyPegen_slash_with_default ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_etc:
+//     | '*' param_no_default param_maybe_default* kwds?
+//     | '*' ',' param_maybe_default+ kwds?
+//     | kwds
+//     | invalid_star_etc
+static StarEtc*
+star_etc_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    StarEtc* _res = NULL;
+    int _mark = p->mark;
+    { // '*' param_no_default param_maybe_default* kwds?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
+        Token * _literal;
+        arg_ty a;
+        asdl_seq * b;
+        void *c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = param_no_default_rule(p))  // param_no_default
+            &&
+            (b = _loop0_66_rule(p))  // param_maybe_default*
+            &&
+            (c = kwds_rule(p), !p->error_indicator)  // kwds?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
+            _res = _PyPegen_star_etc ( p , a , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // '*' ',' param_maybe_default+ kwds?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * b;
+        void *c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (b = _loop1_67_rule(p))  // param_maybe_default+
+            &&
+            (c = kwds_rule(p), !p->error_indicator)  // kwds?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
+            _res = _PyPegen_star_etc ( p , NULL , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // kwds
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds"));
+        arg_ty a;
+        if (
+            (a = kwds_rule(p))  // kwds
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwds"));
+            _res = _PyPegen_star_etc ( p , NULL , NULL , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwds"));
+    }
+    if (p->call_invalid_rules) { // invalid_star_etc
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc"));
+        void *invalid_star_etc_var;
+        if (
+            (invalid_star_etc_var = invalid_star_etc_rule(p))  // invalid_star_etc
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_star_etc"));
+            _res = invalid_star_etc_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_etc[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_star_etc"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// kwds: '**' param_no_default
+static arg_ty
+kwds_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arg_ty _res = NULL;
+    int _mark = p->mark;
+    { // '**' param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
+        Token * _literal;
+        arg_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (a = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s kwds[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' param_no_default"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')'
+static arg_ty
+param_no_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arg_ty _res = NULL;
+    int _mark = p->mark;
+    { // param ',' TYPE_COMMENT?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
+        Token * _literal;
+        arg_ty a;
+        void *tc;
+        if (
+            (a = param_rule(p))  // param
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+        )
+        {
+            D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
+            _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param ',' TYPE_COMMENT?"));
+    }
+    { // param TYPE_COMMENT? &')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
+        arg_ty a;
+        void *tc;
+        if (
+            (a = param_rule(p))  // param
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
+            _res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param TYPE_COMMENT? &')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')'
+static NameDefaultPair*
+param_with_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    NameDefaultPair* _res = NULL;
+    int _mark = p->mark;
+    { // param default ',' TYPE_COMMENT?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?"));
+        Token * _literal;
+        arg_ty a;
+        expr_ty c;
+        void *tc;
+        if (
+            (a = param_rule(p))  // param
+            &&
+            (c = default_rule(p))  // default
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+        )
+        {
+            D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?"));
+            _res = _PyPegen_name_default_pair ( p , a , c , tc );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default ',' TYPE_COMMENT?"));
+    }
+    { // param default TYPE_COMMENT? &')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'"));
+        arg_ty a;
+        expr_ty c;
+        void *tc;
+        if (
+            (a = param_rule(p))  // param
+            &&
+            (c = default_rule(p))  // default
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'"));
+            _res = _PyPegen_name_default_pair ( p , a , c , tc );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default TYPE_COMMENT? &')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// param_maybe_default:
+//     | param default? ',' TYPE_COMMENT?
+//     | param default? TYPE_COMMENT? &')'
+static NameDefaultPair*
+param_maybe_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    NameDefaultPair* _res = NULL;
+    int _mark = p->mark;
+    { // param default? ',' TYPE_COMMENT?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
+        Token * _literal;
+        arg_ty a;
+        void *c;
+        void *tc;
+        if (
+            (a = param_rule(p))  // param
+            &&
+            (c = default_rule(p), !p->error_indicator)  // default?
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+        )
+        {
+            D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
+            _res = _PyPegen_name_default_pair ( p , a , c , tc );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
+    }
+    { // param default? TYPE_COMMENT? &')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
+        arg_ty a;
+        void *c;
+        void *tc;
+        if (
+            (a = param_rule(p))  // param
+            &&
+            (c = default_rule(p), !p->error_indicator)  // default?
+            &&
+            (tc = _PyPegen_expect_token(p, TYPE_COMMENT), !p->error_indicator)  // TYPE_COMMENT?
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
+            _res = _PyPegen_name_default_pair ( p , a , c , tc );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// param: NAME annotation?
+static arg_ty
+param_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arg_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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME annotation?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
+        expr_ty a;
+        void *b;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (b = annotation_rule(p), !p->error_indicator)  // annotation?
+        )
+        {
+            D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_arg ( a -> v . Name . id , b , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s param[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME annotation?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// annotation: ':' expression
+static expr_ty
+annotation_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // ':' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ annotation[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s annotation[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// default: '=' expression
+static expr_ty
+default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // '=' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' expression"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// decorators: (('@' named_expression NEWLINE))+
+static asdl_seq*
+decorators_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // (('@' named_expression NEWLINE))+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
+        asdl_seq * a;
+        if (
+            (a = _loop1_68_rule(p))  // (('@' named_expression NEWLINE))+
+        )
+        {
+            D(fprintf(stderr, "%*c+ decorators[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s decorators[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(('@' named_expression NEWLINE))+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// class_def: decorators class_def_raw | class_def_raw
+static stmt_ty
+class_def_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    stmt_ty _res = NULL;
+    int _mark = p->mark;
+    { // decorators class_def_raw
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
+        asdl_seq* a;
+        stmt_ty b;
+        if (
+            (a = decorators_rule(p))  // decorators
+            &&
+            (b = class_def_raw_rule(p))  // class_def_raw
+        )
+        {
+            D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
+            _res = _PyPegen_class_def_decorators ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // class_def_raw
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
+        stmt_ty class_def_raw_var;
+        if (
+            (class_def_raw_var = class_def_raw_rule(p))  // class_def_raw
+        )
+        {
+            D(fprintf(stderr, "%*c+ class_def[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
+            _res = class_def_raw_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s class_def[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "class_def_raw"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// class_def_raw: 'class' NAME ['(' arguments? ')'] ':' block
+static stmt_ty
+class_def_raw_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'class' NAME ['(' arguments? ')'] ':' block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"));
+        Token * _keyword;
+        Token * _literal;
+        expr_ty a;
+        void *b;
+        asdl_seq* c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 524))  // token='class'
+            &&
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (b = _tmp_69_rule(p), !p->error_indicator)  // ['(' arguments? ')']
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (c = block_rule(p))  // block
+        )
+        {
+            D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s class_def_raw[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// block: NEWLINE INDENT statements DEDENT | simple_stmt | invalid_block
+static asdl_seq*
+block_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    if (_PyPegen_is_memoized(p, block_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    { // NEWLINE INDENT statements DEDENT
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
+        asdl_seq* a;
+        Token * dedent_var;
+        Token * indent_var;
+        Token * newline_var;
+        if (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+            &&
+            (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'
+            &&
+            (a = statements_rule(p))  // statements
+            &&
+            (dedent_var = _PyPegen_expect_token(p, DEDENT))  // token='DEDENT'
+        )
+        {
+            D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
+    }
+    { // simple_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
+        asdl_seq* simple_stmt_var;
+        if (
+            (simple_stmt_var = simple_stmt_rule(p))  // simple_stmt
+        )
+        {
+            D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
+            _res = simple_stmt_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "simple_stmt"));
+    }
+    if (p->call_invalid_rules) { // invalid_block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block"));
+        void *invalid_block_var;
+        if (
+            (invalid_block_var = invalid_block_rule(p))  // invalid_block
+        )
+        {
+            D(fprintf(stderr, "%*c+ block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_block"));
+            _res = invalid_block_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_block"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, block_type, _res);
+    p->level--;
+    return _res;
+}
+
+// star_expressions:
+//     | star_expression ((',' star_expression))+ ','?
+//     | star_expression ','
+//     | star_expression
+static expr_ty
+star_expressions_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // star_expression ((',' star_expression))+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = star_expression_rule(p))  // star_expression
+            &&
+            (b = _loop1_70_rule(p))  // ((',' star_expression))+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
+    }
+    { // star_expression ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (a = star_expression_rule(p))  // star_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression ','"));
+    }
+    { // star_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression"));
+        expr_ty star_expression_var;
+        if (
+            (star_expression_var = star_expression_rule(p))  // star_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression"));
+            _res = star_expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_expression: '*' bitwise_or | expression
+static expr_ty
+star_expression_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, star_expression_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '*' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Starred ( a , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));
+    }
+    { // expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
+            _res = expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, star_expression_type, _res);
+    p->level--;
+    return _res;
+}
+
+// star_named_expressions: ','.star_named_expression+ ','?
+static asdl_seq*
+star_named_expressions_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.star_named_expression+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        if (
+            (a = _gather_71_rule(p))  // ','.star_named_expression+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_named_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_named_expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_named_expression+ ','?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_named_expression: '*' bitwise_or | named_expression
+static expr_ty
+star_named_expression_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '*' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Starred ( a , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' bitwise_or"));
+    }
+    { // named_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
+        expr_ty named_expression_var;
+        if (
+            (named_expression_var = named_expression_rule(p))  // named_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
+            _res = named_expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// named_expression: NAME ':=' ~ expression | expression !':=' | invalid_named_expression
+static expr_ty
+named_expression_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME ':=' ~ expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
+        int _cut_var = 0;
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 53))  // token=':='
+            &&
+            (_cut_var = 1)
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_NamedExpr ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    { // expression !':='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))  // expression
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 53)  // token=':='
+        )
+        {
+            D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression !':='"));
+            _res = expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression !':='"));
+    }
+    if (p->call_invalid_rules) { // invalid_named_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_named_expression"));
+        void *invalid_named_expression_var;
+        if (
+            (invalid_named_expression_var = invalid_named_expression_rule(p))  // invalid_named_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_named_expression"));
+            _res = invalid_named_expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_named_expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// annotated_rhs: yield_expr | star_expressions
+static expr_ty
+annotated_rhs_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // yield_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))  // yield_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+            _res = yield_expr_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
+    }
+    { // star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ annotated_rhs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+            _res = star_expressions_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s annotated_rhs[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// expressions: expression ((',' expression))+ ','? | expression ',' | expression
+static expr_ty
+expressions_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // expression ((',' expression))+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = expression_rule(p))  // expression
+            &&
+            (b = _loop1_73_rule(p))  // ((',' expression))+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ((',' expression))+ ','?"));
+    }
+    { // expression ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (a = expression_rule(p))  // expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ','"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ','"));
+    }
+    { // expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
+            _res = expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s expressions[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// expression: disjunction 'if' disjunction 'else' expression | disjunction | lambdef
+static expr_ty
+expression_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, expression_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // disjunction 'if' disjunction 'else' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
+        Token * _keyword;
+        Token * _keyword_1;
+        expr_ty a;
+        expr_ty b;
+        expr_ty c;
+        if (
+            (a = disjunction_rule(p))  // disjunction
+            &&
+            (_keyword = _PyPegen_expect_token(p, 510))  // token='if'
+            &&
+            (b = disjunction_rule(p))  // disjunction
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 516))  // token='else'
+            &&
+            (c = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_IfExp ( b , a , c , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
+    }
+    { // disjunction
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction"));
+        expr_ty disjunction_var;
+        if (
+            (disjunction_var = disjunction_rule(p))  // disjunction
+        )
+        {
+            D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction"));
+            _res = disjunction_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "disjunction"));
+    }
+    { // lambdef
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef"));
+        expr_ty lambdef_var;
+        if (
+            (lambdef_var = lambdef_rule(p))  // lambdef
+        )
+        {
+            D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambdef"));
+            _res = lambdef_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambdef"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, expression_type, _res);
+    p->level--;
+    return _res;
+}
+
+// lambdef: 'lambda' lambda_params? ':' expression
+static expr_ty
+lambdef_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'lambda' lambda_params? ':' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
+        Token * _keyword;
+        Token * _literal;
+        void *a;
+        expr_ty b;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 525))  // token='lambda'
+            &&
+            (a = lambda_params_rule(p), !p->error_indicator)  // lambda_params?
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Lambda ( ( a ) ? a : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambdef[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'lambda' lambda_params? ':' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_params: invalid_lambda_parameters | lambda_parameters
+static arguments_ty
+lambda_params_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arguments_ty _res = NULL;
+    int _mark = p->mark;
+    if (p->call_invalid_rules) { // invalid_lambda_parameters
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters"));
+        void *invalid_lambda_parameters_var;
+        if (
+            (invalid_lambda_parameters_var = invalid_lambda_parameters_rule(p))  // invalid_lambda_parameters
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters"));
+            _res = invalid_lambda_parameters_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_lambda_parameters"));
+    }
+    { // lambda_parameters
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
+        arguments_ty lambda_parameters_var;
+        if (
+            (lambda_parameters_var = lambda_parameters_rule(p))  // lambda_parameters
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
+            _res = lambda_parameters_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_params[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_parameters"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_parameters:
+//     | lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
+//     | lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
+//     | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
+//     | lambda_param_with_default+ lambda_star_etc?
+//     | lambda_star_etc
+static arguments_ty
+lambda_parameters_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arguments_ty _res = NULL;
+    int _mark = p->mark;
+    { // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?"));
+        asdl_seq* a;
+        asdl_seq * b;
+        asdl_seq * c;
+        void *d;
+        if (
+            (a = lambda_slash_no_default_rule(p))  // lambda_slash_no_default
+            &&
+            (b = _loop0_74_rule(p))  // lambda_param_no_default*
+            &&
+            (c = _loop0_75_rule(p))  // lambda_param_with_default*
+            &&
+            (d = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?"));
+            _res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?"));
+        SlashWithDefault* a;
+        asdl_seq * b;
+        void *c;
+        if (
+            (a = lambda_slash_with_default_rule(p))  // lambda_slash_with_default
+            &&
+            (b = _loop0_76_rule(p))  // lambda_param_with_default*
+            &&
+            (c = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?"));
+            _res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?"));
+        asdl_seq * a;
+        asdl_seq * b;
+        void *c;
+        if (
+            (a = _loop1_77_rule(p))  // lambda_param_no_default+
+            &&
+            (b = _loop0_78_rule(p))  // lambda_param_with_default*
+            &&
+            (c = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?"));
+            _res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // lambda_param_with_default+ lambda_star_etc?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
+        asdl_seq * a;
+        void *b;
+        if (
+            (a = _loop1_79_rule(p))  // lambda_param_with_default+
+            &&
+            (b = lambda_star_etc_rule(p), !p->error_indicator)  // lambda_star_etc?
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
+            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // lambda_star_etc
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
+        StarEtc* a;
+        if (
+            (a = lambda_star_etc_rule(p))  // lambda_star_etc
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
+            _res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_parameters[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_star_etc"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_slash_no_default:
+//     | lambda_param_no_default+ '/' ','
+//     | lambda_param_no_default+ '/' &':'
+static asdl_seq*
+lambda_slash_no_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // lambda_param_no_default+ '/' ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * a;
+        if (
+            (a = _loop1_80_rule(p))  // lambda_param_no_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' ','"));
+    }
+    { // lambda_param_no_default+ '/' &':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
+        Token * _literal;
+        asdl_seq * a;
+        if (
+            (a = _loop1_81_rule(p))  // lambda_param_no_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_slash_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_slash_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_slash_with_default:
+//     | lambda_param_no_default* lambda_param_with_default+ '/' ','
+//     | lambda_param_no_default* lambda_param_with_default+ '/' &':'
+static SlashWithDefault*
+lambda_slash_with_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    SlashWithDefault* _res = NULL;
+    int _mark = p->mark;
+    { // lambda_param_no_default* lambda_param_with_default+ '/' ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * a;
+        asdl_seq * b;
+        if (
+            (a = _loop0_82_rule(p))  // lambda_param_no_default*
+            &&
+            (b = _loop1_83_rule(p))  // lambda_param_with_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','"));
+            _res = _PyPegen_slash_with_default ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','"));
+    }
+    { // lambda_param_no_default* lambda_param_with_default+ '/' &':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'"));
+        Token * _literal;
+        asdl_seq * a;
+        asdl_seq * b;
+        if (
+            (a = _loop0_84_rule(p))  // lambda_param_no_default*
+            &&
+            (b = _loop1_85_rule(p))  // lambda_param_with_default+
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_slash_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'"));
+            _res = _PyPegen_slash_with_default ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_slash_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_star_etc:
+//     | '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
+//     | '*' ',' lambda_param_maybe_default+ lambda_kwds?
+//     | lambda_kwds
+//     | invalid_lambda_star_etc
+static StarEtc*
+lambda_star_etc_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    StarEtc* _res = NULL;
+    int _mark = p->mark;
+    { // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?"));
+        Token * _literal;
+        arg_ty a;
+        asdl_seq * b;
+        void *c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = lambda_param_no_default_rule(p))  // lambda_param_no_default
+            &&
+            (b = _loop0_86_rule(p))  // lambda_param_maybe_default*
+            &&
+            (c = lambda_kwds_rule(p), !p->error_indicator)  // lambda_kwds?
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?"));
+            _res = _PyPegen_star_etc ( p , a , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // '*' ',' lambda_param_maybe_default+ lambda_kwds?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * b;
+        void *c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (b = _loop1_87_rule(p))  // lambda_param_maybe_default+
+            &&
+            (c = lambda_kwds_rule(p), !p->error_indicator)  // lambda_kwds?
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
+            _res = _PyPegen_star_etc ( p , NULL , b , c );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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?"));
+    }
+    { // lambda_kwds
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
+        arg_ty a;
+        if (
+            (a = lambda_kwds_rule(p))  // lambda_kwds
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
+            _res = _PyPegen_star_etc ( p , NULL , NULL , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_kwds"));
+    }
+    if (p->call_invalid_rules) { // invalid_lambda_star_etc
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc"));
+        void *invalid_lambda_star_etc_var;
+        if (
+            (invalid_lambda_star_etc_var = invalid_lambda_star_etc_rule(p))  // invalid_lambda_star_etc
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc"));
+            _res = invalid_lambda_star_etc_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_kwds: '**' lambda_param_no_default
+static arg_ty
+lambda_kwds_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arg_ty _res = NULL;
+    int _mark = p->mark;
+    { // '**' lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default"));
+        Token * _literal;
+        arg_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (a = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_kwds[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_kwds[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' lambda_param_no_default"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_param_no_default: lambda_param ',' | lambda_param &':'
+static arg_ty
+lambda_param_no_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arg_ty _res = NULL;
+    int _mark = p->mark;
+    { // lambda_param ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
+        Token * _literal;
+        arg_ty a;
+        if (
+            (a = lambda_param_rule(p))  // lambda_param
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param ','"));
+    }
+    { // lambda_param &':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
+        arg_ty a;
+        if (
+            (a = lambda_param_rule(p))  // lambda_param
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param_no_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param_no_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param &':'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_param_with_default: lambda_param default ',' | lambda_param default &':'
+static NameDefaultPair*
+lambda_param_with_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    NameDefaultPair* _res = NULL;
+    int _mark = p->mark;
+    { // lambda_param default ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default ','"));
+        Token * _literal;
+        arg_ty a;
+        expr_ty c;
+        if (
+            (a = lambda_param_rule(p))  // lambda_param
+            &&
+            (c = default_rule(p))  // default
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default ','"));
+            _res = _PyPegen_name_default_pair ( p , a , c , NULL );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default ','"));
+    }
+    { // lambda_param default &':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'"));
+        arg_ty a;
+        expr_ty c;
+        if (
+            (a = lambda_param_rule(p))  // lambda_param
+            &&
+            (c = default_rule(p))  // default
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param_with_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'"));
+            _res = _PyPegen_name_default_pair ( p , a , c , NULL );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param_with_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default &':'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':'
+static NameDefaultPair*
+lambda_param_maybe_default_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    NameDefaultPair* _res = NULL;
+    int _mark = p->mark;
+    { // lambda_param default? ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','"));
+        Token * _literal;
+        arg_ty a;
+        void *c;
+        if (
+            (a = lambda_param_rule(p))  // lambda_param
+            &&
+            (c = default_rule(p), !p->error_indicator)  // default?
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','"));
+            _res = _PyPegen_name_default_pair ( p , a , c , NULL );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? ','"));
+    }
+    { // lambda_param default? &':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'"));
+        arg_ty a;
+        void *c;
+        if (
+            (a = lambda_param_rule(p))  // lambda_param
+            &&
+            (c = default_rule(p), !p->error_indicator)  // default?
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 11)  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param_maybe_default[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'"));
+            _res = _PyPegen_name_default_pair ( p , a , c , NULL );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param_maybe_default[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param default? &':'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lambda_param: NAME
+static arg_ty
+lambda_param_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    arg_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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lambda_param[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// disjunction: conjunction (('or' conjunction))+ | conjunction
+static expr_ty
+disjunction_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, disjunction_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // conjunction (('or' conjunction))+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = conjunction_rule(p))  // conjunction
+            &&
+            (b = _loop1_88_rule(p))  // (('or' conjunction))+
+        )
+        {
+            D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BoolOp ( Or , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction (('or' conjunction))+"));
+    }
+    { // conjunction
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction"));
+        expr_ty conjunction_var;
+        if (
+            (conjunction_var = conjunction_rule(p))  // conjunction
+        )
+        {
+            D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction"));
+            _res = conjunction_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s disjunction[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "conjunction"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, disjunction_type, _res);
+    p->level--;
+    return _res;
+}
+
+// conjunction: inversion (('and' inversion))+ | inversion
+static expr_ty
+conjunction_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, conjunction_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // inversion (('and' inversion))+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = inversion_rule(p))  // inversion
+            &&
+            (b = _loop1_89_rule(p))  // (('and' inversion))+
+        )
+        {
+            D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BoolOp ( And , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion (('and' inversion))+"));
+    }
+    { // inversion
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion"));
+        expr_ty inversion_var;
+        if (
+            (inversion_var = inversion_rule(p))  // inversion
+        )
+        {
+            D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion"));
+            _res = inversion_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s conjunction[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "inversion"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, conjunction_type, _res);
+    p->level--;
+    return _res;
+}
+
+// inversion: 'not' inversion | comparison
+static expr_ty
+inversion_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, inversion_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'not' inversion
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
+        Token * _keyword;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 526))  // token='not'
+            &&
+            (a = inversion_rule(p))  // inversion
+        )
+        {
+            D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_UnaryOp ( Not , a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' inversion"));
+    }
+    { // comparison
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison"));
+        expr_ty comparison_var;
+        if (
+            (comparison_var = comparison_rule(p))  // comparison
+        )
+        {
+            D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "comparison"));
+            _res = comparison_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s inversion[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "comparison"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, inversion_type, _res);
+    p->level--;
+    return _res;
+}
+
+// comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
+static expr_ty
+comparison_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // bitwise_or compare_op_bitwise_or_pair+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = bitwise_or_rule(p))  // bitwise_or
+            &&
+            (b = _loop1_90_rule(p))  // compare_op_bitwise_or_pair+
+        )
+        {
+            D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Compare ( a , CHECK ( _PyPegen_get_cmpops ( p , b ) ) , CHECK ( _PyPegen_get_exprs ( p , b ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
+    }
+    { // bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
+        expr_ty bitwise_or_var;
+        if (
+            (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
+            _res = bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s comparison[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// compare_op_bitwise_or_pair:
+//     | eq_bitwise_or
+//     | noteq_bitwise_or
+//     | lte_bitwise_or
+//     | lt_bitwise_or
+//     | gte_bitwise_or
+//     | gt_bitwise_or
+//     | notin_bitwise_or
+//     | in_bitwise_or
+//     | isnot_bitwise_or
+//     | is_bitwise_or
+static CmpopExprPair*
+compare_op_bitwise_or_pair_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // eq_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or"));
+        CmpopExprPair* eq_bitwise_or_var;
+        if (
+            (eq_bitwise_or_var = eq_bitwise_or_rule(p))  // eq_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or"));
+            _res = eq_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "eq_bitwise_or"));
+    }
+    { // noteq_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or"));
+        CmpopExprPair* noteq_bitwise_or_var;
+        if (
+            (noteq_bitwise_or_var = noteq_bitwise_or_rule(p))  // noteq_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or"));
+            _res = noteq_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "noteq_bitwise_or"));
+    }
+    { // lte_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or"));
+        CmpopExprPair* lte_bitwise_or_var;
+        if (
+            (lte_bitwise_or_var = lte_bitwise_or_rule(p))  // lte_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or"));
+            _res = lte_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lte_bitwise_or"));
+    }
+    { // lt_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or"));
+        CmpopExprPair* lt_bitwise_or_var;
+        if (
+            (lt_bitwise_or_var = lt_bitwise_or_rule(p))  // lt_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or"));
+            _res = lt_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lt_bitwise_or"));
+    }
+    { // gte_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or"));
+        CmpopExprPair* gte_bitwise_or_var;
+        if (
+            (gte_bitwise_or_var = gte_bitwise_or_rule(p))  // gte_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or"));
+            _res = gte_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gte_bitwise_or"));
+    }
+    { // gt_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or"));
+        CmpopExprPair* gt_bitwise_or_var;
+        if (
+            (gt_bitwise_or_var = gt_bitwise_or_rule(p))  // gt_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or"));
+            _res = gt_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "gt_bitwise_or"));
+    }
+    { // notin_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or"));
+        CmpopExprPair* notin_bitwise_or_var;
+        if (
+            (notin_bitwise_or_var = notin_bitwise_or_rule(p))  // notin_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or"));
+            _res = notin_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "notin_bitwise_or"));
+    }
+    { // in_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "in_bitwise_or"));
+        CmpopExprPair* in_bitwise_or_var;
+        if (
+            (in_bitwise_or_var = in_bitwise_or_rule(p))  // in_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "in_bitwise_or"));
+            _res = in_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // isnot_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or"));
+        CmpopExprPair* isnot_bitwise_or_var;
+        if (
+            (isnot_bitwise_or_var = isnot_bitwise_or_rule(p))  // isnot_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or"));
+            _res = isnot_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s compare_op_bitwise_or_pair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "isnot_bitwise_or"));
+    }
+    { // is_bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "is_bitwise_or"));
+        CmpopExprPair* is_bitwise_or_var;
+        if (
+            (is_bitwise_or_var = is_bitwise_or_rule(p))  // is_bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ compare_op_bitwise_or_pair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "is_bitwise_or"));
+            _res = is_bitwise_or_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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_bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// eq_bitwise_or: '==' bitwise_or
+static CmpopExprPair*
+eq_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // '==' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 27))  // token='=='
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ eq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s eq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'==' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// noteq_bitwise_or: ('!=') bitwise_or
+static CmpopExprPair*
+noteq_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // ('!=') bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
+        void *_tmp_91_var;
+        expr_ty a;
+        if (
+            (_tmp_91_var = _tmp_91_rule(p))  // '!='
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ noteq_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s noteq_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('!=') bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lte_bitwise_or: '<=' bitwise_or
+static CmpopExprPair*
+lte_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // '<=' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 29))  // token='<='
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ lte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<=' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// lt_bitwise_or: '<' bitwise_or
+static CmpopExprPair*
+lt_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // '<' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 20))  // token='<'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ lt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s lt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'<' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// gte_bitwise_or: '>=' bitwise_or
+static CmpopExprPair*
+gte_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // '>=' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 30))  // token='>='
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ gte_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s gte_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>=' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// gt_bitwise_or: '>' bitwise_or
+static CmpopExprPair*
+gt_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // '>' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 21))  // token='>'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ gt_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s gt_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'>' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// notin_bitwise_or: 'not' 'in' bitwise_or
+static CmpopExprPair*
+notin_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // 'not' 'in' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or"));
+        Token * _keyword;
+        Token * _keyword_1;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 526))  // token='not'
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ notin_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s notin_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'not' 'in' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// in_bitwise_or: 'in' bitwise_or
+static CmpopExprPair*
+in_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // 'in' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
+        Token * _keyword;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 518))  // token='in'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ in_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , In , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s in_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'in' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// isnot_bitwise_or: 'is' 'not' bitwise_or
+static CmpopExprPair*
+isnot_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // 'is' 'not' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or"));
+        Token * _keyword;
+        Token * _keyword_1;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 527))  // token='is'
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 526))  // token='not'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ isnot_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s isnot_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' 'not' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// is_bitwise_or: 'is' bitwise_or
+static CmpopExprPair*
+is_bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    CmpopExprPair* _res = NULL;
+    int _mark = p->mark;
+    { // 'is' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
+        Token * _keyword;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 527))  // token='is'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ is_bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
+            _res = _PyPegen_cmpop_expr_pair ( p , Is , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s is_bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'is' bitwise_or"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor
+static expr_ty bitwise_or_raw(Parser *);
+static expr_ty
+bitwise_or_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_1 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res);
+        if (tmpvar_1) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = bitwise_or_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+bitwise_or_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // bitwise_or '|' bitwise_xor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = bitwise_or_rule(p))  // bitwise_or
+            &&
+            (_literal = _PyPegen_expect_token(p, 18))  // token='|'
+            &&
+            (b = bitwise_xor_rule(p))  // bitwise_xor
+        )
+        {
+            D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , BitOr , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_or '|' bitwise_xor"));
+    }
+    { // bitwise_xor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
+        expr_ty bitwise_xor_var;
+        if (
+            (bitwise_xor_var = bitwise_xor_rule(p))  // bitwise_xor
+        )
+        {
+            D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
+            _res = bitwise_xor_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s bitwise_or[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and
+static expr_ty bitwise_xor_raw(Parser *);
+static expr_ty
+bitwise_xor_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res);
+        if (tmpvar_2) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = bitwise_xor_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+bitwise_xor_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // bitwise_xor '^' bitwise_and
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = bitwise_xor_rule(p))  // bitwise_xor
+            &&
+            (_literal = _PyPegen_expect_token(p, 32))  // token='^'
+            &&
+            (b = bitwise_and_rule(p))  // bitwise_and
+        )
+        {
+            D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , BitXor , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_xor '^' bitwise_and"));
+    }
+    { // bitwise_and
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
+        expr_ty bitwise_and_var;
+        if (
+            (bitwise_and_var = bitwise_and_rule(p))  // bitwise_and
+        )
+        {
+            D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
+            _res = bitwise_and_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s bitwise_xor[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// bitwise_and: bitwise_and '&' shift_expr | shift_expr
+static expr_ty bitwise_and_raw(Parser *);
+static expr_ty
+bitwise_and_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res);
+        if (tmpvar_3) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = bitwise_and_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+bitwise_and_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // bitwise_and '&' shift_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = bitwise_and_rule(p))  // bitwise_and
+            &&
+            (_literal = _PyPegen_expect_token(p, 19))  // token='&'
+            &&
+            (b = shift_expr_rule(p))  // shift_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , BitAnd , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "bitwise_and '&' shift_expr"));
+    }
+    { // shift_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr"));
+        expr_ty shift_expr_var;
+        if (
+            (shift_expr_var = shift_expr_rule(p))  // shift_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr"));
+            _res = shift_expr_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s bitwise_and[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | sum
+static expr_ty shift_expr_raw(Parser *);
+static expr_ty
+shift_expr_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_4 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res);
+        if (tmpvar_4) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = shift_expr_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+shift_expr_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // shift_expr '<<' sum
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = shift_expr_rule(p))  // shift_expr
+            &&
+            (_literal = _PyPegen_expect_token(p, 33))  // token='<<'
+            &&
+            (b = sum_rule(p))  // sum
+        )
+        {
+            D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , LShift , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '<<' sum"));
+    }
+    { // shift_expr '>>' sum
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = shift_expr_rule(p))  // shift_expr
+            &&
+            (_literal = _PyPegen_expect_token(p, 34))  // token='>>'
+            &&
+            (b = sum_rule(p))  // sum
+        )
+        {
+            D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , RShift , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "shift_expr '>>' sum"));
+    }
+    { // sum
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum"));
+        expr_ty sum_var;
+        if (
+            (sum_var = sum_rule(p))  // sum
+        )
+        {
+            D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum"));
+            _res = sum_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s shift_expr[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// sum: sum '+' term | sum '-' term | term
+static expr_ty sum_raw(Parser *);
+static expr_ty
+sum_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, sum_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_5 = _PyPegen_update_memo(p, _mark, sum_type, _res);
+        if (tmpvar_5) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = sum_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+sum_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // sum '+' term
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = sum_rule(p))  // sum
+            &&
+            (_literal = _PyPegen_expect_token(p, 14))  // token='+'
+            &&
+            (b = term_rule(p))  // term
+        )
+        {
+            D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , Add , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '+' term"));
+    }
+    { // sum '-' term
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = sum_rule(p))  // sum
+            &&
+            (_literal = _PyPegen_expect_token(p, 15))  // token='-'
+            &&
+            (b = term_rule(p))  // term
+        )
+        {
+            D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , Sub , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "sum '-' term"));
+    }
+    { // term
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term"));
+        expr_ty term_var;
+        if (
+            (term_var = term_rule(p))  // term
+        )
+        {
+            D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term"));
+            _res = term_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s sum[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// term:
+//     | term '*' factor
+//     | term '/' factor
+//     | term '//' factor
+//     | term '%' factor
+//     | term '@' factor
+//     | factor
+static expr_ty term_raw(Parser *);
+static expr_ty
+term_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, term_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_6 = _PyPegen_update_memo(p, _mark, term_type, _res);
+        if (tmpvar_6) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = term_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+term_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // term '*' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = term_rule(p))  // term
+            &&
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (b = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , Mult , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '*' factor"));
+    }
+    { // term '/' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = term_rule(p))  // term
+            &&
+            (_literal = _PyPegen_expect_token(p, 17))  // token='/'
+            &&
+            (b = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , Div , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '/' factor"));
+    }
+    { // term '//' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = term_rule(p))  // term
+            &&
+            (_literal = _PyPegen_expect_token(p, 47))  // token='//'
+            &&
+            (b = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , FloorDiv , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '//' factor"));
+    }
+    { // term '%' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = term_rule(p))  // term
+            &&
+            (_literal = _PyPegen_expect_token(p, 24))  // token='%'
+            &&
+            (b = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , Mod , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '%' factor"));
+    }
+    { // term '@' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = term_rule(p))  // term
+            &&
+            (_literal = _PyPegen_expect_token(p, 49))  // token='@'
+            &&
+            (b = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 5 , "The '@' operator is" , _Py_BinOp ( a , MatMult , b , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "term '@' factor"));
+    }
+    { // factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor"));
+        expr_ty factor_var;
+        if (
+            (factor_var = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "factor"));
+            _res = factor_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s term[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "factor"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// factor: '+' factor | '-' factor | '~' factor | power
+static expr_ty
+factor_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, factor_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '+' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 14))  // token='+'
+            &&
+            (a = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_UnaryOp ( UAdd , a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'+' factor"));
+    }
+    { // '-' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 15))  // token='-'
+            &&
+            (a = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_UnaryOp ( USub , a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'-' factor"));
+    }
+    { // '~' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 31))  // token='~'
+            &&
+            (a = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_UnaryOp ( Invert , a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'~' factor"));
+    }
+    { // power
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power"));
+        expr_ty power_var;
+        if (
+            (power_var = power_rule(p))  // power
+        )
+        {
+            D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "power"));
+            _res = power_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s factor[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "power"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, factor_type, _res);
+    p->level--;
+    return _res;
+}
+
+// power: await_primary '**' factor | await_primary
+static expr_ty
+power_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // await_primary '**' factor
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = await_primary_rule(p))  // await_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (b = factor_rule(p))  // factor
+        )
+        {
+            D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_BinOp ( a , Pow , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary '**' factor"));
+    }
+    { // await_primary
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary"));
+        expr_ty await_primary_var;
+        if (
+            (await_primary_var = await_primary_rule(p))  // await_primary
+        )
+        {
+            D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary"));
+            _res = await_primary_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s power[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "await_primary"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// await_primary: AWAIT primary | primary
+static expr_ty
+await_primary_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, await_primary_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // AWAIT primary
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AWAIT primary"));
+        expr_ty a;
+        Token * await_var;
+        if (
+            (await_var = _PyPegen_expect_token(p, AWAIT))  // token='AWAIT'
+            &&
+            (a = primary_rule(p))  // primary
+        )
+        {
+            D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AWAIT primary"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = CHECK_VERSION ( 5 , "Await expressions are" , _Py_Await ( a , EXTRA ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "AWAIT primary"));
+    }
+    { // primary
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary"));
+        expr_ty primary_var;
+        if (
+            (primary_var = primary_rule(p))  // primary
+        )
+        {
+            D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary"));
+            _res = primary_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s await_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, await_primary_type, _res);
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// primary:
+//     | invalid_primary
+//     | primary '.' NAME
+//     | primary genexp
+//     | primary '(' arguments? ')'
+//     | primary '[' slices ']'
+//     | atom
+static expr_ty primary_raw(Parser *);
+static expr_ty
+primary_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, primary_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_7 = _PyPegen_update_memo(p, _mark, primary_type, _res);
+        if (tmpvar_7) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = primary_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+primary_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    if (p->call_invalid_rules) { // invalid_primary
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_primary"));
+        void *invalid_primary_var;
+        if (
+            (invalid_primary_var = invalid_primary_rule(p))  // invalid_primary
+        )
+        {
+            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_primary"));
+            _res = invalid_primary_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_primary"));
+    }
+    { // primary '.' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = primary_rule(p))  // primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+            &&
+            (b = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '.' NAME"));
+    }
+    { // primary genexp
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp"));
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = primary_rule(p))  // primary
+            &&
+            (b = genexp_rule(p))  // genexp
+        )
+        {
+            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary genexp"));
+    }
+    { // primary '(' arguments? ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        void *b;
+        if (
+            (a = primary_rule(p))  // primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (b = arguments_rule(p), !p->error_indicator)  // arguments?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '(' arguments? ')'"));
+    }
+    { // primary '[' slices ']'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = primary_rule(p))  // primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (b = slices_rule(p))  // slices
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+        )
+        {
+            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Subscript ( a , b , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '[' slices ']'"));
+    }
+    { // atom
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom"));
+        expr_ty atom_var;
+        if (
+            (atom_var = atom_rule(p))  // atom
+        )
+        {
+            D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom"));
+            _res = atom_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// slices: slice !',' | ','.slice+ ','?
+static expr_ty
+slices_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // slice !','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','"));
+        expr_ty a;
+        if (
+            (a = slice_rule(p))  // slice
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice !','"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice !','"));
+    }
+    { // ','.slice+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        if (
+            (a = _gather_92_rule(p))  // ','.slice+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( a , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slices[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.slice+ ','?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// slice: expression? ':' expression? [':' expression?] | expression
+static expr_ty
+slice_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // expression? ':' expression? [':' expression?]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
+        Token * _literal;
+        void *a;
+        void *b;
+        void *c;
+        if (
+            (a = expression_rule(p), !p->error_indicator)  // expression?
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = expression_rule(p), !p->error_indicator)  // expression?
+            &&
+            (c = _tmp_94_rule(p), !p->error_indicator)  // [':' expression?]
+        )
+        {
+            D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Slice ( a , b , c , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression? ':' expression? [':' expression?]"));
+    }
+    { // expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
+        expr_ty a;
+        if (
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s slice[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// atom:
+//     | NAME
+//     | 'True'
+//     | 'False'
+//     | 'None'
+//     | '__peg_parser__'
+//     | &STRING strings
+//     | NUMBER
+//     | &'(' (tuple | group | genexp)
+//     | &'[' (list | listcomp)
+//     | &'{' (dict | set | dictcomp | setcomp)
+//     | '...'
+static expr_ty
+atom_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
+        expr_ty name_var;
+        if (
+            (name_var = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
+            _res = name_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
+    }
+    { // 'True'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 528))  // token='True'
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Constant ( Py_True , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'True'"));
+    }
+    { // 'False'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 529))  // token='False'
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Constant ( Py_False , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'False'"));
+    }
+    { // 'None'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 530))  // token='None'
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Constant ( Py_None , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'None'"));
+    }
+    { // '__peg_parser__'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'__peg_parser__'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 531))  // token='__peg_parser__'
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'__peg_parser__'"));
+            _res = RAISE_SYNTAX_ERROR ( "You found it!" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'__peg_parser__'"));
+    }
+    { // &STRING strings
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings"));
+        expr_ty strings_var;
+        if (
+            _PyPegen_lookahead(1, _PyPegen_string_token, p)
+            &&
+            (strings_var = strings_rule(p))  // strings
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&STRING strings"));
+            _res = strings_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&STRING strings"));
+    }
+    { // NUMBER
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
+        expr_ty number_var;
+        if (
+            (number_var = _PyPegen_number_token(p))  // NUMBER
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NUMBER"));
+            _res = number_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NUMBER"));
+    }
+    { // &'(' (tuple | group | genexp)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
+        void *_tmp_95_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7)  // token='('
+            &&
+            (_tmp_95_var = _tmp_95_rule(p))  // tuple | group | genexp
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
+            _res = _tmp_95_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'(' (tuple | group | genexp)"));
+    }
+    { // &'[' (list | listcomp)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
+        void *_tmp_96_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9)  // token='['
+            &&
+            (_tmp_96_var = _tmp_96_rule(p))  // list | listcomp
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
+            _res = _tmp_96_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'[' (list | listcomp)"));
+    }
+    { // &'{' (dict | set | dictcomp | setcomp)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
+        void *_tmp_97_var;
+        if (
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25)  // token='{'
+            &&
+            (_tmp_97_var = _tmp_97_rule(p))  // dict | set | dictcomp | setcomp
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
+            _res = _tmp_97_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
+    }
+    { // '...'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 52))  // token='...'
+        )
+        {
+            D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Constant ( Py_Ellipsis , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// strings: STRING+
+static expr_ty
+strings_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, strings_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    { // STRING+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+"));
+        asdl_seq * a;
+        if (
+            (a = _loop1_98_rule(p))  // STRING+
+        )
+        {
+            D(fprintf(stderr, "%*c+ strings[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "STRING+"));
+            _res = _PyPegen_concatenate_strings ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s strings[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING+"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, strings_type, _res);
+    p->level--;
+    return _res;
+}
+
+// list: '[' star_named_expressions? ']'
+static expr_ty
+list_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '[' star_named_expressions? ']'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (a = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+        )
+        {
+            D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_List ( a , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s list[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_named_expressions? ']'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// listcomp: '[' named_expression ~ for_if_clauses ']' | invalid_comprehension
+static expr_ty
+listcomp_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '[' named_expression ~ for_if_clauses ']'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'"));
+        int _cut_var = 0;
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        asdl_seq* b;
+        if (
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_cut_var = 1)
+            &&
+            (b = for_if_clauses_rule(p))  // for_if_clauses
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+        )
+        {
+            D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_ListComp ( a , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    if (p->call_invalid_rules) { // invalid_comprehension
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
+        void *invalid_comprehension_var;
+        if (
+            (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension
+        )
+        {
+            D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
+            _res = invalid_comprehension_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
+static expr_ty
+tuple_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '(' [star_named_expression ',' star_named_expressions?] ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = _tmp_99_rule(p), !p->error_indicator)  // [star_named_expression ',' star_named_expressions?]
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( a , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s tuple[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// group: '(' (yield_expr | named_expression) ')' | invalid_group
+static expr_ty
+group_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // '(' (yield_expr | named_expression) ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = _tmp_100_rule(p))  // yield_expr | named_expression
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
+    }
+    if (p->call_invalid_rules) { // invalid_group
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group"));
+        void *invalid_group_var;
+        if (
+            (invalid_group_var = invalid_group_rule(p))  // invalid_group
+        )
+        {
+            D(fprintf(stderr, "%*c+ group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_group"));
+            _res = invalid_group_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s group[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_group"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// genexp: '(' named_expression ~ for_if_clauses ')' | invalid_comprehension
+static expr_ty
+genexp_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '(' named_expression ~ for_if_clauses ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'"));
+        int _cut_var = 0;
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        asdl_seq* b;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_cut_var = 1)
+            &&
+            (b = for_if_clauses_rule(p))  // for_if_clauses
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_GeneratorExp ( a , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    if (p->call_invalid_rules) { // invalid_comprehension
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
+        void *invalid_comprehension_var;
+        if (
+            (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension
+        )
+        {
+            D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
+            _res = invalid_comprehension_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// set: '{' star_named_expressions '}'
+static expr_ty
+set_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '{' star_named_expressions '}'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq* a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 25))  // token='{'
+            &&
+            (a = star_named_expressions_rule(p))  // star_named_expressions
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'
+        )
+        {
+            D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Set ( a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s set[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' star_named_expressions '}'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// setcomp: '{' named_expression ~ for_if_clauses '}' | invalid_comprehension
+static expr_ty
+setcomp_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '{' named_expression ~ for_if_clauses '}'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'"));
+        int _cut_var = 0;
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        asdl_seq* b;
+        if (
+            (_literal = _PyPegen_expect_token(p, 25))  // token='{'
+            &&
+            (a = named_expression_rule(p))  // named_expression
+            &&
+            (_cut_var = 1)
+            &&
+            (b = for_if_clauses_rule(p))  // for_if_clauses
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'
+        )
+        {
+            D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_SetComp ( a , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    if (p->call_invalid_rules) { // invalid_comprehension
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
+        void *invalid_comprehension_var;
+        if (
+            (invalid_comprehension_var = invalid_comprehension_rule(p))  // invalid_comprehension
+        )
+        {
+            D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
+            _res = invalid_comprehension_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_comprehension"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// dict: '{' double_starred_kvpairs? '}'
+static expr_ty
+dict_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '{' double_starred_kvpairs? '}'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 25))  // token='{'
+            &&
+            (a = double_starred_kvpairs_rule(p), !p->error_indicator)  // double_starred_kvpairs?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'
+        )
+        {
+            D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Dict ( CHECK ( _PyPegen_get_keys ( p , a ) ) , CHECK ( _PyPegen_get_values ( p , a ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dict[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension
+static expr_ty
+dictcomp_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '{' kvpair for_if_clauses '}'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
+        Token * _literal;
+        Token * _literal_1;
+        KeyValuePair* a;
+        asdl_seq* b;
+        if (
+            (_literal = _PyPegen_expect_token(p, 25))  // token='{'
+            &&
+            (a = kvpair_rule(p))  // kvpair
+            &&
+            (b = for_if_clauses_rule(p))  // for_if_clauses
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'
+        )
+        {
+            D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_DictComp ( a -> key , a -> value , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
+    }
+    if (p->call_invalid_rules) { // invalid_dict_comprehension
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension"));
+        void *invalid_dict_comprehension_var;
+        if (
+            (invalid_dict_comprehension_var = invalid_dict_comprehension_rule(p))  // invalid_dict_comprehension
+        )
+        {
+            D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension"));
+            _res = invalid_dict_comprehension_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s dictcomp[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_dict_comprehension"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// double_starred_kvpairs: ','.double_starred_kvpair+ ','?
+static asdl_seq*
+double_starred_kvpairs_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.double_starred_kvpair+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        if (
+            (a = _gather_101_rule(p))  // ','.double_starred_kvpair+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ double_starred_kvpairs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s double_starred_kvpairs[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.double_starred_kvpair+ ','?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// double_starred_kvpair: '**' bitwise_or | kvpair
+static KeyValuePair*
+double_starred_kvpair_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    KeyValuePair* _res = NULL;
+    int _mark = p->mark;
+    { // '**' bitwise_or
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (a = bitwise_or_rule(p))  // bitwise_or
+        )
+        {
+            D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
+            _res = _PyPegen_key_value_pair ( p , NULL , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**' bitwise_or"));
+    }
+    { // kvpair
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpair"));
+        KeyValuePair* kvpair_var;
+        if (
+            (kvpair_var = kvpair_rule(p))  // kvpair
+        )
+        {
+            D(fprintf(stderr, "%*c+ double_starred_kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kvpair"));
+            _res = kvpair_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s double_starred_kvpair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kvpair"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// kvpair: expression ':' expression
+static KeyValuePair*
+kvpair_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    KeyValuePair* _res = NULL;
+    int _mark = p->mark;
+    { // expression ':' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = expression_rule(p))  // expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ kvpair[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
+            _res = _PyPegen_key_value_pair ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s kvpair[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// for_if_clauses: for_if_clause+
+static asdl_seq*
+for_if_clauses_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // for_if_clause+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
+        asdl_seq * _loop1_103_var;
+        if (
+            (_loop1_103_var = _loop1_103_rule(p))  // for_if_clause+
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_if_clauses[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
+            _res = _loop1_103_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s for_if_clauses[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// for_if_clause:
+//     | ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
+//     | 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
+//     | invalid_for_target
+static comprehension_ty
+for_if_clause_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    comprehension_ty _res = NULL;
+    int _mark = p->mark;
+    { // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
+        int _cut_var = 0;
+        Token * _keyword;
+        Token * _keyword_1;
+        expr_ty a;
+        Token * async_var;
+        expr_ty b;
+        asdl_seq * c;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+            &&
+            (_keyword = _PyPegen_expect_token(p, 517))  // token='for'
+            &&
+            (a = star_targets_rule(p))  // star_targets
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'
+            &&
+            (_cut_var = 1)
+            &&
+            (b = disjunction_rule(p))  // disjunction
+            &&
+            (c = _loop0_104_rule(p))  // (('if' disjunction))*
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
+            _res = CHECK_VERSION ( 6 , "Async comprehensions are" , _Py_comprehension ( a , b , c , 1 , p -> arena ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
+        int _cut_var = 0;
+        Token * _keyword;
+        Token * _keyword_1;
+        expr_ty a;
+        expr_ty b;
+        asdl_seq * c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 517))  // token='for'
+            &&
+            (a = star_targets_rule(p))  // star_targets
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 518))  // token='in'
+            &&
+            (_cut_var = 1)
+            &&
+            (b = disjunction_rule(p))  // disjunction
+            &&
+            (c = _loop0_105_rule(p))  // (('if' disjunction))*
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
+            _res = _Py_comprehension ( a , b , c , 0 , p -> arena );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
+        if (_cut_var) {
+            p->level--;
+            return NULL;
+        }
+    }
+    if (p->call_invalid_rules) { // invalid_for_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
+        void *invalid_for_target_var;
+        if (
+            (invalid_for_target_var = invalid_for_target_rule(p))  // invalid_for_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ for_if_clause[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
+            _res = invalid_for_target_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
+static expr_ty
+yield_expr_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // 'yield' 'from' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
+        Token * _keyword;
+        Token * _keyword_1;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 504))  // token='yield'
+            &&
+            (_keyword_1 = _PyPegen_expect_token(p, 514))  // token='from'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_YieldFrom ( a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' 'from' expression"));
+    }
+    { // 'yield' star_expressions?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
+        Token * _keyword;
+        void *a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 504))  // token='yield'
+            &&
+            (a = star_expressions_rule(p), !p->error_indicator)  // star_expressions?
+        )
+        {
+            D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Yield ( a , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s yield_expr[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'yield' star_expressions?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// arguments: args ','? &')' | invalid_arguments
+static expr_ty
+arguments_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, arguments_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    { // args ','? &')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        if (
+            (a = args_rule(p))  // args
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+            &&
+            _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 8)  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ','? &')'"));
+    }
+    if (p->call_invalid_rules) { // invalid_arguments
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments"));
+        void *invalid_arguments_var;
+        if (
+            (invalid_arguments_var = invalid_arguments_rule(p))  // invalid_arguments
+        )
+        {
+            D(fprintf(stderr, "%*c+ arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_arguments"));
+            _res = invalid_arguments_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s arguments[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_arguments"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, arguments_type, _res);
+    p->level--;
+    return _res;
+}
+
+// args: ','.(starred_expression | named_expression !'=')+ [',' kwargs] | kwargs
+static expr_ty
+args_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // ','.(starred_expression | named_expression !'=')+ [',' kwargs]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]"));
+        asdl_seq * a;
+        void *b;
+        if (
+            (a = _gather_106_rule(p))  // ','.(starred_expression | named_expression !'=')+
+            &&
+            (b = _tmp_108_rule(p), !p->error_indicator)  // [',' kwargs]
+        )
+        {
+            D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]"));
+    }
+    { // kwargs
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));
+        asdl_seq* a;
+        if (
+            (a = kwargs_rule(p))  // kwargs
+        )
+        {
+            D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s args[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwargs"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// kwargs:
+//     | ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
+//     | ','.kwarg_or_starred+
+//     | ','.kwarg_or_double_starred+
+static asdl_seq*
+kwargs_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
+        Token * _literal;
+        asdl_seq * a;
+        asdl_seq * b;
+        if (
+            (a = _gather_109_rule(p))  // ','.kwarg_or_starred+
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (b = _gather_111_rule(p))  // ','.kwarg_or_double_starred+
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
+            _res = _PyPegen_join_sequences ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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+"));
+    }
+    { // ','.kwarg_or_starred+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
+        asdl_seq * _gather_113_var;
+        if (
+            (_gather_113_var = _gather_113_rule(p))  // ','.kwarg_or_starred+
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
+            _res = _gather_113_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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 (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
+        asdl_seq * _gather_115_var;
+        if (
+            (_gather_115_var = _gather_115_rule(p))  // ','.kwarg_or_double_starred+
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwargs[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
+            _res = _gather_115_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s kwargs[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.kwarg_or_double_starred+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// starred_expression: '*' expression
+static expr_ty
+starred_expression_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '*' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Starred ( a , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s starred_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// kwarg_or_starred: NAME '=' expression | starred_expression | invalid_kwarg
+static KeywordOrStarred*
+kwarg_or_starred_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    KeywordOrStarred* _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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME '=' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '=' expression"));
+    }
+    { // starred_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
+        expr_ty a;
+        if (
+            (a = starred_expression_rule(p))  // starred_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
+            _res = _PyPegen_keyword_or_starred ( p , a , 0 );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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) { // invalid_kwarg
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
+        void *invalid_kwarg_var;
+        if (
+            (invalid_kwarg_var = invalid_kwarg_rule(p))  // invalid_kwarg
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
+            _res = invalid_kwarg_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s kwarg_or_starred[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "invalid_kwarg"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// kwarg_or_double_starred: NAME '=' expression | '**' expression | invalid_kwarg
+static KeywordOrStarred*
+kwarg_or_double_starred_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    KeywordOrStarred* _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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME '=' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+            &&
+            (b = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // '**' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( NULL , a , EXTRA ) ) , 1 );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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) { // invalid_kwarg
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
+        void *invalid_kwarg_var;
+        if (
+            (invalid_kwarg_var = invalid_kwarg_rule(p))  // invalid_kwarg
+        )
+        {
+            D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
+            _res = invalid_kwarg_var;
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_targets: star_target !',' | star_target ((',' star_target))* ','?
+static expr_ty
+star_targets_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // star_target !','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !','"));
+        expr_ty a;
+        if (
+            (a = star_target_rule(p))  // star_target
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12)  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target !','"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target !','"));
+    }
+    { // star_target ((',' star_target))* ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = star_target_rule(p))  // star_target
+            &&
+            (b = _loop0_117_rule(p))  // ((',' star_target))*
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_targets[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))* ','?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_targets_list_seq: ','.star_target+ ','?
+static asdl_seq*
+star_targets_list_seq_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.star_target+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        if (
+            (a = _gather_118_rule(p))  // ','.star_target+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_targets_list_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_targets_list_seq[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.star_target+ ','?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ','
+static asdl_seq*
+star_targets_tuple_seq_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // star_target ((',' star_target))+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        asdl_seq * b;
+        if (
+            (a = star_target_rule(p))  // star_target
+            &&
+            (b = _loop1_120_rule(p))  // ((',' star_target))+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?"));
+            _res = _PyPegen_seq_insert_in_front ( p , a , b );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ((',' star_target))+ ','?"));
+    }
+    { // star_target ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ','"));
+        Token * _literal;
+        expr_ty a;
+        if (
+            (a = star_target_rule(p))  // star_target
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_targets_tuple_seq[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ','"));
+            _res = _PyPegen_singleton_seq ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_targets_tuple_seq[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target ','"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// star_target: '*' (!'*' star_target) | target_with_star_atom
+static expr_ty
+star_target_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, star_target_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // '*' (!'*' star_target)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
+        Token * _literal;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (a = _tmp_121_rule(p))  // !'*' star_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Starred ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (!'*' star_target)"));
+    }
+    { // target_with_star_atom
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
+        expr_ty target_with_star_atom_var;
+        if (
+            (target_with_star_atom_var = target_with_star_atom_rule(p))  // target_with_star_atom
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
+            _res = target_with_star_atom_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "target_with_star_atom"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, star_target_type, _res);
+    p->level--;
+    return _res;
+}
+
+// target_with_star_atom:
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+//     | star_atom
+static expr_ty
+target_with_star_atom_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // t_primary '.' NAME !t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+            &&
+            (b = _PyPegen_name_token(p))  // NAME
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (b = slices_rule(p))  // slices
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Subscript ( a , b , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+    }
+    { // star_atom
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_atom"));
+        expr_ty star_atom_var;
+        if (
+            (star_atom_var = star_atom_rule(p))  // star_atom
+        )
+        {
+            D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_atom"));
+            _res = star_atom_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s target_with_star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_atom"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res);
+    p->level--;
+    return _res;
+}
+
+// star_atom:
+//     | NAME
+//     | '(' target_with_star_atom ')'
+//     | '(' star_targets_tuple_seq? ')'
+//     | '[' star_targets_list_seq? ']'
+static expr_ty
+star_atom_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
+            _res = _PyPegen_set_expr_context ( p , a , Store );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
+    }
+    { // '(' target_with_star_atom ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = target_with_star_atom_rule(p))  // target_with_star_atom
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
+            _res = _PyPegen_set_expr_context ( p , a , Store );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' target_with_star_atom ')'"));
+    }
+    { // '(' star_targets_tuple_seq? ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = star_targets_tuple_seq_rule(p), !p->error_indicator)  // star_targets_tuple_seq?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( a , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
+    }
+    { // '[' star_targets_list_seq? ']'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (a = star_targets_list_seq_rule(p), !p->error_indicator)  // star_targets_list_seq?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+        )
+        {
+            D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_List ( a , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s star_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' star_targets_list_seq? ']'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// single_target: single_subscript_attribute_target | NAME | '(' single_target ')'
+static expr_ty
+single_target_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // single_subscript_attribute_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
+        expr_ty single_subscript_attribute_target_var;
+        if (
+            (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p))  // single_subscript_attribute_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
+            _res = single_subscript_attribute_target_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target"));
+    }
+    { // NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
+            _res = _PyPegen_set_expr_context ( p , a , Store );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
+    }
+    { // '(' single_target ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = single_target_rule(p))  // single_target
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ single_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s single_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// single_subscript_attribute_target:
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+static expr_ty
+single_subscript_attribute_target_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // t_primary '.' NAME !t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+            &&
+            (b = _PyPegen_name_token(p))  // NAME
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (b = slices_rule(p))  // slices
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Subscript ( a , b , Store , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s single_subscript_attribute_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// del_targets: ','.del_target+ ','?
+static asdl_seq*
+del_targets_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq* _res = NULL;
+    int _mark = p->mark;
+    { // ','.del_target+ ','?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        asdl_seq * a;
+        if (
+            (a = _gather_122_rule(p))  // ','.del_target+
+            &&
+            (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator)  // ','?
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_targets[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','.del_target+ ','?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// del_target:
+//     | t_primary '.' NAME !t_lookahead
+//     | t_primary '[' slices ']' !t_lookahead
+//     | del_t_atom
+static expr_ty
+del_target_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, del_target_type, &_res)) {
+        p->level--;
+        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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // t_primary '.' NAME !t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+            &&
+            (b = _PyPegen_name_token(p))  // NAME
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Attribute ( a , b -> v . Name . id , Del , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
+    }
+    { // t_primary '[' slices ']' !t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (b = slices_rule(p))  // slices
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+            &&
+            _PyPegen_lookahead(0, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Subscript ( a , b , Del , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
+    }
+    { // del_t_atom
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
+        expr_ty del_t_atom_var;
+        if (
+            (del_t_atom_var = del_t_atom_rule(p))  // del_t_atom
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
+            _res = del_t_atom_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_t_atom"));
+    }
+    _res = NULL;
+  done:
+    _PyPegen_insert_memo(p, _mark, del_target_type, _res);
+    p->level--;
+    return _res;
+}
+
+// del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
+static expr_ty
+del_t_atom_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
+        expr_ty a;
+        if (
+            (a = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
+            _res = _PyPegen_set_expr_context ( p , a , Del );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME"));
+    }
+    { // '(' del_target ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = del_target_rule(p))  // del_target
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'"));
+            _res = _PyPegen_set_expr_context ( p , a , Del );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_target ')'"));
+    }
+    { // '(' del_targets? ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = del_targets_rule(p), !p->error_indicator)  // del_targets?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Tuple ( a , Del , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' del_targets? ')'"));
+    }
+    { // '[' del_targets? ']'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (a = del_targets_rule(p), !p->error_indicator)  // del_targets?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+        )
+        {
+            D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_List ( a , Del , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s del_t_atom[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' del_targets? ']'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// t_primary:
+//     | t_primary '.' NAME &t_lookahead
+//     | t_primary '[' slices ']' &t_lookahead
+//     | t_primary genexp &t_lookahead
+//     | t_primary '(' arguments? ')' &t_lookahead
+//     | atom &t_lookahead
+static expr_ty t_primary_raw(Parser *);
+static expr_ty
+t_primary_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    expr_ty _res = NULL;
+    if (_PyPegen_is_memoized(p, t_primary_type, &_res)) {
+        p->level--;
+        return _res;
+    }
+    int _mark = p->mark;
+    int _resmark = p->mark;
+    while (1) {
+        int tmpvar_8 = _PyPegen_update_memo(p, _mark, t_primary_type, _res);
+        if (tmpvar_8) {
+            p->level--;
+            return _res;
+        }
+        p->mark = _mark;
+        void *_raw = t_primary_raw(p);
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        if (_raw == NULL || p->mark <= _resmark)
+            break;
+        _resmark = p->mark;
+        _res = _raw;
+    }
+    p->mark = _resmark;
+    p->level--;
+    return _res;
+}
+static expr_ty
+t_primary_raw(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    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 _start_lineno = p->tokens[_mark]->lineno;
+    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
+    { // t_primary '.' NAME &t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+            &&
+            (b = _PyPegen_name_token(p))  // NAME
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
+    }
+    { // t_primary '[' slices ']' &t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+            &&
+            (b = slices_rule(p))  // slices
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 10))  // token=']'
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Subscript ( a , b , Load , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
+    }
+    { // t_primary genexp &t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead"));
+        expr_ty a;
+        expr_ty b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (b = genexp_rule(p))  // genexp
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary genexp &t_lookahead"));
+    }
+    { // t_primary '(' arguments? ')' &t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        void *b;
+        if (
+            (a = t_primary_rule(p))  // t_primary
+            &&
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (b = arguments_rule(p), !p->error_indicator)  // arguments?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
+            Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
+            if (_token == NULL) {
+                p->level--;
+                return NULL;
+            }
+            int _end_lineno = _token->end_lineno;
+            UNUSED(_end_lineno); // Only used by EXTRA macro
+            int _end_col_offset = _token->end_col_offset;
+            UNUSED(_end_col_offset); // Only used by EXTRA macro
+            _res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
+    }
+    { // atom &t_lookahead
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
+        expr_ty a;
+        if (
+            (a = atom_rule(p))  // atom
+            &&
+            _PyPegen_lookahead(1, t_lookahead_rule, p)
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "atom &t_lookahead"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// t_lookahead: '(' | '[' | '.'
+static void *
+t_lookahead_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '('
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
+    }
+    { // '['
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
+    }
+    { // '.'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+        )
+        {
+            D(fprintf(stderr, "%*c+ t_lookahead[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s t_lookahead[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_arguments:
+//     | args ',' '*'
+//     | expression for_if_clauses ',' [args | expression for_if_clauses]
+//     | args for_if_clauses
+//     | args ',' expression for_if_clauses
+//     | args ',' args
+static void *
+invalid_arguments_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // args ',' '*'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' '*'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty args_var;
+        if (
+            (args_var = args_rule(p))  // args
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 16))  // token='*'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' '*'"));
+            _res = RAISE_SYNTAX_ERROR ( "iterable argument unpacking follows keyword argument unpacking" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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 ',' [args | expression for_if_clauses]
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));
+        Token * _literal;
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (a = expression_rule(p))  // expression
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_opt_var = _tmp_124_rule(p), !p->error_indicator)  // [args | expression for_if_clauses]
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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]"));
+    }
+    { // args for_if_clauses
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_if_clauses"));
+        expr_ty a;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (a = args_rule(p))  // args
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args for_if_clauses"));
+            _res = _PyPegen_nonparen_genexp_in_call ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // args ',' expression for_if_clauses
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty args_var;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (args_var = args_rule(p))  // args
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (a = expression_rule(p))  // expression
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // args ',' args
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' args"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty args_var;
+        if (
+            (a = args_rule(p))  // args
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (args_var = args_rule(p))  // args
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_arguments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args ',' args"));
+            _res = _PyPegen_arguments_parsing_error ( p , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_arguments[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args ',' args"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_kwarg: !(NAME '=') expression '='
+static void *
+invalid_kwarg_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // !(NAME '=') expression '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));
+        expr_ty a;
+        Token * b;
+        if (
+            _PyPegen_lookahead(0, _tmp_125_rule, p)
+            &&
+            (a = expression_rule(p))  // expression
+            &&
+            (b = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_kwarg[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression cannot contain assignment, perhaps you meant \"==\"?" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_kwarg[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!(NAME '=') expression '='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_named_expression: expression ':=' expression
+static void *
+invalid_named_expression_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // expression ':=' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':=' expression"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty expression_var;
+        if (
+            (a = expression_rule(p))  // expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 53))  // token=':='
+            &&
+            (expression_var = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':=' expression"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_named_expression[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':=' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_assignment:
+//     | invalid_ann_assign_target ':' expression
+//     | star_named_expression ',' star_named_expressions* ':' expression
+//     | expression ':' expression
+//     | ((star_targets '='))* star_expressions '='
+//     | ((star_targets '='))* yield_expr '='
+//     | star_expressions augassign (yield_expr | star_expressions)
+static void *
+invalid_assignment_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // invalid_ann_assign_target ':' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty expression_var;
+        if (
+            (a = invalid_ann_assign_target_rule(p))  // invalid_ann_assign_target
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (expression_var = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // star_named_expression ',' star_named_expressions* ':' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
+        Token * _literal;
+        Token * _literal_1;
+        asdl_seq * _loop0_126_var;
+        expr_ty a;
+        expr_ty expression_var;
+        if (
+            (a = star_named_expression_rule(p))  // star_named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_loop0_126_var = _loop0_126_rule(p))  // star_named_expressions*
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (expression_var = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    { // expression ':' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
+        Token * _literal;
+        expr_ty a;
+        expr_ty expression_var;
+        if (
+            (a = expression_rule(p))  // expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (expression_var = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression ':' expression"));
+    }
+    { // ((star_targets '='))* star_expressions '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='"));
+        Token * _literal;
+        asdl_seq * _loop0_127_var;
+        expr_ty a;
+        if (
+            (_loop0_127_var = _loop0_127_rule(p))  // ((star_targets '='))*
+            &&
+            (a = star_expressions_rule(p))  // star_expressions
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='"));
+            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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 '='"));
+    }
+    { // ((star_targets '='))* yield_expr '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='"));
+        Token * _literal;
+        asdl_seq * _loop0_128_var;
+        expr_ty a;
+        if (
+            (_loop0_128_var = _loop0_128_rule(p))  // ((star_targets '='))*
+            &&
+            (a = yield_expr_rule(p))  // yield_expr
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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 '='"));
+    }
+    { // star_expressions augassign (yield_expr | star_expressions)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)"));
+        void *_tmp_129_var;
+        expr_ty a;
+        AugOperator* augassign_var;
+        if (
+            (a = star_expressions_rule(p))  // star_expressions
+            &&
+            (augassign_var = augassign_rule(p))  // augassign
+            &&
+            (_tmp_129_var = _tmp_129_rule(p))  // yield_expr | star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_assignment[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')'
+static expr_ty
+invalid_ann_assign_target_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    expr_ty _res = NULL;
+    int _mark = p->mark;
+    { // list
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
+        expr_ty list_var;
+        if (
+            (list_var = list_rule(p))  // list
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
+            _res = list_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
+    }
+    { // tuple
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
+        expr_ty tuple_var;
+        if (
+            (tuple_var = tuple_rule(p))  // tuple
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
+            _res = tuple_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
+    }
+    { // '(' invalid_ann_assign_target ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = invalid_ann_assign_target_rule(p))  // invalid_ann_assign_target
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_ann_assign_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
+            _res = a;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_ann_assign_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_del_stmt: 'del' star_expressions
+static void *
+invalid_del_stmt_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'del' star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star_expressions"));
+        Token * _keyword;
+        expr_ty a;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 503))  // token='del'
+            &&
+            (a = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' star_expressions"));
+            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_del_stmt[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'del' star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_block: NEWLINE !INDENT
+static void *
+invalid_block_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // NEWLINE !INDENT
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT"));
+        Token * newline_var;
+        if (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, INDENT)  // token=INDENT
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT"));
+            _res = RAISE_INDENTATION_ERROR ( "expected an indented block" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_block[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE !INDENT"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// Left-recursive
+// invalid_primary: primary '{'
+static void *
+invalid_primary_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // primary '{'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '{'"));
+        Token * a;
+        expr_ty primary_var;
+        if (
+            (primary_var = primary_rule(p))  // primary
+            &&
+            (a = _PyPegen_expect_token(p, 25))  // token='{'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '{'"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid syntax" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_primary[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "primary '{'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_comprehension: ('[' | '(' | '{') starred_expression for_if_clauses
+static void *
+invalid_comprehension_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ('[' | '(' | '{') starred_expression for_if_clauses
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
+        void *_tmp_130_var;
+        expr_ty a;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (_tmp_130_var = _tmp_130_rule(p))  // '[' | '(' | '{'
+            &&
+            (a = starred_expression_rule(p))  // starred_expression
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}'
+static void *
+invalid_dict_comprehension_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '{' '**' bitwise_or for_if_clauses '}'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
+        Token * _literal;
+        Token * _literal_1;
+        Token * a;
+        expr_ty bitwise_or_var;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 25))  // token='{'
+            &&
+            (a = _PyPegen_expect_token(p, 35))  // token='**'
+            &&
+            (bitwise_or_var = bitwise_or_rule(p))  // bitwise_or
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 26))  // token='}'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_dict_comprehension[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_dict_comprehension[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_parameters:
+//     | param_no_default* (slash_with_default | param_with_default+) param_no_default
+static void *
+invalid_parameters_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // param_no_default* (slash_with_default | param_with_default+) param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default"));
+        asdl_seq * _loop0_131_var;
+        void *_tmp_132_var;
+        arg_ty param_no_default_var;
+        if (
+            (_loop0_131_var = _loop0_131_rule(p))  // param_no_default*
+            &&
+            (_tmp_132_var = _tmp_132_rule(p))  // slash_with_default | param_with_default+
+            &&
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default"));
+            _res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_parameters[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_lambda_parameters:
+//     | lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default
+static void *
+invalid_lambda_parameters_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default"));
+        asdl_seq * _loop0_133_var;
+        void *_tmp_134_var;
+        arg_ty lambda_param_no_default_var;
+        if (
+            (_loop0_133_var = _loop0_133_rule(p))  // lambda_param_no_default*
+            &&
+            (_tmp_134_var = _tmp_134_rule(p))  // lambda_slash_with_default | lambda_param_with_default+
+            &&
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_lambda_parameters[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default"));
+            _res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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_slash_with_default | lambda_param_with_default+) lambda_param_no_default"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_star_etc: '*' (')' | ',' (')' | '**')) | '*' ',' TYPE_COMMENT
+static void *
+invalid_star_etc_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '*' (')' | ',' (')' | '**'))
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
+        Token * _literal;
+        void *_tmp_135_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (_tmp_135_var = _tmp_135_rule(p))  // ')' | ',' (')' | '**')
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
+            _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
+    }
+    { // '*' ',' TYPE_COMMENT
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT"));
+        Token * _literal;
+        Token * _literal_1;
+        Token * type_comment_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT"));
+            _res = RAISE_SYNTAX_ERROR ( "bare * has associated type comment" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' ',' TYPE_COMMENT"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_lambda_star_etc: '*' (':' | ',' (':' | '**'))
+static void *
+invalid_lambda_star_etc_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '*' (':' | ',' (':' | '**'))
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
+        Token * _literal;
+        void *_tmp_136_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 16))  // token='*'
+            &&
+            (_tmp_136_var = _tmp_136_rule(p))  // ':' | ',' (':' | '**')
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_lambda_star_etc[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
+            _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_lambda_star_etc[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
+static void *
+invalid_double_type_comments_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT"));
+        Token * indent_var;
+        Token * newline_var;
+        Token * newline_var_1;
+        Token * type_comment_var;
+        Token * type_comment_var_1;
+        if (
+            (type_comment_var = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'
+            &&
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+            &&
+            (type_comment_var_1 = _PyPegen_expect_token(p, TYPE_COMMENT))  // token='TYPE_COMMENT'
+            &&
+            (newline_var_1 = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+            &&
+            (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_double_type_comments[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT"));
+            _res = RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_double_type_comments[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_with_item: expression 'as' expression
+static void *
+invalid_with_item_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // expression 'as' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' expression"));
+        Token * _keyword;
+        expr_ty a;
+        expr_ty expression_var;
+        if (
+            (expression_var = expression_rule(p))  // expression
+            &&
+            (_keyword = _PyPegen_expect_token(p, 520))  // token='as'
+            &&
+            (a = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_with_item[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression 'as' expression"));
+            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_with_item[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression 'as' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_for_target: ASYNC? 'for' star_expressions
+static void *
+invalid_for_target_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ASYNC? 'for' star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions"));
+        Token * _keyword;
+        void *_opt_var;
+        UNUSED(_opt_var); // Silence compiler warnings
+        expr_ty a;
+        if (
+            (_opt_var = _PyPegen_expect_token(p, ASYNC), !p->error_indicator)  // ASYNC?
+            &&
+            (_keyword = _PyPegen_expect_token(p, 517))  // token='for'
+            &&
+            (a = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_for_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions"));
+            _res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_for_target[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC? 'for' star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_group: '(' starred_expression ')'
+static void *
+invalid_group_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '(' starred_expression ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty a;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (a = starred_expression_rule(p))  // starred_expression
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_group[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'"));
+            _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "can't use starred expression here" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s invalid_group[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' starred_expression ')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// invalid_import_from_targets: import_from_as_names ',' NEWLINE
+static void *
+invalid_import_from_targets_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // import_from_as_names ',' NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE"));
+        Token * _literal;
+        asdl_seq* import_from_as_names_var;
+        Token * newline_var;
+        if (
+            (import_from_as_names_var = import_from_as_names_rule(p))  // import_from_as_names
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ invalid_import_from_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE"));
+            _res = RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        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"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_1: NEWLINE
+static asdl_seq *
+_loop0_1_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
+        Token * newline_var;
+        while (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            _res = newline_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_1[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_2: NEWLINE
+static asdl_seq *
+_loop0_2_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
+        Token * newline_var;
+        while (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            _res = newline_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_2[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_4: ',' expression
+static asdl_seq *
+_loop0_4_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = expression_rule(p))  // expression
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_4[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_4_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_3: expression _loop0_4
+static asdl_seq *
+_gather_3_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // expression _loop0_4
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_4"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = expression_rule(p))  // expression
+            &&
+            (seq = _loop0_4_rule(p))  // _loop0_4
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_3[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_4"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_3[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_4"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_6: ',' expression
+static asdl_seq *
+_loop0_6_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = expression_rule(p))  // expression
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_6[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_6_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_5: expression _loop0_6
+static asdl_seq *
+_gather_5_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // expression _loop0_6
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_6"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = expression_rule(p))  // expression
+            &&
+            (seq = _loop0_6_rule(p))  // _loop0_6
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_5[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_6"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_5[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_6"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_8: ',' expression
+static asdl_seq *
+_loop0_8_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = expression_rule(p))  // expression
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_8[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_8_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_7: expression _loop0_8
+static asdl_seq *
+_gather_7_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // expression _loop0_8
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_8"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = expression_rule(p))  // expression
+            &&
+            (seq = _loop0_8_rule(p))  // _loop0_8
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_7[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_8"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_7[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_8"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_10: ',' expression
+static asdl_seq *
+_loop0_10_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = expression_rule(p))  // expression
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_10[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_10_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_9: expression _loop0_10
+static asdl_seq *
+_gather_9_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // expression _loop0_10
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_10"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = expression_rule(p))  // expression
+            &&
+            (seq = _loop0_10_rule(p))  // _loop0_10
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_9[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression _loop0_10"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_9[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression _loop0_10"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_11: statement
+static asdl_seq *
+_loop1_11_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // statement
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement"));
+        asdl_seq* statement_var;
+        while (
+            (statement_var = statement_rule(p))  // statement
+        )
+        {
+            _res = statement_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_11[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "statement"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_11_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_13: ';' small_stmt
+static asdl_seq *
+_loop0_13_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ';' small_stmt
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' small_stmt"));
+        Token * _literal;
+        stmt_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 13))  // token=';'
+            &&
+            (elem = small_stmt_rule(p))  // small_stmt
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_13[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';' small_stmt"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_13_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_12: small_stmt _loop0_13
+static asdl_seq *
+_gather_12_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // small_stmt _loop0_13
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "small_stmt _loop0_13"));
+        stmt_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = small_stmt_rule(p))  // small_stmt
+            &&
+            (seq = _loop0_13_rule(p))  // _loop0_13
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_12[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "small_stmt _loop0_13"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_12[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "small_stmt _loop0_13"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_14: 'import' | 'from'
+static void *
+_tmp_14_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'import'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 513))  // token='import'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_14[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import'"));
+            _res = _keyword;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_14[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'import'"));
+    }
+    { // 'from'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 514))  // token='from'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_14[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from'"));
+            _res = _keyword;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_14[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_15: 'def' | '@' | ASYNC
+static void *
+_tmp_15_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'def'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 523))  // token='def'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def'"));
+            _res = _keyword;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'def'"));
+    }
+    { // '@'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 49))  // token='@'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
+    }
+    { // ASYNC
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
+        Token * async_var;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_15[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
+            _res = async_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_15[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_16: 'class' | '@'
+static void *
+_tmp_16_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'class'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 524))  // token='class'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class'"));
+            _res = _keyword;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'class'"));
+    }
+    { // '@'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 49))  // token='@'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_16[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_16[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_17: 'with' | ASYNC
+static void *
+_tmp_17_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'with'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 519))  // token='with'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with'"));
+            _res = _keyword;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'with'"));
+    }
+    { // ASYNC
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
+        Token * async_var;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_17[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
+            _res = async_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_17[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_18: 'for' | ASYNC
+static void *
+_tmp_18_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'for'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'"));
+        Token * _keyword;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 517))  // token='for'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for'"));
+            _res = _keyword;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_18[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for'"));
+    }
+    { // ASYNC
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
+        Token * async_var;
+        if (
+            (async_var = _PyPegen_expect_token(p, ASYNC))  // token='ASYNC'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_18[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC"));
+            _res = async_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_18[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_19: '=' annotated_rhs
+static void *
+_tmp_19_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '=' annotated_rhs
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
+        Token * _literal;
+        expr_ty d;
+        if (
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+            &&
+            (d = annotated_rhs_rule(p))  // annotated_rhs
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_19[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
+            _res = d;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_19[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_20: '(' single_target ')' | single_subscript_attribute_target
+static void *
+_tmp_20_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '(' single_target ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        expr_ty b;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (b = single_target_rule(p))  // single_target
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
+            _res = b;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_20[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' single_target ')'"));
+    }
+    { // single_subscript_attribute_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
+        expr_ty single_subscript_attribute_target_var;
+        if (
+            (single_subscript_attribute_target_var = single_subscript_attribute_target_rule(p))  // single_subscript_attribute_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_20[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
+            _res = single_subscript_attribute_target_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_20[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_subscript_attribute_target"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_21: '=' annotated_rhs
+static void *
+_tmp_21_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '=' annotated_rhs
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
+        Token * _literal;
+        expr_ty d;
+        if (
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+            &&
+            (d = annotated_rhs_rule(p))  // annotated_rhs
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_21[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
+            _res = d;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_21[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'=' annotated_rhs"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_22: (star_targets '=')
+static asdl_seq *
+_loop1_22_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (star_targets '=')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
+        void *_tmp_137_var;
+        while (
+            (_tmp_137_var = _tmp_137_rule(p))  // star_targets '='
+        )
+        {
+            _res = _tmp_137_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_22[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_22_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_23: yield_expr | star_expressions
+static void *
+_tmp_23_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // yield_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))  // yield_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+            _res = yield_expr_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
+    }
+    { // star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_23[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+            _res = star_expressions_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_23[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_24: yield_expr | star_expressions
+static void *
+_tmp_24_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // yield_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))  // yield_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_24[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+            _res = yield_expr_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_24[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
+    }
+    { // star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_24[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+            _res = star_expressions_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_24[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_26: ',' NAME
+static asdl_seq *
+_loop0_26_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_26[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_26_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_25: NAME _loop0_26
+static asdl_seq *
+_gather_25_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // NAME _loop0_26
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_26"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = _PyPegen_name_token(p))  // NAME
+            &&
+            (seq = _loop0_26_rule(p))  // _loop0_26
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_25[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_26"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_25[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_26"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_28: ',' NAME
+static asdl_seq *
+_loop0_28_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_28[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' NAME"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_28_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_27: NAME _loop0_28
+static asdl_seq *
+_gather_27_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // NAME _loop0_28
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_28"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = _PyPegen_name_token(p))  // NAME
+            &&
+            (seq = _loop0_28_rule(p))  // _loop0_28
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_27[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME _loop0_28"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_27[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME _loop0_28"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_29: ',' expression
+static void *
+_tmp_29_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ',' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
+        Token * _literal;
+        expr_ty z;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (z = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_29[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_29[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_30: ';' | NEWLINE
+static void *
+_tmp_30_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ';'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 13))  // token=';'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_30[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "';'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_30[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "';'"));
+    }
+    { // NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
+        Token * newline_var;
+        if (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_30[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
+            _res = newline_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_30[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_31: ('.' | '...')
+static asdl_seq *
+_loop0_31_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('.' | '...')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
+        void *_tmp_138_var;
+        while (
+            (_tmp_138_var = _tmp_138_rule(p))  // '.' | '...'
+        )
+        {
+            _res = _tmp_138_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_31[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_31_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_32: ('.' | '...')
+static asdl_seq *
+_loop1_32_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('.' | '...')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
+        void *_tmp_139_var;
+        while (
+            (_tmp_139_var = _tmp_139_rule(p))  // '.' | '...'
+        )
+        {
+            _res = _tmp_139_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_32[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('.' | '...')"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_34: ',' import_from_as_name
+static asdl_seq *
+_loop0_34_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' import_from_as_name
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_as_name"));
+        Token * _literal;
+        alias_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = import_from_as_name_rule(p))  // import_from_as_name
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_34[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' import_from_as_name"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_34_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_33: import_from_as_name _loop0_34
+static asdl_seq *
+_gather_33_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // import_from_as_name _loop0_34
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_34"));
+        alias_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = import_from_as_name_rule(p))  // import_from_as_name
+            &&
+            (seq = _loop0_34_rule(p))  // _loop0_34
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_33[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_34"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_33[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "import_from_as_name _loop0_34"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_35: 'as' NAME
+static void *
+_tmp_35_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'as' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
+        Token * _keyword;
+        expr_ty z;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 520))  // token='as'
+            &&
+            (z = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_35[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_35[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_37: ',' dotted_as_name
+static asdl_seq *
+_loop0_37_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' dotted_as_name
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_name"));
+        Token * _literal;
+        alias_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = dotted_as_name_rule(p))  // dotted_as_name
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_37[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' dotted_as_name"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_36: dotted_as_name _loop0_37
+static asdl_seq *
+_gather_36_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // dotted_as_name _loop0_37
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_37"));
+        alias_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = dotted_as_name_rule(p))  // dotted_as_name
+            &&
+            (seq = _loop0_37_rule(p))  // _loop0_37
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_36[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_37"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_36[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dotted_as_name _loop0_37"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_38: 'as' NAME
+static void *
+_tmp_38_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'as' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
+        Token * _keyword;
+        expr_ty z;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 520))  // token='as'
+            &&
+            (z = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_38[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_38[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_40: ',' with_item
+static asdl_seq *
+_loop0_40_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' with_item
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
+        Token * _literal;
+        withitem_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = with_item_rule(p))  // with_item
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_40[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_39: with_item _loop0_40
+static asdl_seq *
+_gather_39_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // with_item _loop0_40
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_40"));
+        withitem_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = with_item_rule(p))  // with_item
+            &&
+            (seq = _loop0_40_rule(p))  // _loop0_40
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_39[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_40"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_39[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_40"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_42: ',' with_item
+static asdl_seq *
+_loop0_42_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' with_item
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
+        Token * _literal;
+        withitem_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = with_item_rule(p))  // with_item
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_42[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_42_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_41: with_item _loop0_42
+static asdl_seq *
+_gather_41_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // with_item _loop0_42
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_42"));
+        withitem_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = with_item_rule(p))  // with_item
+            &&
+            (seq = _loop0_42_rule(p))  // _loop0_42
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_41[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_42"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_41[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_42"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_44: ',' with_item
+static asdl_seq *
+_loop0_44_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' with_item
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
+        Token * _literal;
+        withitem_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = with_item_rule(p))  // with_item
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_44[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_43: with_item _loop0_44
+static asdl_seq *
+_gather_43_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // with_item _loop0_44
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_44"));
+        withitem_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = with_item_rule(p))  // with_item
+            &&
+            (seq = _loop0_44_rule(p))  // _loop0_44
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_43[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_44"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_43[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_44"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_46: ',' with_item
+static asdl_seq *
+_loop0_46_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' with_item
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
+        Token * _literal;
+        withitem_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = with_item_rule(p))  // with_item
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_46[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' with_item"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_45: with_item _loop0_46
+static asdl_seq *
+_gather_45_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // with_item _loop0_46
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_46"));
+        withitem_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = with_item_rule(p))  // with_item
+            &&
+            (seq = _loop0_46_rule(p))  // _loop0_46
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_45[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "with_item _loop0_46"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_45[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "with_item _loop0_46"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_47: ',' | ')' | ':'
+static void *
+_tmp_47_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ','
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "','"));
+    }
+    { // ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
+    }
+    { // ':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_47[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_47[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_48: except_block
+static asdl_seq *
+_loop1_48_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // except_block
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
+        excepthandler_ty except_block_var;
+        while (
+            (except_block_var = except_block_rule(p))  // except_block
+        )
+        {
+            _res = except_block_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_48[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "except_block"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_48_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_49: 'as' NAME
+static void *
+_tmp_49_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'as' NAME
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
+        Token * _keyword;
+        expr_ty z;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 520))  // token='as'
+            &&
+            (z = _PyPegen_name_token(p))  // NAME
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_49[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_49[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'as' NAME"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_50: 'from' expression
+static void *
+_tmp_50_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'from' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression"));
+        Token * _keyword;
+        expr_ty z;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 514))  // token='from'
+            &&
+            (z = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_50[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' expression"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_50[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'from' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_51: '->' expression
+static void *
+_tmp_51_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '->' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
+        Token * _literal;
+        expr_ty z;
+        if (
+            (_literal = _PyPegen_expect_token(p, 51))  // token='->'
+            &&
+            (z = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_51[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_51[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_52: '->' expression
+static void *
+_tmp_52_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '->' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
+        Token * _literal;
+        expr_ty z;
+        if (
+            (_literal = _PyPegen_expect_token(p, 51))  // token='->'
+            &&
+            (z = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_52[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'->' expression"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_52[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'->' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_53: NEWLINE INDENT
+static void *
+_tmp_53_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // NEWLINE INDENT
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT"));
+        Token * indent_var;
+        Token * newline_var;
+        if (
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+            &&
+            (indent_var = _PyPegen_expect_token(p, INDENT))  // token='INDENT'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_53[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT"));
+            _res = _PyPegen_dummy_name(p, newline_var, indent_var);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_53[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NEWLINE INDENT"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_54: param_no_default
+static asdl_seq *
+_loop0_54_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_54[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_55: param_with_default
+static asdl_seq *
+_loop0_55_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_55[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_55_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_56: param_with_default
+static asdl_seq *
+_loop0_56_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_56[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_57: param_no_default
+static asdl_seq *
+_loop1_57_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_57[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_57_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_58: param_with_default
+static asdl_seq *
+_loop0_58_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_58[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_59: param_with_default
+static asdl_seq *
+_loop1_59_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_59[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_59_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_60: param_no_default
+static asdl_seq *
+_loop1_60_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_60[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_61: param_no_default
+static asdl_seq *
+_loop1_61_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_61[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_62: param_no_default
+static asdl_seq *
+_loop0_62_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_62[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_62_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_63: param_with_default
+static asdl_seq *
+_loop1_63_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_63[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_63_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_64: param_no_default
+static asdl_seq *
+_loop0_64_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_64[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_64_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_65: param_with_default
+static asdl_seq *
+_loop1_65_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_65[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_65_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_66: param_maybe_default
+static asdl_seq *
+_loop0_66_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_maybe_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
+        NameDefaultPair* param_maybe_default_var;
+        while (
+            (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default
+        )
+        {
+            _res = param_maybe_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_66[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_67: param_maybe_default
+static asdl_seq *
+_loop1_67_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_maybe_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
+        NameDefaultPair* param_maybe_default_var;
+        while (
+            (param_maybe_default_var = param_maybe_default_rule(p))  // param_maybe_default
+        )
+        {
+            _res = param_maybe_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_67[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_maybe_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_67_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_68: ('@' named_expression NEWLINE)
+static asdl_seq *
+_loop1_68_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('@' named_expression NEWLINE)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)"));
+        void *_tmp_140_var;
+        while (
+            (_tmp_140_var = _tmp_140_rule(p))  // '@' named_expression NEWLINE
+        )
+        {
+            _res = _tmp_140_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_68[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('@' named_expression NEWLINE)"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_68_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_69: '(' arguments? ')'
+static void *
+_tmp_69_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '(' arguments? ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
+        Token * _literal;
+        Token * _literal_1;
+        void *z;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+            &&
+            (z = arguments_rule(p), !p->error_indicator)  // arguments?
+            &&
+            (_literal_1 = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_69[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_69[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' arguments? ')'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_70: (',' star_expression)
+static asdl_seq *
+_loop1_70_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (',' star_expression)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)"));
+        void *_tmp_141_var;
+        while (
+            (_tmp_141_var = _tmp_141_rule(p))  // ',' star_expression
+        )
+        {
+            _res = _tmp_141_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_70[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_expression)"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_70_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_72: ',' star_named_expression
+static asdl_seq *
+_loop0_72_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' star_named_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = star_named_expression_rule(p))  // star_named_expression
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_72[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_named_expression"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_71: star_named_expression _loop0_72
+static asdl_seq *
+_gather_71_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // star_named_expression _loop0_72
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_72"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = star_named_expression_rule(p))  // star_named_expression
+            &&
+            (seq = _loop0_72_rule(p))  // _loop0_72
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_71[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_72"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_71[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression _loop0_72"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_73: (',' expression)
+static asdl_seq *
+_loop1_73_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (',' expression)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"));
+        void *_tmp_142_var;
+        while (
+            (_tmp_142_var = _tmp_142_rule(p))  // ',' expression
+        )
+        {
+            _res = _tmp_142_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_73[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' expression)"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_73_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_74: lambda_param_no_default
+static asdl_seq *
+_loop0_74_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_74[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_75: lambda_param_with_default
+static asdl_seq *
+_loop0_75_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_75[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_75_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_76: lambda_param_with_default
+static asdl_seq *
+_loop0_76_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_76[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_76_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_77: lambda_param_no_default
+static asdl_seq *
+_loop1_77_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_77[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_77_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_78: lambda_param_with_default
+static asdl_seq *
+_loop0_78_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_78[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_78_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_79: lambda_param_with_default
+static asdl_seq *
+_loop1_79_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_79[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_79_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_80: lambda_param_no_default
+static asdl_seq *
+_loop1_80_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_80[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_81: lambda_param_no_default
+static asdl_seq *
+_loop1_81_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_81[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_82: lambda_param_no_default
+static asdl_seq *
+_loop0_82_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_82[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_82_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_83: lambda_param_with_default
+static asdl_seq *
+_loop1_83_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_83[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_83_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_84: lambda_param_no_default
+static asdl_seq *
+_loop0_84_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_84[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_84_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_85: lambda_param_with_default
+static asdl_seq *
+_loop1_85_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_85[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_86: lambda_param_maybe_default
+static asdl_seq *
+_loop0_86_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_maybe_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
+        NameDefaultPair* lambda_param_maybe_default_var;
+        while (
+            (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default
+        )
+        {
+            _res = lambda_param_maybe_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_86[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_86_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_87: lambda_param_maybe_default
+static asdl_seq *
+_loop1_87_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_maybe_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
+        NameDefaultPair* lambda_param_maybe_default_var;
+        while (
+            (lambda_param_maybe_default_var = lambda_param_maybe_default_rule(p))  // lambda_param_maybe_default
+        )
+        {
+            _res = lambda_param_maybe_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_87[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_maybe_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_87_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_88: ('or' conjunction)
+static asdl_seq *
+_loop1_88_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('or' conjunction)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)"));
+        void *_tmp_143_var;
+        while (
+            (_tmp_143_var = _tmp_143_rule(p))  // 'or' conjunction
+        )
+        {
+            _res = _tmp_143_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_88[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('or' conjunction)"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_88_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_89: ('and' inversion)
+static asdl_seq *
+_loop1_89_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('and' inversion)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)"));
+        void *_tmp_144_var;
+        while (
+            (_tmp_144_var = _tmp_144_rule(p))  // 'and' inversion
+        )
+        {
+            _res = _tmp_144_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_89[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('and' inversion)"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_89_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_90: compare_op_bitwise_or_pair
+static asdl_seq *
+_loop1_90_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // compare_op_bitwise_or_pair
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair"));
+        CmpopExprPair* compare_op_bitwise_or_pair_var;
+        while (
+            (compare_op_bitwise_or_pair_var = compare_op_bitwise_or_pair_rule(p))  // compare_op_bitwise_or_pair
+        )
+        {
+            _res = compare_op_bitwise_or_pair_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_90[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "compare_op_bitwise_or_pair"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_90_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_91: '!='
+static void *
+_tmp_91_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '!='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='"));
+        Token * tok;
+        if (
+            (tok = _PyPegen_expect_token(p, 28))  // token='!='
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_91[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'!='"));
+            _res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_91[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'!='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_93: ',' slice
+static asdl_seq *
+_loop0_93_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' slice
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' slice"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = slice_rule(p))  // slice
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_93[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' slice"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_93_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_92: slice _loop0_93
+static asdl_seq *
+_gather_92_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // slice _loop0_93
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice _loop0_93"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = slice_rule(p))  // slice
+            &&
+            (seq = _loop0_93_rule(p))  // _loop0_93
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_92[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slice _loop0_93"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_92[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slice _loop0_93"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_94: ':' expression?
+static void *
+_tmp_94_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ':' expression?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?"));
+        Token * _literal;
+        void *d;
+        if (
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+            &&
+            (d = expression_rule(p), !p->error_indicator)  // expression?
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_94[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':' expression?"));
+            _res = d;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_94[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':' expression?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_95: tuple | group | genexp
+static void *
+_tmp_95_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // tuple
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
+        expr_ty tuple_var;
+        if (
+            (tuple_var = tuple_rule(p))  // tuple
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "tuple"));
+            _res = tuple_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "tuple"));
+    }
+    { // group
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group"));
+        expr_ty group_var;
+        if (
+            (group_var = group_rule(p))  // group
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "group"));
+            _res = group_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "group"));
+    }
+    { // genexp
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));
+        expr_ty genexp_var;
+        if (
+            (genexp_var = genexp_rule(p))  // genexp
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_95[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "genexp"));
+            _res = genexp_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_95[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "genexp"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_96: list | listcomp
+static void *
+_tmp_96_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // list
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
+        expr_ty list_var;
+        if (
+            (list_var = list_rule(p))  // list
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "list"));
+            _res = list_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "list"));
+    }
+    { // listcomp
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp"));
+        expr_ty listcomp_var;
+        if (
+            (listcomp_var = listcomp_rule(p))  // listcomp
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_96[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "listcomp"));
+            _res = listcomp_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_96[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "listcomp"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_97: dict | set | dictcomp | setcomp
+static void *
+_tmp_97_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // dict
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict"));
+        expr_ty dict_var;
+        if (
+            (dict_var = dict_rule(p))  // dict
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dict"));
+            _res = dict_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dict"));
+    }
+    { // set
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set"));
+        expr_ty set_var;
+        if (
+            (set_var = set_rule(p))  // set
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "set"));
+            _res = set_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "set"));
+    }
+    { // dictcomp
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp"));
+        expr_ty dictcomp_var;
+        if (
+            (dictcomp_var = dictcomp_rule(p))  // dictcomp
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "dictcomp"));
+            _res = dictcomp_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "dictcomp"));
+    }
+    { // setcomp
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp"));
+        expr_ty setcomp_var;
+        if (
+            (setcomp_var = setcomp_rule(p))  // setcomp
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_97[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "setcomp"));
+            _res = setcomp_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_97[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "setcomp"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_98: STRING
+static asdl_seq *
+_loop1_98_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // STRING
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING"));
+        expr_ty string_var;
+        while (
+            (string_var = _PyPegen_string_token(p))  // STRING
+        )
+        {
+            _res = string_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_98[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "STRING"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_99: star_named_expression ',' star_named_expressions?
+static void *
+_tmp_99_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // star_named_expression ',' star_named_expressions?
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
+        Token * _literal;
+        expr_ty y;
+        void *z;
+        if (
+            (y = star_named_expression_rule(p))  // star_named_expression
+            &&
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (z = star_named_expressions_rule(p), !p->error_indicator)  // star_named_expressions?
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_99[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
+            _res = _PyPegen_seq_insert_in_front ( p , y , z );
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_99[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_100: yield_expr | named_expression
+static void *
+_tmp_100_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // yield_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))  // yield_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+            _res = yield_expr_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
+    }
+    { // named_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
+        expr_ty named_expression_var;
+        if (
+            (named_expression_var = named_expression_rule(p))  // named_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_100[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression"));
+            _res = named_expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_100[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_102: ',' double_starred_kvpair
+static asdl_seq *
+_loop0_102_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' double_starred_kvpair
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair"));
+        Token * _literal;
+        KeyValuePair* elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_102[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' double_starred_kvpair"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_102_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_101: double_starred_kvpair _loop0_102
+static asdl_seq *
+_gather_101_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // double_starred_kvpair _loop0_102
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_102"));
+        KeyValuePair* elem;
+        asdl_seq * seq;
+        if (
+            (elem = double_starred_kvpair_rule(p))  // double_starred_kvpair
+            &&
+            (seq = _loop0_102_rule(p))  // _loop0_102
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_101[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_102"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_101[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "double_starred_kvpair _loop0_102"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_103: for_if_clause
+static asdl_seq *
+_loop1_103_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // for_if_clause
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause"));
+        comprehension_ty for_if_clause_var;
+        while (
+            (for_if_clause_var = for_if_clause_rule(p))  // for_if_clause
+        )
+        {
+            _res = for_if_clause_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_103[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "for_if_clause"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_103_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_104: ('if' disjunction)
+static asdl_seq *
+_loop0_104_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('if' disjunction)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
+        void *_tmp_145_var;
+        while (
+            (_tmp_145_var = _tmp_145_rule(p))  // 'if' disjunction
+        )
+        {
+            _res = _tmp_145_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_104[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_104_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_105: ('if' disjunction)
+static asdl_seq *
+_loop0_105_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ('if' disjunction)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
+        void *_tmp_146_var;
+        while (
+            (_tmp_146_var = _tmp_146_rule(p))  // 'if' disjunction
+        )
+        {
+            _res = _tmp_146_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_105[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "('if' disjunction)"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_107: ',' (starred_expression | named_expression !'=')
+static asdl_seq *
+_loop0_107_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' (starred_expression | named_expression !'=')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | named_expression !'=')"));
+        Token * _literal;
+        void *elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = _tmp_147_rule(p))  // starred_expression | named_expression !'='
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_107[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (starred_expression | named_expression !'=')"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_106: (starred_expression | named_expression !'=') _loop0_107
+static asdl_seq *
+_gather_106_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // (starred_expression | named_expression !'=') _loop0_107
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107"));
+        void *elem;
+        asdl_seq * seq;
+        if (
+            (elem = _tmp_147_rule(p))  // starred_expression | named_expression !'='
+            &&
+            (seq = _loop0_107_rule(p))  // _loop0_107
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_106[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_106[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_108: ',' kwargs
+static void *
+_tmp_108_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ',' kwargs
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
+        Token * _literal;
+        asdl_seq* k;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (k = kwargs_rule(p))  // kwargs
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_108[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
+            _res = k;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_108[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwargs"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_110: ',' kwarg_or_starred
+static asdl_seq *
+_loop0_110_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' kwarg_or_starred
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred"));
+        Token * _literal;
+        KeywordOrStarred* elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_110[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_110_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_109: kwarg_or_starred _loop0_110
+static asdl_seq *
+_gather_109_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // kwarg_or_starred _loop0_110
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_110"));
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred
+            &&
+            (seq = _loop0_110_rule(p))  // _loop0_110
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_109[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_110"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_109[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_110"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_112: ',' kwarg_or_double_starred
+static asdl_seq *
+_loop0_112_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' kwarg_or_double_starred
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred"));
+        Token * _literal;
+        KeywordOrStarred* elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_112[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_111: kwarg_or_double_starred _loop0_112
+static asdl_seq *
+_gather_111_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // kwarg_or_double_starred _loop0_112
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_112"));
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred
+            &&
+            (seq = _loop0_112_rule(p))  // _loop0_112
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_111[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_112"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_111[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_112"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_114: ',' kwarg_or_starred
+static asdl_seq *
+_loop0_114_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' kwarg_or_starred
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred"));
+        Token * _literal;
+        KeywordOrStarred* elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_114[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_starred"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_113: kwarg_or_starred _loop0_114
+static asdl_seq *
+_gather_113_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // kwarg_or_starred _loop0_114
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_114"));
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_starred_rule(p))  // kwarg_or_starred
+            &&
+            (seq = _loop0_114_rule(p))  // _loop0_114
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_113[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_114"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_113[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_starred _loop0_114"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_116: ',' kwarg_or_double_starred
+static asdl_seq *
+_loop0_116_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' kwarg_or_double_starred
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred"));
+        Token * _literal;
+        KeywordOrStarred* elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_116[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' kwarg_or_double_starred"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_116_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_115: kwarg_or_double_starred _loop0_116
+static asdl_seq *
+_gather_115_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // kwarg_or_double_starred _loop0_116
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_116"));
+        KeywordOrStarred* elem;
+        asdl_seq * seq;
+        if (
+            (elem = kwarg_or_double_starred_rule(p))  // kwarg_or_double_starred
+            &&
+            (seq = _loop0_116_rule(p))  // _loop0_116
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_115[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_116"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_115[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "kwarg_or_double_starred _loop0_116"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_117: (',' star_target)
+static asdl_seq *
+_loop0_117_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (',' star_target)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
+        void *_tmp_148_var;
+        while (
+            (_tmp_148_var = _tmp_148_rule(p))  // ',' star_target
+        )
+        {
+            _res = _tmp_148_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_117[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_117_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_119: ',' star_target
+static asdl_seq *
+_loop0_119_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' star_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = star_target_rule(p))  // star_target
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_119[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_119_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_118: star_target _loop0_119
+static asdl_seq *
+_gather_118_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // star_target _loop0_119
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_119"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = star_target_rule(p))  // star_target
+            &&
+            (seq = _loop0_119_rule(p))  // _loop0_119
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_118[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target _loop0_119"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_118[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_target _loop0_119"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_120: (',' star_target)
+static asdl_seq *
+_loop1_120_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (',' star_target)
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
+        void *_tmp_149_var;
+        while (
+            (_tmp_149_var = _tmp_149_rule(p))  // ',' star_target
+        )
+        {
+            _res = _tmp_149_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_120[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(',' star_target)"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_120_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_121: !'*' star_target
+static void *
+_tmp_121_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // !'*' star_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
+        expr_ty star_target_var;
+        if (
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16)  // token='*'
+            &&
+            (star_target_var = star_target_rule(p))  // star_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_121[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
+            _res = star_target_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_121[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "!'*' star_target"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_123: ',' del_target
+static asdl_seq *
+_loop0_123_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // ',' del_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target"));
+        Token * _literal;
+        expr_ty elem;
+        while (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (elem = del_target_rule(p))  // del_target
+        )
+        {
+            _res = elem;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                PyMem_Free(_children);
+                p->level--;
+                return NULL;
+            }
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_123[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' del_target"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _gather_122: del_target _loop0_123
+static asdl_seq *
+_gather_122_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    asdl_seq * _res = NULL;
+    int _mark = p->mark;
+    { // del_target _loop0_123
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _gather_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_123"));
+        expr_ty elem;
+        asdl_seq * seq;
+        if (
+            (elem = del_target_rule(p))  // del_target
+            &&
+            (seq = _loop0_123_rule(p))  // _loop0_123
+        )
+        {
+            D(fprintf(stderr, "%*c+ _gather_122[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "del_target _loop0_123"));
+            _res = _PyPegen_seq_insert_in_front(p, elem, seq);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _gather_122[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "del_target _loop0_123"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_124: args | expression for_if_clauses
+static void *
+_tmp_124_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // args
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args"));
+        expr_ty args_var;
+        if (
+            (args_var = args_rule(p))  // args
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "args"));
+            _res = args_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "args"));
+    }
+    { // expression for_if_clauses
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses"));
+        expr_ty expression_var;
+        asdl_seq* for_if_clauses_var;
+        if (
+            (expression_var = expression_rule(p))  // expression
+            &&
+            (for_if_clauses_var = for_if_clauses_rule(p))  // for_if_clauses
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_124[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses"));
+            _res = _PyPegen_dummy_name(p, expression_var, for_if_clauses_var);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_124[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "expression for_if_clauses"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_125: NAME '='
+static void *
+_tmp_125_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // NAME '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='"));
+        Token * _literal;
+        expr_ty name_var;
+        if (
+            (name_var = _PyPegen_name_token(p))  // NAME
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_125[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '='"));
+            _res = _PyPegen_dummy_name(p, name_var, _literal);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_125[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME '='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_126: star_named_expressions
+static asdl_seq *
+_loop0_126_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // star_named_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions"));
+        asdl_seq* star_named_expressions_var;
+        while (
+            (star_named_expressions_var = star_named_expressions_rule(p))  // star_named_expressions
+        )
+        {
+            _res = star_named_expressions_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_126[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_named_expressions"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_126_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_127: (star_targets '=')
+static asdl_seq *
+_loop0_127_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (star_targets '=')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
+        void *_tmp_150_var;
+        while (
+            (_tmp_150_var = _tmp_150_rule(p))  // star_targets '='
+        )
+        {
+            _res = _tmp_150_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_127[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop0_128: (star_targets '=')
+static asdl_seq *
+_loop0_128_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // (star_targets '=')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
+        void *_tmp_151_var;
+        while (
+            (_tmp_151_var = _tmp_151_rule(p))  // star_targets '='
+        )
+        {
+            _res = _tmp_151_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_128[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "(star_targets '=')"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_129: yield_expr | star_expressions
+static void *
+_tmp_129_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // yield_expr
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+        expr_ty yield_expr_var;
+        if (
+            (yield_expr_var = yield_expr_rule(p))  // yield_expr
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
+            _res = yield_expr_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "yield_expr"));
+    }
+    { // star_expressions
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+        expr_ty star_expressions_var;
+        if (
+            (star_expressions_var = star_expressions_rule(p))  // star_expressions
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_129[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
+            _res = star_expressions_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_129[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_expressions"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_130: '[' | '(' | '{'
+static void *
+_tmp_130_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '['
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 9))  // token='['
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'['"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'['"));
+    }
+    { // '('
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 7))  // token='('
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'('"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'('"));
+    }
+    { // '{'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 25))  // token='{'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_130[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_130[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_131: param_no_default
+static asdl_seq *
+_loop0_131_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
+        arg_ty param_no_default_var;
+        while (
+            (param_no_default_var = param_no_default_rule(p))  // param_no_default
+        )
+        {
+            _res = param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_131[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_131_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_132: slash_with_default | param_with_default+
+static void *
+_tmp_132_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // slash_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
+        SlashWithDefault* slash_with_default_var;
+        if (
+            (slash_with_default_var = slash_with_default_rule(p))  // slash_with_default
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
+            _res = slash_with_default_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "slash_with_default"));
+    }
+    { // param_with_default+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+"));
+        asdl_seq * _loop1_152_var;
+        if (
+            (_loop1_152_var = _loop1_152_rule(p))  // param_with_default+
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_132[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "param_with_default+"));
+            _res = _loop1_152_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_132[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop0_133: lambda_param_no_default
+static asdl_seq *
+_loop0_133_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_no_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
+        arg_ty lambda_param_no_default_var;
+        while (
+            (lambda_param_no_default_var = lambda_param_no_default_rule(p))  // lambda_param_no_default
+        )
+        {
+            _res = lambda_param_no_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop0_133[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_no_default"));
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop0_133_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_134: lambda_slash_with_default | lambda_param_with_default+
+static void *
+_tmp_134_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // lambda_slash_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
+        SlashWithDefault* lambda_slash_with_default_var;
+        if (
+            (lambda_slash_with_default_var = lambda_slash_with_default_rule(p))  // lambda_slash_with_default
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
+            _res = lambda_slash_with_default_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_slash_with_default"));
+    }
+    { // lambda_param_with_default+
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+"));
+        asdl_seq * _loop1_153_var;
+        if (
+            (_loop1_153_var = _loop1_153_rule(p))  // lambda_param_with_default+
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_134[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+"));
+            _res = _loop1_153_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_134[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default+"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_135: ')' | ',' (')' | '**')
+static void *
+_tmp_135_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
+    }
+    { // ',' (')' | '**')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')"));
+        Token * _literal;
+        void *_tmp_154_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_tmp_154_var = _tmp_154_rule(p))  // ')' | '**'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_135[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')"));
+            _res = _PyPegen_dummy_name(p, _literal, _tmp_154_var);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_135[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (')' | '**')"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_136: ':' | ',' (':' | '**')
+static void *
+_tmp_136_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
+    }
+    { // ',' (':' | '**')
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')"));
+        Token * _literal;
+        void *_tmp_155_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (_tmp_155_var = _tmp_155_rule(p))  // ':' | '**'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_136[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')"));
+            _res = _PyPegen_dummy_name(p, _literal, _tmp_155_var);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_136[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' (':' | '**')"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_137: star_targets '='
+static void *
+_tmp_137_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // star_targets '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
+        Token * _literal;
+        expr_ty z;
+        if (
+            (z = star_targets_rule(p))  // star_targets
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_137[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_137[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_138: '.' | '...'
+static void *
+_tmp_138_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '.'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
+    }
+    { // '...'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 52))  // token='...'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_138[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_138[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_139: '.' | '...'
+static void *
+_tmp_139_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '.'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 23))  // token='.'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'.'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'.'"));
+    }
+    { // '...'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 52))  // token='...'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_139[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_139[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'...'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_140: '@' named_expression NEWLINE
+static void *
+_tmp_140_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // '@' named_expression NEWLINE
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
+        Token * _literal;
+        expr_ty f;
+        Token * newline_var;
+        if (
+            (_literal = _PyPegen_expect_token(p, 49))  // token='@'
+            &&
+            (f = named_expression_rule(p))  // named_expression
+            &&
+            (newline_var = _PyPegen_expect_token(p, NEWLINE))  // token='NEWLINE'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_140[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
+            _res = f;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_140[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'@' named_expression NEWLINE"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_141: ',' star_expression
+static void *
+_tmp_141_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ',' star_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
+        Token * _literal;
+        expr_ty c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (c = star_expression_rule(p))  // star_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_141[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
+            _res = c;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_141[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_142: ',' expression
+static void *
+_tmp_142_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ',' expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
+        Token * _literal;
+        expr_ty c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (c = expression_rule(p))  // expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_142[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' expression"));
+            _res = c;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_142[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' expression"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_143: 'or' conjunction
+static void *
+_tmp_143_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'or' conjunction
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
+        Token * _keyword;
+        expr_ty c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 532))  // token='or'
+            &&
+            (c = conjunction_rule(p))  // conjunction
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_143[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
+            _res = c;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_143[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'or' conjunction"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_144: 'and' inversion
+static void *
+_tmp_144_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'and' inversion
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
+        Token * _keyword;
+        expr_ty c;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 533))  // token='and'
+            &&
+            (c = inversion_rule(p))  // inversion
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_144[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
+            _res = c;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_144[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'and' inversion"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_145: 'if' disjunction
+static void *
+_tmp_145_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'if' disjunction
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
+        Token * _keyword;
+        expr_ty z;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 510))  // token='if'
+            &&
+            (z = disjunction_rule(p))  // disjunction
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_145[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_145[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_146: 'if' disjunction
+static void *
+_tmp_146_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // 'if' disjunction
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
+        Token * _keyword;
+        expr_ty z;
+        if (
+            (_keyword = _PyPegen_expect_token(p, 510))  // token='if'
+            &&
+            (z = disjunction_rule(p))  // disjunction
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_146[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
+            _res = z;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_146[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'if' disjunction"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_147: starred_expression | named_expression !'='
+static void *
+_tmp_147_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // starred_expression
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
+        expr_ty starred_expression_var;
+        if (
+            (starred_expression_var = starred_expression_rule(p))  // starred_expression
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "starred_expression"));
+            _res = starred_expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "starred_expression"));
+    }
+    { // named_expression !'='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression !'='"));
+        expr_ty named_expression_var;
+        if (
+            (named_expression_var = named_expression_rule(p))  // named_expression
+            &&
+            _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 22)  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_147[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "named_expression !'='"));
+            _res = named_expression_var;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_147[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "named_expression !'='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_148: ',' star_target
+static void *
+_tmp_148_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ',' star_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
+        Token * _literal;
+        expr_ty c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (c = star_target_rule(p))  // star_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_148[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
+            _res = c;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_148[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_149: ',' star_target
+static void *
+_tmp_149_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ',' star_target
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
+        Token * _literal;
+        expr_ty c;
+        if (
+            (_literal = _PyPegen_expect_token(p, 12))  // token=','
+            &&
+            (c = star_target_rule(p))  // star_target
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_149[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "',' star_target"));
+            _res = c;
+            if (_res == NULL && PyErr_Occurred()) {
+                p->error_indicator = 1;
+                p->level--;
+                return NULL;
+            }
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_149[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "',' star_target"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_150: star_targets '='
+static void *
+_tmp_150_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // star_targets '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
+        Token * _literal;
+        expr_ty star_targets_var;
+        if (
+            (star_targets_var = star_targets_rule(p))  // star_targets
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_150[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
+            _res = _PyPegen_dummy_name(p, star_targets_var, _literal);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_150[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_151: star_targets '='
+static void *
+_tmp_151_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // star_targets '='
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
+        Token * _literal;
+        expr_ty star_targets_var;
+        if (
+            (star_targets_var = star_targets_rule(p))  // star_targets
+            &&
+            (_literal = _PyPegen_expect_token(p, 22))  // token='='
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_151[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
+            _res = _PyPegen_dummy_name(p, star_targets_var, _literal);
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_151[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "star_targets '='"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _loop1_152: param_with_default
+static asdl_seq *
+_loop1_152_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
+        NameDefaultPair* param_with_default_var;
+        while (
+            (param_with_default_var = param_with_default_rule(p))  // param_with_default
+        )
+        {
+            _res = param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_152[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_152_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _loop1_153: lambda_param_with_default
+static asdl_seq *
+_loop1_153_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void *_res = NULL;
+    int _mark = p->mark;
+    int _start_mark = p->mark;
+    void **_children = PyMem_Malloc(sizeof(void *));
+    if (!_children) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    ssize_t _children_capacity = 1;
+    ssize_t _n = 0;
+    { // lambda_param_with_default
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _loop1_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
+        NameDefaultPair* lambda_param_with_default_var;
+        while (
+            (lambda_param_with_default_var = lambda_param_with_default_rule(p))  // lambda_param_with_default
+        )
+        {
+            _res = lambda_param_with_default_var;
+            if (_n == _children_capacity) {
+                _children_capacity *= 2;
+                void **_new_children = PyMem_Realloc(_children, _children_capacity*sizeof(void *));
+                if (!_new_children) {
+                    p->error_indicator = 1;
+                    PyErr_NoMemory();
+                    p->level--;
+                    return NULL;
+                }
+                _children = _new_children;
+            }
+            _children[_n++] = _res;
+            _mark = p->mark;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _loop1_153[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "lambda_param_with_default"));
+    }
+    if (_n == 0 || p->error_indicator) {
+        PyMem_Free(_children);
+        p->level--;
+        return NULL;
+    }
+    asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
+    if (!_seq) {
+        PyMem_Free(_children);
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+        p->level--;
+        return NULL;
+    }
+    for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
+    PyMem_Free(_children);
+    _PyPegen_insert_memo(p, _start_mark, _loop1_153_type, _seq);
+    p->level--;
+    return _seq;
+}
+
+// _tmp_154: ')' | '**'
+static void *
+_tmp_154_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ')'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 8))  // token=')'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "')'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "')'"));
+    }
+    { // '**'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_154[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_154[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+// _tmp_155: ':' | '**'
+static void *
+_tmp_155_rule(Parser *p)
+{
+    if (p->level++ == MAXSTACK) {
+        p->error_indicator = 1;
+        PyErr_NoMemory();
+    }
+    if (p->error_indicator) {
+        p->level--;
+        return NULL;
+    }
+    void * _res = NULL;
+    int _mark = p->mark;
+    { // ':'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 11))  // token=':'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "':'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "':'"));
+    }
+    { // '**'
+        if (p->error_indicator) {
+            p->level--;
+            return NULL;
+        }
+        D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
+        Token * _literal;
+        if (
+            (_literal = _PyPegen_expect_token(p, 35))  // token='**'
+        )
+        {
+            D(fprintf(stderr, "%*c+ _tmp_155[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**'"));
+            _res = _literal;
+            goto done;
+        }
+        p->mark = _mark;
+        D(fprintf(stderr, "%*c%s _tmp_155[%d-%d]: %s failed!\n", p->level, ' ',
+                  p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'**'"));
+    }
+    _res = NULL;
+  done:
+    p->level--;
+    return _res;
+}
+
+void *
+_PyPegen_parse(Parser *p)
+{
+    // Initialize keywords
+    p->keywords = reserved_keywords;
+    p->n_keyword_lists = n_keyword_lists;
+
+    // Run parser
+    void *result = NULL;
+    if (p->start_rule == Py_file_input) {
+        result = file_rule(p);
+    } else if (p->start_rule == Py_single_input) {
+        result = interactive_rule(p);
+    } else if (p->start_rule == Py_eval_input) {
+        result = eval_rule(p);
+    } else if (p->start_rule == Py_func_type_input) {
+        result = func_type_rule(p);
+    } else if (p->start_rule == Py_fstring_input) {
+        result = fstring_rule(p);
+    }
+
+    return result;
+}
+
+// The end
diff --git a/contrib/tools/python3/src/Parser/pegen/parse_string.c b/contrib/tools/python3/src/Parser/pegen/parse_string.c
index 6b113c966b..f1df2c46a6 100644
--- a/contrib/tools/python3/src/Parser/pegen/parse_string.c
+++ b/contrib/tools/python3/src/Parser/pegen/parse_string.c
@@ -1,1229 +1,1229 @@
-#include <stdbool.h> 
- 
-#include <Python.h> 
- 
-#include "../tokenizer.h" 
-#include "pegen.h" 
-#include "parse_string.h" 
- 
-//// STRING HANDLING FUNCTIONS //// 
- 
-// These functions are ported directly from Python/ast.c with some modifications 
-// to account for the use of "Parser *p", the fact that don't have parser nodes 
-// to pass around and the usage of some specialized APIs present only in this 
-// file (like "_PyPegen_raise_syntax_error"). 
- 
-static int 
-warn_invalid_escape_sequence(Parser *p, unsigned char first_invalid_escape_char, Token *t) 
-{ 
-    PyObject *msg = 
-        PyUnicode_FromFormat("invalid escape sequence \\%c", first_invalid_escape_char); 
-    if (msg == NULL) { 
-        return -1; 
-    } 
-    if (PyErr_WarnExplicitObject(PyExc_DeprecationWarning, msg, p->tok->filename, 
-                                 t->lineno, NULL, NULL) < 0) { 
-        if (PyErr_ExceptionMatches(PyExc_DeprecationWarning)) { 
-            /* Replace the DeprecationWarning exception with a SyntaxError 
-               to get a more accurate error report */ 
-            PyErr_Clear(); 
- 
-            /* This is needed, in order for the SyntaxError to point to the token t, 
-               since _PyPegen_raise_error uses p->tokens[p->fill - 1] for the 
-               error location, if p->known_err_token is not set. */ 
-            p->known_err_token = t; 
-            RAISE_SYNTAX_ERROR("invalid escape sequence \\%c", first_invalid_escape_char); 
-        } 
-        Py_DECREF(msg); 
-        return -1; 
-    } 
-    Py_DECREF(msg); 
-    return 0; 
-} 
- 
-static PyObject * 
-decode_utf8(const char **sPtr, const char *end) 
-{ 
-    const char *s; 
-    const char *t; 
-    t = s = *sPtr; 
-    while (s < end && (*s & 0x80)) { 
-        s++; 
-    } 
-    *sPtr = s; 
-    return PyUnicode_DecodeUTF8(t, s - t, NULL); 
-} 
- 
-static PyObject * 
-decode_unicode_with_escapes(Parser *parser, const char *s, size_t len, Token *t) 
-{ 
-    PyObject *v; 
-    PyObject *u; 
-    char *buf; 
-    char *p; 
-    const char *end; 
- 
-    /* check for integer overflow */ 
-    if (len > SIZE_MAX / 6) { 
-        return NULL; 
-    } 
-    /* "ä" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5 
-       "\ä" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */ 
-    u = PyBytes_FromStringAndSize((char *)NULL, len * 6); 
-    if (u == NULL) { 
-        return NULL; 
-    } 
-    p = buf = PyBytes_AsString(u); 
-    if (p == NULL) { 
-        return NULL; 
-    } 
-    end = s + len; 
-    while (s < end) { 
-        if (*s == '\\') { 
-            *p++ = *s++; 
-            if (s >= end || *s & 0x80) { 
-                strcpy(p, "u005c"); 
-                p += 5; 
-                if (s >= end) { 
-                    break; 
-                } 
-            } 
-        } 
-        if (*s & 0x80) { 
-            PyObject *w; 
-            int kind; 
-            void *data; 
-            Py_ssize_t w_len; 
-            Py_ssize_t i; 
-            w = decode_utf8(&s, end); 
-            if (w == NULL) { 
-                Py_DECREF(u); 
-                return NULL; 
-            } 
-            kind = PyUnicode_KIND(w); 
-            data = PyUnicode_DATA(w); 
-            w_len = PyUnicode_GET_LENGTH(w); 
-            for (i = 0; i < w_len; i++) { 
-                Py_UCS4 chr = PyUnicode_READ(kind, data, i); 
-                sprintf(p, "\\U%08x", chr); 
-                p += 10; 
-            } 
-            /* Should be impossible to overflow */ 
-            assert(p - buf <= PyBytes_GET_SIZE(u)); 
-            Py_DECREF(w); 
-        } 
-        else { 
-            *p++ = *s++; 
-        } 
-    } 
-    len = p - buf; 
-    s = buf; 
- 
-    const char *first_invalid_escape; 
-    v = _PyUnicode_DecodeUnicodeEscapeInternal(s, len, NULL, NULL, &first_invalid_escape); 
- 
-    if (v != NULL && first_invalid_escape != NULL) { 
-        if (warn_invalid_escape_sequence(parser, *first_invalid_escape, t) < 0) { 
-            /* We have not decref u before because first_invalid_escape points 
-               inside u. */ 
-            Py_XDECREF(u); 
-            Py_DECREF(v); 
-            return NULL; 
-        } 
-    } 
-    Py_XDECREF(u); 
-    return v; 
-} 
- 
-static PyObject * 
-decode_bytes_with_escapes(Parser *p, const char *s, Py_ssize_t len, Token *t) 
-{ 
-    const char *first_invalid_escape; 
-    PyObject *result = _PyBytes_DecodeEscape(s, len, NULL, &first_invalid_escape); 
-    if (result == NULL) { 
-        return NULL; 
-    } 
- 
-    if (first_invalid_escape != NULL) { 
-        if (warn_invalid_escape_sequence(p, *first_invalid_escape, t) < 0) { 
-            Py_DECREF(result); 
-            return NULL; 
-        } 
-    } 
-    return result; 
-} 
- 
-/* s must include the bracketing quote characters, and r, b, u, 
-   &/or f prefixes (if any), and embedded escape sequences (if any). 
-   _PyPegen_parsestr parses it, and sets *result to decoded Python string object. 
-   If the string is an f-string, set *fstr and *fstrlen to the unparsed 
-   string object.  Return 0 if no errors occurred.  */ 
-int 
-_PyPegen_parsestr(Parser *p, int *bytesmode, int *rawmode, PyObject **result, 
-                  const char **fstr, Py_ssize_t *fstrlen, Token *t) 
-{ 
-    const char *s = PyBytes_AsString(t->bytes); 
-    if (s == NULL) { 
-        return -1; 
-    } 
- 
-    size_t len; 
-    int quote = Py_CHARMASK(*s); 
-    int fmode = 0; 
-    *bytesmode = 0; 
-    *rawmode = 0; 
-    *result = NULL; 
-    *fstr = NULL; 
-    if (Py_ISALPHA(quote)) { 
-        while (!*bytesmode || !*rawmode) { 
-            if (quote == 'b' || quote == 'B') { 
-                quote =(unsigned char)*++s; 
-                *bytesmode = 1; 
-            } 
-            else if (quote == 'u' || quote == 'U') { 
-                quote = (unsigned char)*++s; 
-            } 
-            else if (quote == 'r' || quote == 'R') { 
-                quote = (unsigned char)*++s; 
-                *rawmode = 1; 
-            } 
-            else if (quote == 'f' || quote == 'F') { 
-                quote = (unsigned char)*++s; 
-                fmode = 1; 
-            } 
-            else { 
-                break; 
-            } 
-        } 
-    } 
- 
-    /* fstrings are only allowed in Python 3.6 and greater */ 
-    if (fmode && p->feature_version < 6) { 
-        p->error_indicator = 1; 
-        RAISE_SYNTAX_ERROR("Format strings are only supported in Python 3.6 and greater"); 
-        return -1; 
-    } 
- 
-    if (fmode && *bytesmode) { 
-        PyErr_BadInternalCall(); 
-        return -1; 
-    } 
-    if (quote != '\'' && quote != '\"') { 
-        PyErr_BadInternalCall(); 
-        return -1; 
-    } 
-    /* Skip the leading quote char. */ 
-    s++; 
-    len = strlen(s); 
-    if (len > INT_MAX) { 
-        PyErr_SetString(PyExc_OverflowError, "string to parse is too long"); 
-        return -1; 
-    } 
-    if (s[--len] != quote) { 
-        /* Last quote char must match the first. */ 
-        PyErr_BadInternalCall(); 
-        return -1; 
-    } 
-    if (len >= 4 && s[0] == quote && s[1] == quote) { 
-        /* A triple quoted string. We've already skipped one quote at 
-           the start and one at the end of the string. Now skip the 
-           two at the start. */ 
-        s += 2; 
-        len -= 2; 
-        /* And check that the last two match. */ 
-        if (s[--len] != quote || s[--len] != quote) { 
-            PyErr_BadInternalCall(); 
-            return -1; 
-        } 
-    } 
- 
-    if (fmode) { 
-        /* Just return the bytes. The caller will parse the resulting 
-           string. */ 
-        *fstr = s; 
-        *fstrlen = len; 
-        return 0; 
-    } 
- 
-    /* Not an f-string. */ 
-    /* Avoid invoking escape decoding routines if possible. */ 
-    *rawmode = *rawmode || strchr(s, '\\') == NULL; 
-    if (*bytesmode) { 
-        /* Disallow non-ASCII characters. */ 
-        const char *ch; 
-        for (ch = s; *ch; ch++) { 
-            if (Py_CHARMASK(*ch) >= 0x80) { 
-                RAISE_SYNTAX_ERROR( 
-                                   "bytes can only contain ASCII " 
-                                   "literal characters."); 
-                return -1; 
-            } 
-        } 
-        if (*rawmode) { 
-            *result = PyBytes_FromStringAndSize(s, len); 
-        } 
-        else { 
-            *result = decode_bytes_with_escapes(p, s, len, t); 
-        } 
-    } 
-    else { 
-        if (*rawmode) { 
-            *result = PyUnicode_DecodeUTF8Stateful(s, len, NULL, NULL); 
-        } 
-        else { 
-            *result = decode_unicode_with_escapes(p, s, len, t); 
-        } 
-    } 
-    return *result == NULL ? -1 : 0; 
-} 
- 
- 
- 
-// FSTRING STUFF 
- 
-/* Fix locations for the given node and its children. 
- 
-   `parent` is the enclosing node. 
-   `expr_start` is the starting position of the expression (pointing to the open brace). 
-   `n` is the node which locations are going to be fixed relative to parent. 
-   `expr_str` is the child node's string representation, including braces. 
-*/ 
-static bool 
-fstring_find_expr_location(Token *parent, const char* expr_start, char *expr_str, int *p_lines, int *p_cols) 
-{ 
-    *p_lines = 0; 
-    *p_cols = 0; 
-    assert(expr_start != NULL && *expr_start == '{'); 
-    if (parent && parent->bytes) { 
-        char *parent_str = PyBytes_AsString(parent->bytes); 
-        if (!parent_str) { 
-            return false; 
-        } 
-        // The following is needed, in order to correctly shift the column 
-        // offset, in the case that (disregarding any whitespace) a newline 
-        // immediately follows the opening curly brace of the fstring expression. 
-        bool newline_after_brace = 1; 
-        const char *start = expr_start + 1; 
-        while (start && *start != '}' && *start != '\n') { 
-            if (*start != ' ' && *start != '\t' && *start != '\f') { 
-                newline_after_brace = 0; 
-                break; 
-            } 
-            start++; 
-        } 
- 
-        // Account for the characters from the last newline character to our 
-        // left until the beginning of expr_start. 
-        if (!newline_after_brace) { 
-            start = expr_start; 
-            while (start > parent_str && *start != '\n') { 
-                start--; 
-            } 
-            *p_cols += (int)(expr_start - start); 
-        } 
-        /* adjust the start based on the number of newlines encountered 
-           before the f-string expression */ 
-        for (const char *p = parent_str; p < expr_start; p++) { 
-            if (*p == '\n') { 
-                (*p_lines)++; 
-            } 
-        } 
-    } 
-    return true; 
-} 
- 
- 
-/* Compile this expression in to an expr_ty.  Add parens around the 
-   expression, in order to allow leading spaces in the expression. */ 
-static expr_ty 
-fstring_compile_expr(Parser *p, const char *expr_start, const char *expr_end, 
-                     Token *t) 
-{ 
-    expr_ty expr = NULL; 
-    char *str; 
-    Py_ssize_t len; 
-    const char *s; 
-    expr_ty result = NULL; 
- 
-    assert(expr_end >= expr_start); 
-    assert(*(expr_start-1) == '{'); 
-    assert(*expr_end == '}' || *expr_end == '!' || *expr_end == ':' || 
-           *expr_end == '='); 
- 
-    /* If the substring is all whitespace, it's an error.  We need to catch this 
-       here, and not when we call PyParser_SimpleParseStringFlagsFilename, 
-       because turning the expression '' in to '()' would go from being invalid 
-       to valid. */ 
-    for (s = expr_start; s != expr_end; s++) { 
-        char c = *s; 
-        /* The Python parser ignores only the following whitespace 
-           characters (\r already is converted to \n). */ 
-        if (!(c == ' ' || c == '\t' || c == '\n' || c == '\f')) { 
-            break; 
-        } 
-    } 
-    if (s == expr_end) { 
-        RAISE_SYNTAX_ERROR("f-string: empty expression not allowed"); 
-        return NULL; 
-    } 
- 
-    len = expr_end - expr_start; 
-    /* Allocate 3 extra bytes: open paren, close paren, null byte. */ 
-    str = PyMem_Calloc(len + 3, sizeof(char)); 
-    if (str == NULL) { 
-        PyErr_NoMemory(); 
-        return NULL; 
-    } 
- 
-    // The call to fstring_find_expr_location is responsible for finding the column offset 
-    // the generated AST nodes need to be shifted to the right, which is equal to the number 
-    // of the f-string characters before the expression starts. 
-    memcpy(str+1, expr_start, len); 
-    int lines, cols; 
-    if (!fstring_find_expr_location(t, expr_start-1, str+1, &lines, &cols)) { 
-        PyMem_Free(str); 
-        return NULL; 
-    } 
- 
-    // The parentheses are needed in order to allow for leading whitespace within 
-    // the f-string expression. This consequently gets parsed as a group (see the 
-    // group rule in python.gram). 
-    str[0] = '('; 
-    str[len+1] = ')'; 
- 
-    struct tok_state* tok = PyTokenizer_FromString(str, 1); 
-    if (tok == NULL) { 
-        PyMem_Free(str); 
-        return NULL; 
-    } 
-    Py_INCREF(p->tok->filename); 
-    tok->filename = p->tok->filename; 
- 
-    Parser *p2 = _PyPegen_Parser_New(tok, Py_fstring_input, p->flags, p->feature_version, 
-                                     NULL, p->arena); 
-    p2->starting_lineno = t->lineno + lines - 1; 
-    p2->starting_col_offset = t->col_offset + cols; 
- 
-    expr = _PyPegen_run_parser(p2); 
- 
-    if (expr == NULL) { 
-        goto exit; 
-    } 
-    result = expr; 
- 
-exit: 
-    PyMem_Free(str); 
-    _PyPegen_Parser_Free(p2); 
-    PyTokenizer_Free(tok); 
-    return result; 
-} 
- 
-/* Return -1 on error. 
- 
-   Return 0 if we reached the end of the literal. 
- 
-   Return 1 if we haven't reached the end of the literal, but we want 
-   the caller to process the literal up to this point. Used for 
-   doubled braces. 
-*/ 
-static int 
-fstring_find_literal(Parser *p, const char **str, const char *end, int raw, 
-                     PyObject **literal, int recurse_lvl, Token *t) 
-{ 
-    /* Get any literal string. It ends when we hit an un-doubled left 
-       brace (which isn't part of a unicode name escape such as 
-       "\N{EULER CONSTANT}"), or the end of the string. */ 
- 
-    const char *s = *str; 
-    const char *literal_start = s; 
-    int result = 0; 
- 
-    assert(*literal == NULL); 
-    while (s < end) { 
-        char ch = *s++; 
-        if (!raw && ch == '\\' && s < end) { 
-            ch = *s++; 
-            if (ch == 'N') { 
-                if (s < end && *s++ == '{') { 
-                    while (s < end && *s++ != '}') { 
-                    } 
-                    continue; 
-                } 
-                break; 
-            } 
-            if (ch == '{' && warn_invalid_escape_sequence(p, ch, t) < 0) { 
-                return -1; 
-            } 
-        } 
-        if (ch == '{' || ch == '}') { 
-            /* Check for doubled braces, but only at the top level. If 
-               we checked at every level, then f'{0:{3}}' would fail 
-               with the two closing braces. */ 
-            if (recurse_lvl == 0) { 
-                if (s < end && *s == ch) { 
-                    /* We're going to tell the caller that the literal ends 
-                       here, but that they should continue scanning. But also 
-                       skip over the second brace when we resume scanning. */ 
-                    *str = s + 1; 
-                    result = 1; 
-                    goto done; 
-                } 
- 
-                /* Where a single '{' is the start of a new expression, a 
-                   single '}' is not allowed. */ 
-                if (ch == '}') { 
-                    *str = s - 1; 
-                    RAISE_SYNTAX_ERROR("f-string: single '}' is not allowed"); 
-                    return -1; 
-                } 
-            } 
-            /* We're either at a '{', which means we're starting another 
-               expression; or a '}', which means we're at the end of this 
-               f-string (for a nested format_spec). */ 
-            s--; 
-            break; 
-        } 
-    } 
-    *str = s; 
-    assert(s <= end); 
-    assert(s == end || *s == '{' || *s == '}'); 
-done: 
-    if (literal_start != s) { 
-        if (raw) { 
-            *literal = PyUnicode_DecodeUTF8Stateful(literal_start, 
-                                                    s - literal_start, 
-                                                    NULL, NULL); 
-        } else { 
-            *literal = decode_unicode_with_escapes(p, literal_start, 
-                                                   s - literal_start, t); 
-        } 
-        if (!*literal) { 
-            return -1; 
-        } 
-    } 
-    return result; 
-} 
- 
-/* Forward declaration because parsing is recursive. */ 
-static expr_ty 
-fstring_parse(Parser *p, const char **str, const char *end, int raw, int recurse_lvl, 
-              Token *first_token, Token* t, Token *last_token); 
- 
-/* Parse the f-string at *str, ending at end.  We know *str starts an 
-   expression (so it must be a '{'). Returns the FormattedValue node, which 
-   includes the expression, conversion character, format_spec expression, and 
-   optionally the text of the expression (if = is used). 
- 
-   Note that I don't do a perfect job here: I don't make sure that a 
-   closing brace doesn't match an opening paren, for example. It 
-   doesn't need to error on all invalid expressions, just correctly 
-   find the end of all valid ones. Any errors inside the expression 
-   will be caught when we parse it later. 
- 
-   *expression is set to the expression.  For an '=' "debug" expression, 
-   *expr_text is set to the debug text (the original text of the expression, 
-   including the '=' and any whitespace around it, as a string object).  If 
-   not a debug expression, *expr_text set to NULL. */ 
-static int 
-fstring_find_expr(Parser *p, const char **str, const char *end, int raw, int recurse_lvl, 
-                  PyObject **expr_text, expr_ty *expression, Token *first_token, 
-                  Token *t, Token *last_token) 
-{ 
-    /* Return -1 on error, else 0. */ 
- 
-    const char *expr_start; 
-    const char *expr_end; 
-    expr_ty simple_expression; 
-    expr_ty format_spec = NULL; /* Optional format specifier. */ 
-    int conversion = -1; /* The conversion char.  Use default if not 
-                            specified, or !r if using = and no format 
-                            spec. */ 
- 
-    /* 0 if we're not in a string, else the quote char we're trying to 
-       match (single or double quote). */ 
-    char quote_char = 0; 
- 
-    /* If we're inside a string, 1=normal, 3=triple-quoted. */ 
-    int string_type = 0; 
- 
-    /* Keep track of nesting level for braces/parens/brackets in 
-       expressions. */ 
-    Py_ssize_t nested_depth = 0; 
-    char parenstack[MAXLEVEL]; 
- 
-    *expr_text = NULL; 
- 
-    /* Can only nest one level deep. */ 
-    if (recurse_lvl >= 2) { 
-        RAISE_SYNTAX_ERROR("f-string: expressions nested too deeply"); 
-        goto error; 
-    } 
- 
-    /* The first char must be a left brace, or we wouldn't have gotten 
-       here. Skip over it. */ 
-    assert(**str == '{'); 
-    *str += 1; 
- 
-    expr_start = *str; 
-    for (; *str < end; (*str)++) { 
-        char ch; 
- 
-        /* Loop invariants. */ 
-        assert(nested_depth >= 0); 
-        assert(*str >= expr_start && *str < end); 
-        if (quote_char) { 
-            assert(string_type == 1 || string_type == 3); 
-        } else { 
-            assert(string_type == 0); 
-        } 
- 
-        ch = **str; 
-        /* Nowhere inside an expression is a backslash allowed. */ 
-        if (ch == '\\') { 
-            /* Error: can't include a backslash character, inside 
-               parens or strings or not. */ 
-            RAISE_SYNTAX_ERROR( 
-                      "f-string expression part " 
-                      "cannot include a backslash"); 
-            goto error; 
-        } 
-        if (quote_char) { 
-            /* We're inside a string. See if we're at the end. */ 
-            /* This code needs to implement the same non-error logic 
-               as tok_get from tokenizer.c, at the letter_quote 
-               label. To actually share that code would be a 
-               nightmare. But, it's unlikely to change and is small, 
-               so duplicate it here. Note we don't need to catch all 
-               of the errors, since they'll be caught when parsing the 
-               expression. We just need to match the non-error 
-               cases. Thus we can ignore \n in single-quoted strings, 
-               for example. Or non-terminated strings. */ 
-            if (ch == quote_char) { 
-                /* Does this match the string_type (single or triple 
-                   quoted)? */ 
-                if (string_type == 3) { 
-                    if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) { 
-                        /* We're at the end of a triple quoted string. */ 
-                        *str += 2; 
-                        string_type = 0; 
-                        quote_char = 0; 
-                        continue; 
-                    } 
-                } else { 
-                    /* We're at the end of a normal string. */ 
-                    quote_char = 0; 
-                    string_type = 0; 
-                    continue; 
-                } 
-            } 
-        } else if (ch == '\'' || ch == '"') { 
-            /* Is this a triple quoted string? */ 
-            if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) { 
-                string_type = 3; 
-                *str += 2; 
-            } else { 
-                /* Start of a normal string. */ 
-                string_type = 1; 
-            } 
-            /* Start looking for the end of the string. */ 
-            quote_char = ch; 
-        } else if (ch == '[' || ch == '{' || ch == '(') { 
-            if (nested_depth >= MAXLEVEL) { 
-                RAISE_SYNTAX_ERROR("f-string: too many nested parenthesis"); 
-                goto error; 
-            } 
-            parenstack[nested_depth] = ch; 
-            nested_depth++; 
-        } else if (ch == '#') { 
-            /* Error: can't include a comment character, inside parens 
-               or not. */ 
-            RAISE_SYNTAX_ERROR("f-string expression part cannot include '#'"); 
-            goto error; 
-        } else if (nested_depth == 0 && 
-                   (ch == '!' || ch == ':' || ch == '}' || 
-                    ch == '=' || ch == '>' || ch == '<')) { 
-            /* See if there's a next character. */ 
-            if (*str+1 < end) { 
-                char next = *(*str+1); 
- 
-                /* For "!=". since '=' is not an allowed conversion character, 
-                   nothing is lost in this test. */ 
-                if ((ch == '!' && next == '=') ||   /* != */ 
-                    (ch == '=' && next == '=') ||   /* == */ 
-                    (ch == '<' && next == '=') ||   /* <= */ 
-                    (ch == '>' && next == '=')      /* >= */ 
-                    ) { 
-                    *str += 1; 
-                    continue; 
-                } 
-                /* Don't get out of the loop for these, if they're single 
-                   chars (not part of 2-char tokens). If by themselves, they 
-                   don't end an expression (unlike say '!'). */ 
-                if (ch == '>' || ch == '<') { 
-                    continue; 
-                } 
-            } 
- 
-            /* Normal way out of this loop. */ 
-            break; 
-        } else if (ch == ']' || ch == '}' || ch == ')') { 
-            if (!nested_depth) { 
-                RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", ch); 
-                goto error; 
-            } 
-            nested_depth--; 
-            int opening = (unsigned char)parenstack[nested_depth]; 
-            if (!((opening == '(' && ch == ')') || 
-                  (opening == '[' && ch == ']') || 
-                  (opening == '{' && ch == '}'))) 
-            { 
-                RAISE_SYNTAX_ERROR( 
-                          "f-string: closing parenthesis '%c' " 
-                          "does not match opening parenthesis '%c'", 
-                          ch, opening); 
-                goto error; 
-            } 
-        } else { 
-            /* Just consume this char and loop around. */ 
-        } 
-    } 
-    expr_end = *str; 
-    /* If we leave this loop in a string or with mismatched parens, we 
-       don't care. We'll get a syntax error when compiling the 
-       expression. But, we can produce a better error message, so 
-       let's just do that.*/ 
-    if (quote_char) { 
-        RAISE_SYNTAX_ERROR("f-string: unterminated string"); 
-        goto error; 
-    } 
-    if (nested_depth) { 
-        int opening = (unsigned char)parenstack[nested_depth - 1]; 
-        RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", opening); 
-        goto error; 
-    } 
- 
-    if (*str >= end) { 
-        goto unexpected_end_of_string; 
-    } 
- 
-    /* Compile the expression as soon as possible, so we show errors 
-       related to the expression before errors related to the 
-       conversion or format_spec. */ 
-    simple_expression = fstring_compile_expr(p, expr_start, expr_end, t); 
-    if (!simple_expression) { 
-        goto error; 
-    } 
- 
-    /* Check for =, which puts the text value of the expression in 
-       expr_text. */ 
-    if (**str == '=') { 
-        if (p->feature_version < 8) { 
-            RAISE_SYNTAX_ERROR("f-string: self documenting expressions are " 
-                               "only supported in Python 3.8 and greater"); 
-            goto error; 
-        } 
-        *str += 1; 
- 
-        /* Skip over ASCII whitespace.  No need to test for end of string 
-           here, since we know there's at least a trailing quote somewhere 
-           ahead. */ 
-        while (Py_ISSPACE(**str)) { 
-            *str += 1; 
-        } 
- 
-        /* Set *expr_text to the text of the expression. */ 
-        *expr_text = PyUnicode_FromStringAndSize(expr_start, *str-expr_start); 
-        if (!*expr_text) { 
-            goto error; 
-        } 
-    } 
- 
-    /* Check for a conversion char, if present. */ 
-    if (**str == '!') { 
-        *str += 1; 
-        if (*str >= end) { 
-            goto unexpected_end_of_string; 
-        } 
- 
-        conversion = (unsigned char)**str; 
-        *str += 1; 
- 
-        /* Validate the conversion. */ 
-        if (!(conversion == 's' || conversion == 'r' || conversion == 'a')) { 
-            RAISE_SYNTAX_ERROR( 
-                      "f-string: invalid conversion character: " 
-                      "expected 's', 'r', or 'a'"); 
-            goto error; 
-        } 
- 
-    } 
- 
-    /* Check for the format spec, if present. */ 
-    if (*str >= end) { 
-        goto unexpected_end_of_string; 
-    } 
-    if (**str == ':') { 
-        *str += 1; 
-        if (*str >= end) { 
-            goto unexpected_end_of_string; 
-        } 
- 
-        /* Parse the format spec. */ 
-        format_spec = fstring_parse(p, str, end, raw, recurse_lvl+1, 
-                                    first_token, t, last_token); 
-        if (!format_spec) { 
-            goto error; 
-        } 
-    } 
- 
-    if (*str >= end || **str != '}') { 
-        goto unexpected_end_of_string; 
-    } 
- 
-    /* We're at a right brace. Consume it. */ 
-    assert(*str < end); 
-    assert(**str == '}'); 
-    *str += 1; 
- 
-    /* If we're in = mode (detected by non-NULL expr_text), and have no format 
-       spec and no explicit conversion, set the conversion to 'r'. */ 
-    if (*expr_text && format_spec == NULL && conversion == -1) { 
-        conversion = 'r'; 
-    } 
- 
-    /* And now create the FormattedValue node that represents this 
-       entire expression with the conversion and format spec. */ 
-    //TODO: Fix this 
-    *expression = FormattedValue(simple_expression, conversion, 
-                                 format_spec, first_token->lineno, 
-                                 first_token->col_offset, last_token->end_lineno, 
-                                 last_token->end_col_offset, p->arena); 
-    if (!*expression) { 
-        goto error; 
-    } 
- 
-    return 0; 
- 
-unexpected_end_of_string: 
-    RAISE_SYNTAX_ERROR("f-string: expecting '}'"); 
-    /* Falls through to error. */ 
- 
-error: 
-    Py_XDECREF(*expr_text); 
-    return -1; 
- 
-} 
- 
-/* Return -1 on error. 
- 
-   Return 0 if we have a literal (possible zero length) and an 
-   expression (zero length if at the end of the string. 
- 
-   Return 1 if we have a literal, but no expression, and we want the 
-   caller to call us again. This is used to deal with doubled 
-   braces. 
- 
-   When called multiple times on the string 'a{{b{0}c', this function 
-   will return: 
- 
-   1. the literal 'a{' with no expression, and a return value 
-      of 1. Despite the fact that there's no expression, the return 
-      value of 1 means we're not finished yet. 
- 
-   2. the literal 'b' and the expression '0', with a return value of 
-      0. The fact that there's an expression means we're not finished. 
- 
-   3. literal 'c' with no expression and a return value of 0. The 
-      combination of the return value of 0 with no expression means 
-      we're finished. 
-*/ 
-static int 
-fstring_find_literal_and_expr(Parser *p, const char **str, const char *end, int raw, 
-                              int recurse_lvl, PyObject **literal, 
-                              PyObject **expr_text, expr_ty *expression, 
-                              Token *first_token, Token *t, Token *last_token) 
-{ 
-    int result; 
- 
-    assert(*literal == NULL && *expression == NULL); 
- 
-    /* Get any literal string. */ 
-    result = fstring_find_literal(p, str, end, raw, literal, recurse_lvl, t); 
-    if (result < 0) { 
-        goto error; 
-    } 
- 
-    assert(result == 0 || result == 1); 
- 
-    if (result == 1) { 
-        /* We have a literal, but don't look at the expression. */ 
-        return 1; 
-    } 
- 
-    if (*str >= end || **str == '}') { 
-        /* We're at the end of the string or the end of a nested 
-           f-string: no expression. The top-level error case where we 
-           expect to be at the end of the string but we're at a '}' is 
-           handled later. */ 
-        return 0; 
-    } 
- 
-    /* We must now be the start of an expression, on a '{'. */ 
-    assert(**str == '{'); 
- 
-    if (fstring_find_expr(p, str, end, raw, recurse_lvl, expr_text, 
-                          expression, first_token, t, last_token) < 0) { 
-        goto error; 
-    } 
- 
-    return 0; 
- 
-error: 
-    Py_CLEAR(*literal); 
-    return -1; 
-} 
- 
-#ifdef NDEBUG 
-#define ExprList_check_invariants(l) 
-#else 
-static void 
-ExprList_check_invariants(ExprList *l) 
-{ 
-    /* Check our invariants. Make sure this object is "live", and 
-       hasn't been deallocated. */ 
-    assert(l->size >= 0); 
-    assert(l->p != NULL); 
-    if (l->size <= EXPRLIST_N_CACHED) { 
-        assert(l->data == l->p); 
-    } 
-} 
-#endif 
- 
-static void 
-ExprList_Init(ExprList *l) 
-{ 
-    l->allocated = EXPRLIST_N_CACHED; 
-    l->size = 0; 
- 
-    /* Until we start allocating dynamically, p points to data. */ 
-    l->p = l->data; 
- 
-    ExprList_check_invariants(l); 
-} 
- 
-static int 
-ExprList_Append(ExprList *l, expr_ty exp) 
-{ 
-    ExprList_check_invariants(l); 
-    if (l->size >= l->allocated) { 
-        /* We need to alloc (or realloc) the memory. */ 
-        Py_ssize_t new_size = l->allocated * 2; 
- 
-        /* See if we've ever allocated anything dynamically. */ 
-        if (l->p == l->data) { 
-            Py_ssize_t i; 
-            /* We're still using the cached data. Switch to 
-               alloc-ing. */ 
-            l->p = PyMem_Malloc(sizeof(expr_ty) * new_size); 
-            if (!l->p) { 
-                return -1; 
-            } 
-            /* Copy the cached data into the new buffer. */ 
-            for (i = 0; i < l->size; i++) { 
-                l->p[i] = l->data[i]; 
-            } 
-        } else { 
-            /* Just realloc. */ 
-            expr_ty *tmp = PyMem_Realloc(l->p, sizeof(expr_ty) * new_size); 
-            if (!tmp) { 
-                PyMem_Free(l->p); 
-                l->p = NULL; 
-                return -1; 
-            } 
-            l->p = tmp; 
-        } 
- 
-        l->allocated = new_size; 
-        assert(l->allocated == 2 * l->size); 
-    } 
- 
-    l->p[l->size++] = exp; 
- 
-    ExprList_check_invariants(l); 
-    return 0; 
-} 
- 
-static void 
-ExprList_Dealloc(ExprList *l) 
-{ 
-    ExprList_check_invariants(l); 
- 
-    /* If there's been an error, or we've never dynamically allocated, 
-       do nothing. */ 
-    if (!l->p || l->p == l->data) { 
-        /* Do nothing. */ 
-    } else { 
-        /* We have dynamically allocated. Free the memory. */ 
-        PyMem_Free(l->p); 
-    } 
-    l->p = NULL; 
-    l->size = -1; 
-} 
- 
-static asdl_seq * 
-ExprList_Finish(ExprList *l, PyArena *arena) 
-{ 
-    asdl_seq *seq; 
- 
-    ExprList_check_invariants(l); 
- 
-    /* Allocate the asdl_seq and copy the expressions in to it. */ 
-    seq = _Py_asdl_seq_new(l->size, arena); 
-    if (seq) { 
-        Py_ssize_t i; 
-        for (i = 0; i < l->size; i++) { 
-            asdl_seq_SET(seq, i, l->p[i]); 
-        } 
-    } 
-    ExprList_Dealloc(l); 
-    return seq; 
-} 
- 
-#ifdef NDEBUG 
-#define FstringParser_check_invariants(state) 
-#else 
-static void 
-FstringParser_check_invariants(FstringParser *state) 
-{ 
-    if (state->last_str) { 
-        assert(PyUnicode_CheckExact(state->last_str)); 
-    } 
-    ExprList_check_invariants(&state->expr_list); 
-} 
-#endif 
- 
-void 
-_PyPegen_FstringParser_Init(FstringParser *state) 
-{ 
-    state->last_str = NULL; 
-    state->fmode = 0; 
-    ExprList_Init(&state->expr_list); 
-    FstringParser_check_invariants(state); 
-} 
- 
-void 
-_PyPegen_FstringParser_Dealloc(FstringParser *state) 
-{ 
-    FstringParser_check_invariants(state); 
- 
-    Py_XDECREF(state->last_str); 
-    ExprList_Dealloc(&state->expr_list); 
-} 
- 
-/* Make a Constant node, but decref the PyUnicode object being added. */ 
-static expr_ty 
-make_str_node_and_del(Parser *p, PyObject **str, Token* first_token, Token *last_token) 
-{ 
-    PyObject *s = *str; 
-    PyObject *kind = NULL; 
-    *str = NULL; 
-    assert(PyUnicode_CheckExact(s)); 
-    if (PyArena_AddPyObject(p->arena, s) < 0) { 
-        Py_DECREF(s); 
-        return NULL; 
-    } 
-    const char* the_str = PyBytes_AsString(first_token->bytes); 
-    if (the_str && the_str[0] == 'u') { 
-        kind = _PyPegen_new_identifier(p, "u"); 
-    } 
- 
-    if (kind == NULL && PyErr_Occurred()) { 
-        return NULL; 
-    } 
- 
-    return Constant(s, kind, first_token->lineno, first_token->col_offset, 
-                    last_token->end_lineno, last_token->end_col_offset, p->arena); 
- 
-} 
- 
- 
-/* Add a non-f-string (that is, a regular literal string). str is 
-   decref'd. */ 
-int 
-_PyPegen_FstringParser_ConcatAndDel(FstringParser *state, PyObject *str) 
-{ 
-    FstringParser_check_invariants(state); 
- 
-    assert(PyUnicode_CheckExact(str)); 
- 
-    if (PyUnicode_GET_LENGTH(str) == 0) { 
-        Py_DECREF(str); 
-        return 0; 
-    } 
- 
-    if (!state->last_str) { 
-        /* We didn't have a string before, so just remember this one. */ 
-        state->last_str = str; 
-    } else { 
-        /* Concatenate this with the previous string. */ 
-        PyUnicode_AppendAndDel(&state->last_str, str); 
-        if (!state->last_str) { 
-            return -1; 
-        } 
-    } 
-    FstringParser_check_invariants(state); 
-    return 0; 
-} 
- 
-/* Parse an f-string. The f-string is in *str to end, with no 
-   'f' or quotes. */ 
-int 
-_PyPegen_FstringParser_ConcatFstring(Parser *p, FstringParser *state, const char **str, 
-                            const char *end, int raw, int recurse_lvl, 
-                            Token *first_token, Token* t, Token *last_token) 
-{ 
-    FstringParser_check_invariants(state); 
-    state->fmode = 1; 
- 
-    /* Parse the f-string. */ 
-    while (1) { 
-        PyObject *literal = NULL; 
-        PyObject *expr_text = NULL; 
-        expr_ty expression = NULL; 
- 
-        /* If there's a zero length literal in front of the 
-           expression, literal will be NULL. If we're at the end of 
-           the f-string, expression will be NULL (unless result == 1, 
-           see below). */ 
-        int result = fstring_find_literal_and_expr(p, str, end, raw, recurse_lvl, 
-                                                   &literal, &expr_text, 
-                                                   &expression, first_token, t, last_token); 
-        if (result < 0) { 
-            return -1; 
-        } 
- 
-        /* Add the literal, if any. */ 
-        if (literal && _PyPegen_FstringParser_ConcatAndDel(state, literal) < 0) { 
-            Py_XDECREF(expr_text); 
-            return -1; 
-        } 
-        /* Add the expr_text, if any. */ 
-        if (expr_text && _PyPegen_FstringParser_ConcatAndDel(state, expr_text) < 0) { 
-            return -1; 
-        } 
- 
-        /* We've dealt with the literal and expr_text, their ownership has 
-           been transferred to the state object.  Don't look at them again. */ 
- 
-        /* See if we should just loop around to get the next literal 
-           and expression, while ignoring the expression this 
-           time. This is used for un-doubling braces, as an 
-           optimization. */ 
-        if (result == 1) { 
-            continue; 
-        } 
- 
-        if (!expression) { 
-            /* We're done with this f-string. */ 
-            break; 
-        } 
- 
-        /* We know we have an expression. Convert any existing string 
-           to a Constant node. */ 
-        if (!state->last_str) { 
-            /* Do nothing. No previous literal. */ 
-        } else { 
-            /* Convert the existing last_str literal to a Constant node. */ 
-            expr_ty last_str = make_str_node_and_del(p, &state->last_str, first_token, last_token); 
-            if (!last_str || ExprList_Append(&state->expr_list, last_str) < 0) { 
-                return -1; 
-            } 
-        } 
- 
-        if (ExprList_Append(&state->expr_list, expression) < 0) { 
-            return -1; 
-        } 
-    } 
- 
-    /* If recurse_lvl is zero, then we must be at the end of the 
-       string. Otherwise, we must be at a right brace. */ 
- 
-    if (recurse_lvl == 0 && *str < end-1) { 
-        RAISE_SYNTAX_ERROR("f-string: unexpected end of string"); 
-        return -1; 
-    } 
-    if (recurse_lvl != 0 && **str != '}') { 
-        RAISE_SYNTAX_ERROR("f-string: expecting '}'"); 
-        return -1; 
-    } 
- 
-    FstringParser_check_invariants(state); 
-    return 0; 
-} 
- 
-/* Convert the partial state reflected in last_str and expr_list to an 
-   expr_ty. The expr_ty can be a Constant, or a JoinedStr. */ 
-expr_ty 
-_PyPegen_FstringParser_Finish(Parser *p, FstringParser *state, Token* first_token, 
-                     Token *last_token) 
-{ 
-    asdl_seq *seq; 
- 
-    FstringParser_check_invariants(state); 
- 
-    /* If we're just a constant string with no expressions, return 
-       that. */ 
-    if (!state->fmode) { 
-        assert(!state->expr_list.size); 
-        if (!state->last_str) { 
-            /* Create a zero length string. */ 
-            state->last_str = PyUnicode_FromStringAndSize(NULL, 0); 
-            if (!state->last_str) { 
-                goto error; 
-            } 
-        } 
-        return make_str_node_and_del(p, &state->last_str, first_token, last_token); 
-    } 
- 
-    /* Create a Constant node out of last_str, if needed. It will be the 
-       last node in our expression list. */ 
-    if (state->last_str) { 
-        expr_ty str = make_str_node_and_del(p, &state->last_str, first_token, last_token); 
-        if (!str || ExprList_Append(&state->expr_list, str) < 0) { 
-            goto error; 
-        } 
-    } 
-    /* This has already been freed. */ 
-    assert(state->last_str == NULL); 
- 
-    seq = ExprList_Finish(&state->expr_list, p->arena); 
-    if (!seq) { 
-        goto error; 
-    } 
- 
-    return _Py_JoinedStr(seq, first_token->lineno, first_token->col_offset, 
-                         last_token->end_lineno, last_token->end_col_offset, p->arena); 
- 
-error: 
-    _PyPegen_FstringParser_Dealloc(state); 
-    return NULL; 
-} 
- 
-/* Given an f-string (with no 'f' or quotes) that's in *str and ends 
-   at end, parse it into an expr_ty.  Return NULL on error.  Adjust 
-   str to point past the parsed portion. */ 
-static expr_ty 
-fstring_parse(Parser *p, const char **str, const char *end, int raw, 
-              int recurse_lvl, Token *first_token, Token* t, Token *last_token) 
-{ 
-    FstringParser state; 
- 
-    _PyPegen_FstringParser_Init(&state); 
-    if (_PyPegen_FstringParser_ConcatFstring(p, &state, str, end, raw, recurse_lvl, 
-                                    first_token, t, last_token) < 0) { 
-        _PyPegen_FstringParser_Dealloc(&state); 
-        return NULL; 
-    } 
- 
-    return _PyPegen_FstringParser_Finish(p, &state, t, t); 
-} 
+#include <stdbool.h>
+
+#include <Python.h>
+
+#include "../tokenizer.h"
+#include "pegen.h"
+#include "parse_string.h"
+
+//// STRING HANDLING FUNCTIONS ////
+
+// These functions are ported directly from Python/ast.c with some modifications
+// to account for the use of "Parser *p", the fact that don't have parser nodes
+// to pass around and the usage of some specialized APIs present only in this
+// file (like "_PyPegen_raise_syntax_error").
+
+static int
+warn_invalid_escape_sequence(Parser *p, unsigned char first_invalid_escape_char, Token *t)
+{
+    PyObject *msg =
+        PyUnicode_FromFormat("invalid escape sequence \\%c", first_invalid_escape_char);
+    if (msg == NULL) {
+        return -1;
+    }
+    if (PyErr_WarnExplicitObject(PyExc_DeprecationWarning, msg, p->tok->filename,
+                                 t->lineno, NULL, NULL) < 0) {
+        if (PyErr_ExceptionMatches(PyExc_DeprecationWarning)) {
+            /* Replace the DeprecationWarning exception with a SyntaxError
+               to get a more accurate error report */
+            PyErr_Clear();
+
+            /* This is needed, in order for the SyntaxError to point to the token t,
+               since _PyPegen_raise_error uses p->tokens[p->fill - 1] for the
+               error location, if p->known_err_token is not set. */
+            p->known_err_token = t;
+            RAISE_SYNTAX_ERROR("invalid escape sequence \\%c", first_invalid_escape_char);
+        }
+        Py_DECREF(msg);
+        return -1;
+    }
+    Py_DECREF(msg);
+    return 0;
+}
+
+static PyObject *
+decode_utf8(const char **sPtr, const char *end)
+{
+    const char *s;
+    const char *t;
+    t = s = *sPtr;
+    while (s < end && (*s & 0x80)) {
+        s++;
+    }
+    *sPtr = s;
+    return PyUnicode_DecodeUTF8(t, s - t, NULL);
+}
+
+static PyObject *
+decode_unicode_with_escapes(Parser *parser, const char *s, size_t len, Token *t)
+{
+    PyObject *v;
+    PyObject *u;
+    char *buf;
+    char *p;
+    const char *end;
+
+    /* check for integer overflow */
+    if (len > SIZE_MAX / 6) {
+        return NULL;
+    }
+    /* "ä" (2 bytes) may become "\U000000E4" (10 bytes), or 1:5
+       "\ä" (3 bytes) may become "\u005c\U000000E4" (16 bytes), or ~1:6 */
+    u = PyBytes_FromStringAndSize((char *)NULL, len * 6);
+    if (u == NULL) {
+        return NULL;
+    }
+    p = buf = PyBytes_AsString(u);
+    if (p == NULL) {
+        return NULL;
+    }
+    end = s + len;
+    while (s < end) {
+        if (*s == '\\') {
+            *p++ = *s++;
+            if (s >= end || *s & 0x80) {
+                strcpy(p, "u005c");
+                p += 5;
+                if (s >= end) {
+                    break;
+                }
+            }
+        }
+        if (*s & 0x80) {
+            PyObject *w;
+            int kind;
+            void *data;
+            Py_ssize_t w_len;
+            Py_ssize_t i;
+            w = decode_utf8(&s, end);
+            if (w == NULL) {
+                Py_DECREF(u);
+                return NULL;
+            }
+            kind = PyUnicode_KIND(w);
+            data = PyUnicode_DATA(w);
+            w_len = PyUnicode_GET_LENGTH(w);
+            for (i = 0; i < w_len; i++) {
+                Py_UCS4 chr = PyUnicode_READ(kind, data, i);
+                sprintf(p, "\\U%08x", chr);
+                p += 10;
+            }
+            /* Should be impossible to overflow */
+            assert(p - buf <= PyBytes_GET_SIZE(u));
+            Py_DECREF(w);
+        }
+        else {
+            *p++ = *s++;
+        }
+    }
+    len = p - buf;
+    s = buf;
+
+    const char *first_invalid_escape;
+    v = _PyUnicode_DecodeUnicodeEscapeInternal(s, len, NULL, NULL, &first_invalid_escape);
+
+    if (v != NULL && first_invalid_escape != NULL) {
+        if (warn_invalid_escape_sequence(parser, *first_invalid_escape, t) < 0) {
+            /* We have not decref u before because first_invalid_escape points
+               inside u. */
+            Py_XDECREF(u);
+            Py_DECREF(v);
+            return NULL;
+        }
+    }
+    Py_XDECREF(u);
+    return v;
+}
+
+static PyObject *
+decode_bytes_with_escapes(Parser *p, const char *s, Py_ssize_t len, Token *t)
+{
+    const char *first_invalid_escape;
+    PyObject *result = _PyBytes_DecodeEscape(s, len, NULL, &first_invalid_escape);
+    if (result == NULL) {
+        return NULL;
+    }
+
+    if (first_invalid_escape != NULL) {
+        if (warn_invalid_escape_sequence(p, *first_invalid_escape, t) < 0) {
+            Py_DECREF(result);
+            return NULL;
+        }
+    }
+    return result;
+}
+
+/* s must include the bracketing quote characters, and r, b, u,
+   &/or f prefixes (if any), and embedded escape sequences (if any).
+   _PyPegen_parsestr parses it, and sets *result to decoded Python string object.
+   If the string is an f-string, set *fstr and *fstrlen to the unparsed
+   string object.  Return 0 if no errors occurred.  */
+int
+_PyPegen_parsestr(Parser *p, int *bytesmode, int *rawmode, PyObject **result,
+                  const char **fstr, Py_ssize_t *fstrlen, Token *t)
+{
+    const char *s = PyBytes_AsString(t->bytes);
+    if (s == NULL) {
+        return -1;
+    }
+
+    size_t len;
+    int quote = Py_CHARMASK(*s);
+    int fmode = 0;
+    *bytesmode = 0;
+    *rawmode = 0;
+    *result = NULL;
+    *fstr = NULL;
+    if (Py_ISALPHA(quote)) {
+        while (!*bytesmode || !*rawmode) {
+            if (quote == 'b' || quote == 'B') {
+                quote =(unsigned char)*++s;
+                *bytesmode = 1;
+            }
+            else if (quote == 'u' || quote == 'U') {
+                quote = (unsigned char)*++s;
+            }
+            else if (quote == 'r' || quote == 'R') {
+                quote = (unsigned char)*++s;
+                *rawmode = 1;
+            }
+            else if (quote == 'f' || quote == 'F') {
+                quote = (unsigned char)*++s;
+                fmode = 1;
+            }
+            else {
+                break;
+            }
+        }
+    }
+
+    /* fstrings are only allowed in Python 3.6 and greater */
+    if (fmode && p->feature_version < 6) {
+        p->error_indicator = 1;
+        RAISE_SYNTAX_ERROR("Format strings are only supported in Python 3.6 and greater");
+        return -1;
+    }
+
+    if (fmode && *bytesmode) {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    if (quote != '\'' && quote != '\"') {
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    /* Skip the leading quote char. */
+    s++;
+    len = strlen(s);
+    if (len > INT_MAX) {
+        PyErr_SetString(PyExc_OverflowError, "string to parse is too long");
+        return -1;
+    }
+    if (s[--len] != quote) {
+        /* Last quote char must match the first. */
+        PyErr_BadInternalCall();
+        return -1;
+    }
+    if (len >= 4 && s[0] == quote && s[1] == quote) {
+        /* A triple quoted string. We've already skipped one quote at
+           the start and one at the end of the string. Now skip the
+           two at the start. */
+        s += 2;
+        len -= 2;
+        /* And check that the last two match. */
+        if (s[--len] != quote || s[--len] != quote) {
+            PyErr_BadInternalCall();
+            return -1;
+        }
+    }
+
+    if (fmode) {
+        /* Just return the bytes. The caller will parse the resulting
+           string. */
+        *fstr = s;
+        *fstrlen = len;
+        return 0;
+    }
+
+    /* Not an f-string. */
+    /* Avoid invoking escape decoding routines if possible. */
+    *rawmode = *rawmode || strchr(s, '\\') == NULL;
+    if (*bytesmode) {
+        /* Disallow non-ASCII characters. */
+        const char *ch;
+        for (ch = s; *ch; ch++) {
+            if (Py_CHARMASK(*ch) >= 0x80) {
+                RAISE_SYNTAX_ERROR(
+                                   "bytes can only contain ASCII "
+                                   "literal characters.");
+                return -1;
+            }
+        }
+        if (*rawmode) {
+            *result = PyBytes_FromStringAndSize(s, len);
+        }
+        else {
+            *result = decode_bytes_with_escapes(p, s, len, t);
+        }
+    }
+    else {
+        if (*rawmode) {
+            *result = PyUnicode_DecodeUTF8Stateful(s, len, NULL, NULL);
+        }
+        else {
+            *result = decode_unicode_with_escapes(p, s, len, t);
+        }
+    }
+    return *result == NULL ? -1 : 0;
+}
+
+
+
+// FSTRING STUFF
+
+/* Fix locations for the given node and its children.
+
+   `parent` is the enclosing node.
+   `expr_start` is the starting position of the expression (pointing to the open brace).
+   `n` is the node which locations are going to be fixed relative to parent.
+   `expr_str` is the child node's string representation, including braces.
+*/
+static bool
+fstring_find_expr_location(Token *parent, const char* expr_start, char *expr_str, int *p_lines, int *p_cols)
+{
+    *p_lines = 0;
+    *p_cols = 0;
+    assert(expr_start != NULL && *expr_start == '{');
+    if (parent && parent->bytes) {
+        char *parent_str = PyBytes_AsString(parent->bytes);
+        if (!parent_str) {
+            return false;
+        }
+        // The following is needed, in order to correctly shift the column
+        // offset, in the case that (disregarding any whitespace) a newline
+        // immediately follows the opening curly brace of the fstring expression.
+        bool newline_after_brace = 1;
+        const char *start = expr_start + 1;
+        while (start && *start != '}' && *start != '\n') {
+            if (*start != ' ' && *start != '\t' && *start != '\f') {
+                newline_after_brace = 0;
+                break;
+            }
+            start++;
+        }
+
+        // Account for the characters from the last newline character to our
+        // left until the beginning of expr_start.
+        if (!newline_after_brace) {
+            start = expr_start;
+            while (start > parent_str && *start != '\n') {
+                start--;
+            }
+            *p_cols += (int)(expr_start - start);
+        }
+        /* adjust the start based on the number of newlines encountered
+           before the f-string expression */
+        for (const char *p = parent_str; p < expr_start; p++) {
+            if (*p == '\n') {
+                (*p_lines)++;
+            }
+        }
+    }
+    return true;
+}
+
+
+/* Compile this expression in to an expr_ty.  Add parens around the
+   expression, in order to allow leading spaces in the expression. */
+static expr_ty
+fstring_compile_expr(Parser *p, const char *expr_start, const char *expr_end,
+                     Token *t)
+{
+    expr_ty expr = NULL;
+    char *str;
+    Py_ssize_t len;
+    const char *s;
+    expr_ty result = NULL;
+
+    assert(expr_end >= expr_start);
+    assert(*(expr_start-1) == '{');
+    assert(*expr_end == '}' || *expr_end == '!' || *expr_end == ':' ||
+           *expr_end == '=');
+
+    /* If the substring is all whitespace, it's an error.  We need to catch this
+       here, and not when we call PyParser_SimpleParseStringFlagsFilename,
+       because turning the expression '' in to '()' would go from being invalid
+       to valid. */
+    for (s = expr_start; s != expr_end; s++) {
+        char c = *s;
+        /* The Python parser ignores only the following whitespace
+           characters (\r already is converted to \n). */
+        if (!(c == ' ' || c == '\t' || c == '\n' || c == '\f')) {
+            break;
+        }
+    }
+    if (s == expr_end) {
+        RAISE_SYNTAX_ERROR("f-string: empty expression not allowed");
+        return NULL;
+    }
+
+    len = expr_end - expr_start;
+    /* Allocate 3 extra bytes: open paren, close paren, null byte. */
+    str = PyMem_Calloc(len + 3, sizeof(char));
+    if (str == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    // The call to fstring_find_expr_location is responsible for finding the column offset
+    // the generated AST nodes need to be shifted to the right, which is equal to the number
+    // of the f-string characters before the expression starts.
+    memcpy(str+1, expr_start, len);
+    int lines, cols;
+    if (!fstring_find_expr_location(t, expr_start-1, str+1, &lines, &cols)) {
+        PyMem_Free(str);
+        return NULL;
+    }
+
+    // The parentheses are needed in order to allow for leading whitespace within
+    // the f-string expression. This consequently gets parsed as a group (see the
+    // group rule in python.gram).
+    str[0] = '(';
+    str[len+1] = ')';
+
+    struct tok_state* tok = PyTokenizer_FromString(str, 1);
+    if (tok == NULL) {
+        PyMem_Free(str);
+        return NULL;
+    }
+    Py_INCREF(p->tok->filename);
+    tok->filename = p->tok->filename;
+
+    Parser *p2 = _PyPegen_Parser_New(tok, Py_fstring_input, p->flags, p->feature_version,
+                                     NULL, p->arena);
+    p2->starting_lineno = t->lineno + lines - 1;
+    p2->starting_col_offset = t->col_offset + cols;
+
+    expr = _PyPegen_run_parser(p2);
+
+    if (expr == NULL) {
+        goto exit;
+    }
+    result = expr;
+
+exit:
+    PyMem_Free(str);
+    _PyPegen_Parser_Free(p2);
+    PyTokenizer_Free(tok);
+    return result;
+}
+
+/* Return -1 on error.
+
+   Return 0 if we reached the end of the literal.
+
+   Return 1 if we haven't reached the end of the literal, but we want
+   the caller to process the literal up to this point. Used for
+   doubled braces.
+*/
+static int
+fstring_find_literal(Parser *p, const char **str, const char *end, int raw,
+                     PyObject **literal, int recurse_lvl, Token *t)
+{
+    /* Get any literal string. It ends when we hit an un-doubled left
+       brace (which isn't part of a unicode name escape such as
+       "\N{EULER CONSTANT}"), or the end of the string. */
+
+    const char *s = *str;
+    const char *literal_start = s;
+    int result = 0;
+
+    assert(*literal == NULL);
+    while (s < end) {
+        char ch = *s++;
+        if (!raw && ch == '\\' && s < end) {
+            ch = *s++;
+            if (ch == 'N') {
+                if (s < end && *s++ == '{') {
+                    while (s < end && *s++ != '}') {
+                    }
+                    continue;
+                }
+                break;
+            }
+            if (ch == '{' && warn_invalid_escape_sequence(p, ch, t) < 0) {
+                return -1;
+            }
+        }
+        if (ch == '{' || ch == '}') {
+            /* Check for doubled braces, but only at the top level. If
+               we checked at every level, then f'{0:{3}}' would fail
+               with the two closing braces. */
+            if (recurse_lvl == 0) {
+                if (s < end && *s == ch) {
+                    /* We're going to tell the caller that the literal ends
+                       here, but that they should continue scanning. But also
+                       skip over the second brace when we resume scanning. */
+                    *str = s + 1;
+                    result = 1;
+                    goto done;
+                }
+
+                /* Where a single '{' is the start of a new expression, a
+                   single '}' is not allowed. */
+                if (ch == '}') {
+                    *str = s - 1;
+                    RAISE_SYNTAX_ERROR("f-string: single '}' is not allowed");
+                    return -1;
+                }
+            }
+            /* We're either at a '{', which means we're starting another
+               expression; or a '}', which means we're at the end of this
+               f-string (for a nested format_spec). */
+            s--;
+            break;
+        }
+    }
+    *str = s;
+    assert(s <= end);
+    assert(s == end || *s == '{' || *s == '}');
+done:
+    if (literal_start != s) {
+        if (raw) {
+            *literal = PyUnicode_DecodeUTF8Stateful(literal_start,
+                                                    s - literal_start,
+                                                    NULL, NULL);
+        } else {
+            *literal = decode_unicode_with_escapes(p, literal_start,
+                                                   s - literal_start, t);
+        }
+        if (!*literal) {
+            return -1;
+        }
+    }
+    return result;
+}
+
+/* Forward declaration because parsing is recursive. */
+static expr_ty
+fstring_parse(Parser *p, const char **str, const char *end, int raw, int recurse_lvl,
+              Token *first_token, Token* t, Token *last_token);
+
+/* Parse the f-string at *str, ending at end.  We know *str starts an
+   expression (so it must be a '{'). Returns the FormattedValue node, which
+   includes the expression, conversion character, format_spec expression, and
+   optionally the text of the expression (if = is used).
+
+   Note that I don't do a perfect job here: I don't make sure that a
+   closing brace doesn't match an opening paren, for example. It
+   doesn't need to error on all invalid expressions, just correctly
+   find the end of all valid ones. Any errors inside the expression
+   will be caught when we parse it later.
+
+   *expression is set to the expression.  For an '=' "debug" expression,
+   *expr_text is set to the debug text (the original text of the expression,
+   including the '=' and any whitespace around it, as a string object).  If
+   not a debug expression, *expr_text set to NULL. */
+static int
+fstring_find_expr(Parser *p, const char **str, const char *end, int raw, int recurse_lvl,
+                  PyObject **expr_text, expr_ty *expression, Token *first_token,
+                  Token *t, Token *last_token)
+{
+    /* Return -1 on error, else 0. */
+
+    const char *expr_start;
+    const char *expr_end;
+    expr_ty simple_expression;
+    expr_ty format_spec = NULL; /* Optional format specifier. */
+    int conversion = -1; /* The conversion char.  Use default if not
+                            specified, or !r if using = and no format
+                            spec. */
+
+    /* 0 if we're not in a string, else the quote char we're trying to
+       match (single or double quote). */
+    char quote_char = 0;
+
+    /* If we're inside a string, 1=normal, 3=triple-quoted. */
+    int string_type = 0;
+
+    /* Keep track of nesting level for braces/parens/brackets in
+       expressions. */
+    Py_ssize_t nested_depth = 0;
+    char parenstack[MAXLEVEL];
+
+    *expr_text = NULL;
+
+    /* Can only nest one level deep. */
+    if (recurse_lvl >= 2) {
+        RAISE_SYNTAX_ERROR("f-string: expressions nested too deeply");
+        goto error;
+    }
+
+    /* The first char must be a left brace, or we wouldn't have gotten
+       here. Skip over it. */
+    assert(**str == '{');
+    *str += 1;
+
+    expr_start = *str;
+    for (; *str < end; (*str)++) {
+        char ch;
+
+        /* Loop invariants. */
+        assert(nested_depth >= 0);
+        assert(*str >= expr_start && *str < end);
+        if (quote_char) {
+            assert(string_type == 1 || string_type == 3);
+        } else {
+            assert(string_type == 0);
+        }
+
+        ch = **str;
+        /* Nowhere inside an expression is a backslash allowed. */
+        if (ch == '\\') {
+            /* Error: can't include a backslash character, inside
+               parens or strings or not. */
+            RAISE_SYNTAX_ERROR(
+                      "f-string expression part "
+                      "cannot include a backslash");
+            goto error;
+        }
+        if (quote_char) {
+            /* We're inside a string. See if we're at the end. */
+            /* This code needs to implement the same non-error logic
+               as tok_get from tokenizer.c, at the letter_quote
+               label. To actually share that code would be a
+               nightmare. But, it's unlikely to change and is small,
+               so duplicate it here. Note we don't need to catch all
+               of the errors, since they'll be caught when parsing the
+               expression. We just need to match the non-error
+               cases. Thus we can ignore \n in single-quoted strings,
+               for example. Or non-terminated strings. */
+            if (ch == quote_char) {
+                /* Does this match the string_type (single or triple
+                   quoted)? */
+                if (string_type == 3) {
+                    if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) {
+                        /* We're at the end of a triple quoted string. */
+                        *str += 2;
+                        string_type = 0;
+                        quote_char = 0;
+                        continue;
+                    }
+                } else {
+                    /* We're at the end of a normal string. */
+                    quote_char = 0;
+                    string_type = 0;
+                    continue;
+                }
+            }
+        } else if (ch == '\'' || ch == '"') {
+            /* Is this a triple quoted string? */
+            if (*str+2 < end && *(*str+1) == ch && *(*str+2) == ch) {
+                string_type = 3;
+                *str += 2;
+            } else {
+                /* Start of a normal string. */
+                string_type = 1;
+            }
+            /* Start looking for the end of the string. */
+            quote_char = ch;
+        } else if (ch == '[' || ch == '{' || ch == '(') {
+            if (nested_depth >= MAXLEVEL) {
+                RAISE_SYNTAX_ERROR("f-string: too many nested parenthesis");
+                goto error;
+            }
+            parenstack[nested_depth] = ch;
+            nested_depth++;
+        } else if (ch == '#') {
+            /* Error: can't include a comment character, inside parens
+               or not. */
+            RAISE_SYNTAX_ERROR("f-string expression part cannot include '#'");
+            goto error;
+        } else if (nested_depth == 0 &&
+                   (ch == '!' || ch == ':' || ch == '}' ||
+                    ch == '=' || ch == '>' || ch == '<')) {
+            /* See if there's a next character. */
+            if (*str+1 < end) {
+                char next = *(*str+1);
+
+                /* For "!=". since '=' is not an allowed conversion character,
+                   nothing is lost in this test. */
+                if ((ch == '!' && next == '=') ||   /* != */
+                    (ch == '=' && next == '=') ||   /* == */
+                    (ch == '<' && next == '=') ||   /* <= */
+                    (ch == '>' && next == '=')      /* >= */
+                    ) {
+                    *str += 1;
+                    continue;
+                }
+                /* Don't get out of the loop for these, if they're single
+                   chars (not part of 2-char tokens). If by themselves, they
+                   don't end an expression (unlike say '!'). */
+                if (ch == '>' || ch == '<') {
+                    continue;
+                }
+            }
+
+            /* Normal way out of this loop. */
+            break;
+        } else if (ch == ']' || ch == '}' || ch == ')') {
+            if (!nested_depth) {
+                RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", ch);
+                goto error;
+            }
+            nested_depth--;
+            int opening = (unsigned char)parenstack[nested_depth];
+            if (!((opening == '(' && ch == ')') ||
+                  (opening == '[' && ch == ']') ||
+                  (opening == '{' && ch == '}')))
+            {
+                RAISE_SYNTAX_ERROR(
+                          "f-string: closing parenthesis '%c' "
+                          "does not match opening parenthesis '%c'",
+                          ch, opening);
+                goto error;
+            }
+        } else {
+            /* Just consume this char and loop around. */
+        }
+    }
+    expr_end = *str;
+    /* If we leave this loop in a string or with mismatched parens, we
+       don't care. We'll get a syntax error when compiling the
+       expression. But, we can produce a better error message, so
+       let's just do that.*/
+    if (quote_char) {
+        RAISE_SYNTAX_ERROR("f-string: unterminated string");
+        goto error;
+    }
+    if (nested_depth) {
+        int opening = (unsigned char)parenstack[nested_depth - 1];
+        RAISE_SYNTAX_ERROR("f-string: unmatched '%c'", opening);
+        goto error;
+    }
+
+    if (*str >= end) {
+        goto unexpected_end_of_string;
+    }
+
+    /* Compile the expression as soon as possible, so we show errors
+       related to the expression before errors related to the
+       conversion or format_spec. */
+    simple_expression = fstring_compile_expr(p, expr_start, expr_end, t);
+    if (!simple_expression) {
+        goto error;
+    }
+
+    /* Check for =, which puts the text value of the expression in
+       expr_text. */
+    if (**str == '=') {
+        if (p->feature_version < 8) {
+            RAISE_SYNTAX_ERROR("f-string: self documenting expressions are "
+                               "only supported in Python 3.8 and greater");
+            goto error;
+        }
+        *str += 1;
+
+        /* Skip over ASCII whitespace.  No need to test for end of string
+           here, since we know there's at least a trailing quote somewhere
+           ahead. */
+        while (Py_ISSPACE(**str)) {
+            *str += 1;
+        }
+
+        /* Set *expr_text to the text of the expression. */
+        *expr_text = PyUnicode_FromStringAndSize(expr_start, *str-expr_start);
+        if (!*expr_text) {
+            goto error;
+        }
+    }
+
+    /* Check for a conversion char, if present. */
+    if (**str == '!') {
+        *str += 1;
+        if (*str >= end) {
+            goto unexpected_end_of_string;
+        }
+
+        conversion = (unsigned char)**str;
+        *str += 1;
+
+        /* Validate the conversion. */
+        if (!(conversion == 's' || conversion == 'r' || conversion == 'a')) {
+            RAISE_SYNTAX_ERROR(
+                      "f-string: invalid conversion character: "
+                      "expected 's', 'r', or 'a'");
+            goto error;
+        }
+
+    }
+
+    /* Check for the format spec, if present. */
+    if (*str >= end) {
+        goto unexpected_end_of_string;
+    }
+    if (**str == ':') {
+        *str += 1;
+        if (*str >= end) {
+            goto unexpected_end_of_string;
+        }
+
+        /* Parse the format spec. */
+        format_spec = fstring_parse(p, str, end, raw, recurse_lvl+1,
+                                    first_token, t, last_token);
+        if (!format_spec) {
+            goto error;
+        }
+    }
+
+    if (*str >= end || **str != '}') {
+        goto unexpected_end_of_string;
+    }
+
+    /* We're at a right brace. Consume it. */
+    assert(*str < end);
+    assert(**str == '}');
+    *str += 1;
+
+    /* If we're in = mode (detected by non-NULL expr_text), and have no format
+       spec and no explicit conversion, set the conversion to 'r'. */
+    if (*expr_text && format_spec == NULL && conversion == -1) {
+        conversion = 'r';
+    }
+
+    /* And now create the FormattedValue node that represents this
+       entire expression with the conversion and format spec. */
+    //TODO: Fix this
+    *expression = FormattedValue(simple_expression, conversion,
+                                 format_spec, first_token->lineno,
+                                 first_token->col_offset, last_token->end_lineno,
+                                 last_token->end_col_offset, p->arena);
+    if (!*expression) {
+        goto error;
+    }
+
+    return 0;
+
+unexpected_end_of_string:
+    RAISE_SYNTAX_ERROR("f-string: expecting '}'");
+    /* Falls through to error. */
+
+error:
+    Py_XDECREF(*expr_text);
+    return -1;
+
+}
+
+/* Return -1 on error.
+
+   Return 0 if we have a literal (possible zero length) and an
+   expression (zero length if at the end of the string.
+
+   Return 1 if we have a literal, but no expression, and we want the
+   caller to call us again. This is used to deal with doubled
+   braces.
+
+   When called multiple times on the string 'a{{b{0}c', this function
+   will return:
+
+   1. the literal 'a{' with no expression, and a return value
+      of 1. Despite the fact that there's no expression, the return
+      value of 1 means we're not finished yet.
+
+   2. the literal 'b' and the expression '0', with a return value of
+      0. The fact that there's an expression means we're not finished.
+
+   3. literal 'c' with no expression and a return value of 0. The
+      combination of the return value of 0 with no expression means
+      we're finished.
+*/
+static int
+fstring_find_literal_and_expr(Parser *p, const char **str, const char *end, int raw,
+                              int recurse_lvl, PyObject **literal,
+                              PyObject **expr_text, expr_ty *expression,
+                              Token *first_token, Token *t, Token *last_token)
+{
+    int result;
+
+    assert(*literal == NULL && *expression == NULL);
+
+    /* Get any literal string. */
+    result = fstring_find_literal(p, str, end, raw, literal, recurse_lvl, t);
+    if (result < 0) {
+        goto error;
+    }
+
+    assert(result == 0 || result == 1);
+
+    if (result == 1) {
+        /* We have a literal, but don't look at the expression. */
+        return 1;
+    }
+
+    if (*str >= end || **str == '}') {
+        /* We're at the end of the string or the end of a nested
+           f-string: no expression. The top-level error case where we
+           expect to be at the end of the string but we're at a '}' is
+           handled later. */
+        return 0;
+    }
+
+    /* We must now be the start of an expression, on a '{'. */
+    assert(**str == '{');
+
+    if (fstring_find_expr(p, str, end, raw, recurse_lvl, expr_text,
+                          expression, first_token, t, last_token) < 0) {
+        goto error;
+    }
+
+    return 0;
+
+error:
+    Py_CLEAR(*literal);
+    return -1;
+}
+
+#ifdef NDEBUG
+#define ExprList_check_invariants(l)
+#else
+static void
+ExprList_check_invariants(ExprList *l)
+{
+    /* Check our invariants. Make sure this object is "live", and
+       hasn't been deallocated. */
+    assert(l->size >= 0);
+    assert(l->p != NULL);
+    if (l->size <= EXPRLIST_N_CACHED) {
+        assert(l->data == l->p);
+    }
+}
+#endif
+
+static void
+ExprList_Init(ExprList *l)
+{
+    l->allocated = EXPRLIST_N_CACHED;
+    l->size = 0;
+
+    /* Until we start allocating dynamically, p points to data. */
+    l->p = l->data;
+
+    ExprList_check_invariants(l);
+}
+
+static int
+ExprList_Append(ExprList *l, expr_ty exp)
+{
+    ExprList_check_invariants(l);
+    if (l->size >= l->allocated) {
+        /* We need to alloc (or realloc) the memory. */
+        Py_ssize_t new_size = l->allocated * 2;
+
+        /* See if we've ever allocated anything dynamically. */
+        if (l->p == l->data) {
+            Py_ssize_t i;
+            /* We're still using the cached data. Switch to
+               alloc-ing. */
+            l->p = PyMem_Malloc(sizeof(expr_ty) * new_size);
+            if (!l->p) {
+                return -1;
+            }
+            /* Copy the cached data into the new buffer. */
+            for (i = 0; i < l->size; i++) {
+                l->p[i] = l->data[i];
+            }
+        } else {
+            /* Just realloc. */
+            expr_ty *tmp = PyMem_Realloc(l->p, sizeof(expr_ty) * new_size);
+            if (!tmp) {
+                PyMem_Free(l->p);
+                l->p = NULL;
+                return -1;
+            }
+            l->p = tmp;
+        }
+
+        l->allocated = new_size;
+        assert(l->allocated == 2 * l->size);
+    }
+
+    l->p[l->size++] = exp;
+
+    ExprList_check_invariants(l);
+    return 0;
+}
+
+static void
+ExprList_Dealloc(ExprList *l)
+{
+    ExprList_check_invariants(l);
+
+    /* If there's been an error, or we've never dynamically allocated,
+       do nothing. */
+    if (!l->p || l->p == l->data) {
+        /* Do nothing. */
+    } else {
+        /* We have dynamically allocated. Free the memory. */
+        PyMem_Free(l->p);
+    }
+    l->p = NULL;
+    l->size = -1;
+}
+
+static asdl_seq *
+ExprList_Finish(ExprList *l, PyArena *arena)
+{
+    asdl_seq *seq;
+
+    ExprList_check_invariants(l);
+
+    /* Allocate the asdl_seq and copy the expressions in to it. */
+    seq = _Py_asdl_seq_new(l->size, arena);
+    if (seq) {
+        Py_ssize_t i;
+        for (i = 0; i < l->size; i++) {
+            asdl_seq_SET(seq, i, l->p[i]);
+        }
+    }
+    ExprList_Dealloc(l);
+    return seq;
+}
+
+#ifdef NDEBUG
+#define FstringParser_check_invariants(state)
+#else
+static void
+FstringParser_check_invariants(FstringParser *state)
+{
+    if (state->last_str) {
+        assert(PyUnicode_CheckExact(state->last_str));
+    }
+    ExprList_check_invariants(&state->expr_list);
+}
+#endif
+
+void
+_PyPegen_FstringParser_Init(FstringParser *state)
+{
+    state->last_str = NULL;
+    state->fmode = 0;
+    ExprList_Init(&state->expr_list);
+    FstringParser_check_invariants(state);
+}
+
+void
+_PyPegen_FstringParser_Dealloc(FstringParser *state)
+{
+    FstringParser_check_invariants(state);
+
+    Py_XDECREF(state->last_str);
+    ExprList_Dealloc(&state->expr_list);
+}
+
+/* Make a Constant node, but decref the PyUnicode object being added. */
+static expr_ty
+make_str_node_and_del(Parser *p, PyObject **str, Token* first_token, Token *last_token)
+{
+    PyObject *s = *str;
+    PyObject *kind = NULL;
+    *str = NULL;
+    assert(PyUnicode_CheckExact(s));
+    if (PyArena_AddPyObject(p->arena, s) < 0) {
+        Py_DECREF(s);
+        return NULL;
+    }
+    const char* the_str = PyBytes_AsString(first_token->bytes);
+    if (the_str && the_str[0] == 'u') {
+        kind = _PyPegen_new_identifier(p, "u");
+    }
+
+    if (kind == NULL && PyErr_Occurred()) {
+        return NULL;
+    }
+
+    return Constant(s, kind, first_token->lineno, first_token->col_offset,
+                    last_token->end_lineno, last_token->end_col_offset, p->arena);
+
+}
+
+
+/* Add a non-f-string (that is, a regular literal string). str is
+   decref'd. */
+int
+_PyPegen_FstringParser_ConcatAndDel(FstringParser *state, PyObject *str)
+{
+    FstringParser_check_invariants(state);
+
+    assert(PyUnicode_CheckExact(str));
+
+    if (PyUnicode_GET_LENGTH(str) == 0) {
+        Py_DECREF(str);
+        return 0;
+    }
+
+    if (!state->last_str) {
+        /* We didn't have a string before, so just remember this one. */
+        state->last_str = str;
+    } else {
+        /* Concatenate this with the previous string. */
+        PyUnicode_AppendAndDel(&state->last_str, str);
+        if (!state->last_str) {
+            return -1;
+        }
+    }
+    FstringParser_check_invariants(state);
+    return 0;
+}
+
+/* Parse an f-string. The f-string is in *str to end, with no
+   'f' or quotes. */
+int
+_PyPegen_FstringParser_ConcatFstring(Parser *p, FstringParser *state, const char **str,
+                            const char *end, int raw, int recurse_lvl,
+                            Token *first_token, Token* t, Token *last_token)
+{
+    FstringParser_check_invariants(state);
+    state->fmode = 1;
+
+    /* Parse the f-string. */
+    while (1) {
+        PyObject *literal = NULL;
+        PyObject *expr_text = NULL;
+        expr_ty expression = NULL;
+
+        /* If there's a zero length literal in front of the
+           expression, literal will be NULL. If we're at the end of
+           the f-string, expression will be NULL (unless result == 1,
+           see below). */
+        int result = fstring_find_literal_and_expr(p, str, end, raw, recurse_lvl,
+                                                   &literal, &expr_text,
+                                                   &expression, first_token, t, last_token);
+        if (result < 0) {
+            return -1;
+        }
+
+        /* Add the literal, if any. */
+        if (literal && _PyPegen_FstringParser_ConcatAndDel(state, literal) < 0) {
+            Py_XDECREF(expr_text);
+            return -1;
+        }
+        /* Add the expr_text, if any. */
+        if (expr_text && _PyPegen_FstringParser_ConcatAndDel(state, expr_text) < 0) {
+            return -1;
+        }
+
+        /* We've dealt with the literal and expr_text, their ownership has
+           been transferred to the state object.  Don't look at them again. */
+
+        /* See if we should just loop around to get the next literal
+           and expression, while ignoring the expression this
+           time. This is used for un-doubling braces, as an
+           optimization. */
+        if (result == 1) {
+            continue;
+        }
+
+        if (!expression) {
+            /* We're done with this f-string. */
+            break;
+        }
+
+        /* We know we have an expression. Convert any existing string
+           to a Constant node. */
+        if (!state->last_str) {
+            /* Do nothing. No previous literal. */
+        } else {
+            /* Convert the existing last_str literal to a Constant node. */
+            expr_ty last_str = make_str_node_and_del(p, &state->last_str, first_token, last_token);
+            if (!last_str || ExprList_Append(&state->expr_list, last_str) < 0) {
+                return -1;
+            }
+        }
+
+        if (ExprList_Append(&state->expr_list, expression) < 0) {
+            return -1;
+        }
+    }
+
+    /* If recurse_lvl is zero, then we must be at the end of the
+       string. Otherwise, we must be at a right brace. */
+
+    if (recurse_lvl == 0 && *str < end-1) {
+        RAISE_SYNTAX_ERROR("f-string: unexpected end of string");
+        return -1;
+    }
+    if (recurse_lvl != 0 && **str != '}') {
+        RAISE_SYNTAX_ERROR("f-string: expecting '}'");
+        return -1;
+    }
+
+    FstringParser_check_invariants(state);
+    return 0;
+}
+
+/* Convert the partial state reflected in last_str and expr_list to an
+   expr_ty. The expr_ty can be a Constant, or a JoinedStr. */
+expr_ty
+_PyPegen_FstringParser_Finish(Parser *p, FstringParser *state, Token* first_token,
+                     Token *last_token)
+{
+    asdl_seq *seq;
+
+    FstringParser_check_invariants(state);
+
+    /* If we're just a constant string with no expressions, return
+       that. */
+    if (!state->fmode) {
+        assert(!state->expr_list.size);
+        if (!state->last_str) {
+            /* Create a zero length string. */
+            state->last_str = PyUnicode_FromStringAndSize(NULL, 0);
+            if (!state->last_str) {
+                goto error;
+            }
+        }
+        return make_str_node_and_del(p, &state->last_str, first_token, last_token);
+    }
+
+    /* Create a Constant node out of last_str, if needed. It will be the
+       last node in our expression list. */
+    if (state->last_str) {
+        expr_ty str = make_str_node_and_del(p, &state->last_str, first_token, last_token);
+        if (!str || ExprList_Append(&state->expr_list, str) < 0) {
+            goto error;
+        }
+    }
+    /* This has already been freed. */
+    assert(state->last_str == NULL);
+
+    seq = ExprList_Finish(&state->expr_list, p->arena);
+    if (!seq) {
+        goto error;
+    }
+
+    return _Py_JoinedStr(seq, first_token->lineno, first_token->col_offset,
+                         last_token->end_lineno, last_token->end_col_offset, p->arena);
+
+error:
+    _PyPegen_FstringParser_Dealloc(state);
+    return NULL;
+}
+
+/* Given an f-string (with no 'f' or quotes) that's in *str and ends
+   at end, parse it into an expr_ty.  Return NULL on error.  Adjust
+   str to point past the parsed portion. */
+static expr_ty
+fstring_parse(Parser *p, const char **str, const char *end, int raw,
+              int recurse_lvl, Token *first_token, Token* t, Token *last_token)
+{
+    FstringParser state;
+
+    _PyPegen_FstringParser_Init(&state);
+    if (_PyPegen_FstringParser_ConcatFstring(p, &state, str, end, raw, recurse_lvl,
+                                    first_token, t, last_token) < 0) {
+        _PyPegen_FstringParser_Dealloc(&state);
+        return NULL;
+    }
+
+    return _PyPegen_FstringParser_Finish(p, &state, t, t);
+}
diff --git a/contrib/tools/python3/src/Parser/pegen/parse_string.h b/contrib/tools/python3/src/Parser/pegen/parse_string.h
index 6597ed7de2..cd85bd57d0 100644
--- a/contrib/tools/python3/src/Parser/pegen/parse_string.h
+++ b/contrib/tools/python3/src/Parser/pegen/parse_string.h
@@ -1,46 +1,46 @@
-#ifndef STRINGS_H 
-#define STRINGS_H 
- 
-#include <Python.h> 
-#include <Python-ast.h> 
-#include "pegen.h" 
- 
-#define EXPRLIST_N_CACHED  64 
- 
-typedef struct { 
-    /* Incrementally build an array of expr_ty, so be used in an 
-       asdl_seq. Cache some small but reasonably sized number of 
-       expr_ty's, and then after that start dynamically allocating, 
-       doubling the number allocated each time. Note that the f-string 
-       f'{0}a{1}' contains 3 expr_ty's: 2 FormattedValue's, and one 
-       Constant for the literal 'a'. So you add expr_ty's about twice as 
-       fast as you add expressions in an f-string. */ 
- 
-    Py_ssize_t allocated;  /* Number we've allocated. */ 
-    Py_ssize_t size;       /* Number we've used. */ 
-    expr_ty    *p;         /* Pointer to the memory we're actually 
-                              using. Will point to 'data' until we 
-                              start dynamically allocating. */ 
-    expr_ty    data[EXPRLIST_N_CACHED]; 
-} ExprList; 
- 
-/* The FstringParser is designed to add a mix of strings and 
-   f-strings, and concat them together as needed. Ultimately, it 
-   generates an expr_ty. */ 
-typedef struct { 
-    PyObject *last_str; 
-    ExprList expr_list; 
-    int fmode; 
-} FstringParser; 
- 
-void _PyPegen_FstringParser_Init(FstringParser *); 
-int _PyPegen_parsestr(Parser *, int *, int *, PyObject **, 
-                      const char **, Py_ssize_t *, Token *); 
-int _PyPegen_FstringParser_ConcatFstring(Parser *, FstringParser *, const char **, 
-                                const char *, int, int, Token *, Token *, 
-                                Token *); 
-int _PyPegen_FstringParser_ConcatAndDel(FstringParser *, PyObject *); 
-expr_ty _PyPegen_FstringParser_Finish(Parser *, FstringParser *, Token *, Token *); 
-void _PyPegen_FstringParser_Dealloc(FstringParser *); 
- 
-#endif 
+#ifndef STRINGS_H
+#define STRINGS_H
+
+#include <Python.h>
+#include <Python-ast.h>
+#include "pegen.h"
+
+#define EXPRLIST_N_CACHED  64
+
+typedef struct {
+    /* Incrementally build an array of expr_ty, so be used in an
+       asdl_seq. Cache some small but reasonably sized number of
+       expr_ty's, and then after that start dynamically allocating,
+       doubling the number allocated each time. Note that the f-string
+       f'{0}a{1}' contains 3 expr_ty's: 2 FormattedValue's, and one
+       Constant for the literal 'a'. So you add expr_ty's about twice as
+       fast as you add expressions in an f-string. */
+
+    Py_ssize_t allocated;  /* Number we've allocated. */
+    Py_ssize_t size;       /* Number we've used. */
+    expr_ty    *p;         /* Pointer to the memory we're actually
+                              using. Will point to 'data' until we
+                              start dynamically allocating. */
+    expr_ty    data[EXPRLIST_N_CACHED];
+} ExprList;
+
+/* The FstringParser is designed to add a mix of strings and
+   f-strings, and concat them together as needed. Ultimately, it
+   generates an expr_ty. */
+typedef struct {
+    PyObject *last_str;
+    ExprList expr_list;
+    int fmode;
+} FstringParser;
+
+void _PyPegen_FstringParser_Init(FstringParser *);
+int _PyPegen_parsestr(Parser *, int *, int *, PyObject **,
+                      const char **, Py_ssize_t *, Token *);
+int _PyPegen_FstringParser_ConcatFstring(Parser *, FstringParser *, const char **,
+                                const char *, int, int, Token *, Token *,
+                                Token *);
+int _PyPegen_FstringParser_ConcatAndDel(FstringParser *, PyObject *);
+expr_ty _PyPegen_FstringParser_Finish(Parser *, FstringParser *, Token *, Token *);
+void _PyPegen_FstringParser_Dealloc(FstringParser *);
+
+#endif
diff --git a/contrib/tools/python3/src/Parser/pegen/peg_api.c b/contrib/tools/python3/src/Parser/pegen/peg_api.c
index 10e00a7c75..5e71ecdb13 100644
--- a/contrib/tools/python3/src/Parser/pegen/peg_api.c
+++ b/contrib/tools/python3/src/Parser/pegen/peg_api.c
@@ -1,54 +1,54 @@
-#include "pegen_interface.h" 
- 
-#include "../tokenizer.h" 
-#include "pegen.h" 
- 
-mod_ty 
-PyPegen_ASTFromString(const char *str, const char *filename, int mode, 
-                      PyCompilerFlags *flags, PyArena *arena) 
-{ 
-    PyObject *filename_ob = PyUnicode_FromString(filename); 
-    if (filename_ob == NULL) { 
-        return NULL; 
-    } 
-    mod_ty result = PyPegen_ASTFromStringObject(str, filename_ob, mode, flags, arena); 
-    Py_XDECREF(filename_ob); 
-    return result; 
-} 
- 
-mod_ty 
-PyPegen_ASTFromStringObject(const char *str, PyObject* filename, int mode, 
-                            PyCompilerFlags *flags, PyArena *arena) 
-{ 
-    if (PySys_Audit("compile", "yO", str, filename) < 0) { 
-        return NULL; 
-    } 
- 
-    mod_ty result = _PyPegen_run_parser_from_string(str, mode, filename, flags, arena); 
-    return result; 
-} 
- 
-mod_ty 
-PyPegen_ASTFromFilename(const char *filename, int mode, PyCompilerFlags *flags, PyArena *arena) 
-{ 
-    PyObject *filename_ob = PyUnicode_FromString(filename); 
-    if (filename_ob == NULL) { 
-        return NULL; 
-    } 
- 
-    mod_ty result = _PyPegen_run_parser_from_file(filename, mode, filename_ob, flags, arena); 
-    Py_XDECREF(filename_ob); 
-    return result; 
-} 
- 
-mod_ty 
-PyPegen_ASTFromFileObject(FILE *fp, PyObject *filename_ob, int mode, 
-                          const char *enc, const char *ps1, const char* ps2, 
-                          PyCompilerFlags *flags, int *errcode, PyArena *arena) 
-{ 
-    if (PySys_Audit("compile", "OO", Py_None, filename_ob) < 0) { 
-        return NULL; 
-    } 
-    return _PyPegen_run_parser_from_file_pointer(fp, mode, filename_ob, enc, ps1, ps2, 
-                                        flags, errcode, arena); 
-} 
+#include "pegen_interface.h"
+
+#include "../tokenizer.h"
+#include "pegen.h"
+
+mod_ty
+PyPegen_ASTFromString(const char *str, const char *filename, int mode,
+                      PyCompilerFlags *flags, PyArena *arena)
+{
+    PyObject *filename_ob = PyUnicode_FromString(filename);
+    if (filename_ob == NULL) {
+        return NULL;
+    }
+    mod_ty result = PyPegen_ASTFromStringObject(str, filename_ob, mode, flags, arena);
+    Py_XDECREF(filename_ob);
+    return result;
+}
+
+mod_ty
+PyPegen_ASTFromStringObject(const char *str, PyObject* filename, int mode,
+                            PyCompilerFlags *flags, PyArena *arena)
+{
+    if (PySys_Audit("compile", "yO", str, filename) < 0) {
+        return NULL;
+    }
+
+    mod_ty result = _PyPegen_run_parser_from_string(str, mode, filename, flags, arena);
+    return result;
+}
+
+mod_ty
+PyPegen_ASTFromFilename(const char *filename, int mode, PyCompilerFlags *flags, PyArena *arena)
+{
+    PyObject *filename_ob = PyUnicode_FromString(filename);
+    if (filename_ob == NULL) {
+        return NULL;
+    }
+
+    mod_ty result = _PyPegen_run_parser_from_file(filename, mode, filename_ob, flags, arena);
+    Py_XDECREF(filename_ob);
+    return result;
+}
+
+mod_ty
+PyPegen_ASTFromFileObject(FILE *fp, PyObject *filename_ob, int mode,
+                          const char *enc, const char *ps1, const char* ps2,
+                          PyCompilerFlags *flags, int *errcode, PyArena *arena)
+{
+    if (PySys_Audit("compile", "OO", Py_None, filename_ob) < 0) {
+        return NULL;
+    }
+    return _PyPegen_run_parser_from_file_pointer(fp, mode, filename_ob, enc, ps1, ps2,
+                                        flags, errcode, arena);
+}
diff --git a/contrib/tools/python3/src/Parser/pegen/pegen.c b/contrib/tools/python3/src/Parser/pegen/pegen.c
index 974cbf41a3..cdfbc12d16 100644
--- a/contrib/tools/python3/src/Parser/pegen/pegen.c
+++ b/contrib/tools/python3/src/Parser/pegen/pegen.c
@@ -1,2280 +1,2280 @@
-#include <Python.h> 
-#include <errcode.h> 
-#include "../tokenizer.h" 
- 
-#include "pegen.h" 
-#include "parse_string.h" 
-#include "ast.h" 
- 
-PyObject * 
-_PyPegen_new_type_comment(Parser *p, char *s) 
-{ 
-    PyObject *res = PyUnicode_DecodeUTF8(s, strlen(s), NULL); 
-    if (res == NULL) { 
-        return NULL; 
-    } 
-    if (PyArena_AddPyObject(p->arena, res) < 0) { 
-        Py_DECREF(res); 
-        return NULL; 
-    } 
-    return res; 
-} 
- 
-arg_ty 
-_PyPegen_add_type_comment_to_arg(Parser *p, arg_ty a, Token *tc) 
-{ 
-    if (tc == NULL) { 
-        return a; 
-    } 
-    char *bytes = PyBytes_AsString(tc->bytes); 
-    if (bytes == NULL) { 
-        return NULL; 
-    } 
-    PyObject *tco = _PyPegen_new_type_comment(p, bytes); 
-    if (tco == NULL) { 
-        return NULL; 
-    } 
-    return arg(a->arg, a->annotation, tco, 
-               a->lineno, a->col_offset, a->end_lineno, a->end_col_offset, 
-               p->arena); 
-} 
- 
-static int 
-init_normalization(Parser *p) 
-{ 
-    if (p->normalize) { 
-        return 1; 
-    } 
-    PyObject *m = PyImport_ImportModuleNoBlock("unicodedata"); 
-    if (!m) 
-    { 
-        return 0; 
-    } 
-    p->normalize = PyObject_GetAttrString(m, "normalize"); 
-    Py_DECREF(m); 
-    if (!p->normalize) 
-    { 
-        return 0; 
-    } 
-    return 1; 
-} 
- 
-/* Checks if the NOTEQUAL token is valid given the current parser flags 
-0 indicates success and nonzero indicates failure (an exception may be set) */ 
-int 
-_PyPegen_check_barry_as_flufl(Parser *p, Token* t) { 
-    assert(t->bytes != NULL); 
-    assert(t->type == NOTEQUAL); 
- 
-    char* tok_str = PyBytes_AS_STRING(t->bytes); 
-    if (p->flags & PyPARSE_BARRY_AS_BDFL && strcmp(tok_str, "<>") != 0) { 
-        RAISE_SYNTAX_ERROR("with Barry as BDFL, use '<>' instead of '!='"); 
-        return -1; 
-    } 
-    if (!(p->flags & PyPARSE_BARRY_AS_BDFL)) { 
-        return strcmp(tok_str, "!="); 
-    } 
-    return 0; 
-} 
- 
-PyObject * 
-_PyPegen_new_identifier(Parser *p, char *n) 
-{ 
-    PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL); 
-    if (!id) { 
-        goto error; 
-    } 
-    /* PyUnicode_DecodeUTF8 should always return a ready string. */ 
-    assert(PyUnicode_IS_READY(id)); 
-    /* Check whether there are non-ASCII characters in the 
-       identifier; if so, normalize to NFKC. */ 
-    if (!PyUnicode_IS_ASCII(id)) 
-    { 
-        PyObject *id2; 
-        if (!init_normalization(p)) 
-        { 
-            Py_DECREF(id); 
-            goto error; 
-        } 
-        PyObject *form = PyUnicode_InternFromString("NFKC"); 
-        if (form == NULL) 
-        { 
-            Py_DECREF(id); 
-            goto error; 
-        } 
-        PyObject *args[2] = {form, id}; 
-        id2 = _PyObject_FastCall(p->normalize, args, 2); 
-        Py_DECREF(id); 
-        Py_DECREF(form); 
-        if (!id2) { 
-            goto error; 
-        } 
-        if (!PyUnicode_Check(id2)) 
-        { 
-            PyErr_Format(PyExc_TypeError, 
-                         "unicodedata.normalize() must return a string, not " 
-                         "%.200s", 
-                         _PyType_Name(Py_TYPE(id2))); 
-            Py_DECREF(id2); 
-            goto error; 
-        } 
-        id = id2; 
-    } 
-    PyUnicode_InternInPlace(&id); 
-    if (PyArena_AddPyObject(p->arena, id) < 0) 
-    { 
-        Py_DECREF(id); 
-        goto error; 
-    } 
-    return id; 
- 
-error: 
-    p->error_indicator = 1; 
-    return NULL; 
-} 
- 
-static PyObject * 
-_create_dummy_identifier(Parser *p) 
-{ 
-    return _PyPegen_new_identifier(p, ""); 
-} 
- 
-static inline Py_ssize_t 
-byte_offset_to_character_offset(PyObject *line, Py_ssize_t col_offset) 
-{ 
-    const char *str = PyUnicode_AsUTF8(line); 
-    if (!str) { 
-        return 0; 
-    } 
-    assert(col_offset >= 0 && (unsigned long)col_offset <= strlen(str)); 
-    PyObject *text = PyUnicode_DecodeUTF8(str, col_offset, "replace"); 
-    if (!text) { 
-        return 0; 
-    } 
-    Py_ssize_t size = PyUnicode_GET_LENGTH(text); 
-    Py_DECREF(text); 
-    return size; 
-} 
- 
-const char * 
-_PyPegen_get_expr_name(expr_ty e) 
-{ 
-    assert(e != NULL); 
-    switch (e->kind) { 
-        case Attribute_kind: 
-            return "attribute"; 
-        case Subscript_kind: 
-            return "subscript"; 
-        case Starred_kind: 
-            return "starred"; 
-        case Name_kind: 
-            return "name"; 
-        case List_kind: 
-            return "list"; 
-        case Tuple_kind: 
-            return "tuple"; 
-        case Lambda_kind: 
-            return "lambda"; 
-        case Call_kind: 
-            return "function call"; 
-        case BoolOp_kind: 
-        case BinOp_kind: 
-        case UnaryOp_kind: 
-            return "operator"; 
-        case GeneratorExp_kind: 
-            return "generator expression"; 
-        case Yield_kind: 
-        case YieldFrom_kind: 
-            return "yield expression"; 
-        case Await_kind: 
-            return "await expression"; 
-        case ListComp_kind: 
-            return "list comprehension"; 
-        case SetComp_kind: 
-            return "set comprehension"; 
-        case DictComp_kind: 
-            return "dict comprehension"; 
-        case Dict_kind: 
-            return "dict display"; 
-        case Set_kind: 
-            return "set display"; 
-        case JoinedStr_kind: 
-        case FormattedValue_kind: 
-            return "f-string expression"; 
-        case Constant_kind: { 
-            PyObject *value = e->v.Constant.value; 
-            if (value == Py_None) { 
-                return "None"; 
-            } 
-            if (value == Py_False) { 
-                return "False"; 
-            } 
-            if (value == Py_True) { 
-                return "True"; 
-            } 
-            if (value == Py_Ellipsis) { 
-                return "Ellipsis"; 
-            } 
-            return "literal"; 
-        } 
-        case Compare_kind: 
-            return "comparison"; 
-        case IfExp_kind: 
-            return "conditional expression"; 
-        case NamedExpr_kind: 
-            return "named expression"; 
-        default: 
-            PyErr_Format(PyExc_SystemError, 
-                         "unexpected expression in assignment %d (line %d)", 
-                         e->kind, e->lineno); 
-            return NULL; 
-    } 
-} 
- 
-static int 
-raise_decode_error(Parser *p) 
-{ 
-    assert(PyErr_Occurred()); 
-    const char *errtype = NULL; 
-    if (PyErr_ExceptionMatches(PyExc_UnicodeError)) { 
-        errtype = "unicode error"; 
-    } 
-    else if (PyErr_ExceptionMatches(PyExc_ValueError)) { 
-        errtype = "value error"; 
-    } 
-    if (errtype) { 
-        PyObject *type; 
-        PyObject *value; 
-        PyObject *tback; 
-        PyObject *errstr; 
-        PyErr_Fetch(&type, &value, &tback); 
-        errstr = PyObject_Str(value); 
-        if (errstr) { 
-            RAISE_SYNTAX_ERROR("(%s) %U", errtype, errstr); 
-            Py_DECREF(errstr); 
-        } 
-        else { 
-            PyErr_Clear(); 
-            RAISE_SYNTAX_ERROR("(%s) unknown error", errtype); 
-        } 
-        Py_XDECREF(type); 
-        Py_XDECREF(value); 
-        Py_XDECREF(tback); 
-    } 
- 
-    return -1; 
-} 
- 
-static void 
-raise_tokenizer_init_error(PyObject *filename) 
-{ 
-    if (!(PyErr_ExceptionMatches(PyExc_LookupError) 
-          || PyErr_ExceptionMatches(PyExc_SyntaxError) 
-          || PyErr_ExceptionMatches(PyExc_ValueError) 
-          || PyErr_ExceptionMatches(PyExc_UnicodeDecodeError))) { 
-        return; 
-    } 
-    PyObject *errstr = NULL; 
-    PyObject *tuple = NULL; 
-    PyObject *type; 
-    PyObject *value; 
-    PyObject *tback; 
-    PyErr_Fetch(&type, &value, &tback); 
-    errstr = PyObject_Str(value); 
-    if (!errstr) { 
-        goto error; 
-    } 
- 
-    PyObject *tmp = Py_BuildValue("(OiiO)", filename, 0, -1, Py_None); 
-    if (!tmp) { 
-        goto error; 
-    } 
- 
-    tuple = PyTuple_Pack(2, errstr, tmp); 
-    Py_DECREF(tmp); 
-    if (!value) { 
-        goto error; 
-    } 
-    PyErr_SetObject(PyExc_SyntaxError, tuple); 
- 
-error: 
-    Py_XDECREF(type); 
-    Py_XDECREF(value); 
-    Py_XDECREF(tback); 
-    Py_XDECREF(errstr); 
-    Py_XDECREF(tuple); 
-} 
- 
-static int 
-tokenizer_error(Parser *p) 
-{ 
-    if (PyErr_Occurred()) { 
-        return -1; 
-    } 
- 
-    const char *msg = NULL; 
-    PyObject* errtype = PyExc_SyntaxError; 
-    Py_ssize_t col_offset = -1; 
-    switch (p->tok->done) { 
-        case E_TOKEN: 
-            msg = "invalid token"; 
-            break; 
-        case E_EOFS: 
-            RAISE_SYNTAX_ERROR("EOF while scanning triple-quoted string literal"); 
-            return -1; 
-        case E_EOLS: 
-            RAISE_SYNTAX_ERROR("EOL while scanning string literal"); 
-            return -1; 
-        case E_EOF: 
-            RAISE_SYNTAX_ERROR("unexpected EOF while parsing"); 
-            return -1; 
-        case E_DEDENT: 
-            RAISE_INDENTATION_ERROR("unindent does not match any outer indentation level"); 
-            return -1; 
-        case E_INTR: 
-            if (!PyErr_Occurred()) { 
-                PyErr_SetNone(PyExc_KeyboardInterrupt); 
-            } 
-            return -1; 
-        case E_NOMEM: 
-            PyErr_NoMemory(); 
-            return -1; 
-        case E_TABSPACE: 
-            errtype = PyExc_TabError; 
-            msg = "inconsistent use of tabs and spaces in indentation"; 
-            break; 
-        case E_TOODEEP: 
-            errtype = PyExc_IndentationError; 
-            msg = "too many levels of indentation"; 
-            break; 
-        case E_LINECONT: { 
-            col_offset = p->tok->cur - p->tok->buf - 1; 
-            msg = "unexpected character after line continuation character"; 
-            break; 
-        } 
-        default: 
-            msg = "unknown parsing error"; 
-    } 
- 
-    RAISE_ERROR_KNOWN_LOCATION(p, errtype, p->tok->lineno, 
-                               col_offset >= 0 ? col_offset : 0, msg); 
-    return -1; 
-} 
- 
-void * 
-_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...) 
-{ 
-    if (p->fill == 0) { 
-        va_list va; 
-        va_start(va, errmsg); 
-        _PyPegen_raise_error_known_location(p, errtype, 0, 0, errmsg, va); 
-        va_end(va); 
-        return NULL; 
-    } 
- 
-    Token *t = p->known_err_token != NULL ? p->known_err_token : p->tokens[p->fill - 1]; 
-    Py_ssize_t col_offset; 
-    if (t->col_offset == -1) { 
-        col_offset = Py_SAFE_DOWNCAST(p->tok->cur - p->tok->buf, 
-                                      intptr_t, int); 
-    } else { 
-        col_offset = t->col_offset + 1; 
-    } 
- 
-    va_list va; 
-    va_start(va, errmsg); 
-    _PyPegen_raise_error_known_location(p, errtype, t->lineno, 
-                                        col_offset, errmsg, va); 
-    va_end(va); 
- 
-    return NULL; 
-} 
- 
-void * 
-_PyPegen_raise_error_known_location(Parser *p, PyObject *errtype, 
-                                    Py_ssize_t lineno, Py_ssize_t col_offset, 
-                                    const char *errmsg, va_list va) 
-{ 
-    PyObject *value = NULL; 
-    PyObject *errstr = NULL; 
-    PyObject *error_line = NULL; 
-    PyObject *tmp = NULL; 
-    p->error_indicator = 1; 
- 
-    if (p->start_rule == Py_fstring_input) { 
-        const char *fstring_msg = "f-string: "; 
-        Py_ssize_t len = strlen(fstring_msg) + strlen(errmsg); 
- 
-        char *new_errmsg = PyMem_RawMalloc(len + 1); // Lengths of both strings plus NULL character 
-        if (!new_errmsg) { 
-            return (void *) PyErr_NoMemory(); 
-        } 
- 
-        // Copy both strings into new buffer 
-        memcpy(new_errmsg, fstring_msg, strlen(fstring_msg)); 
-        memcpy(new_errmsg + strlen(fstring_msg), errmsg, strlen(errmsg)); 
-        new_errmsg[len] = 0; 
-        errmsg = new_errmsg; 
-    } 
-    errstr = PyUnicode_FromFormatV(errmsg, va); 
-    if (!errstr) { 
-        goto error; 
-    } 
- 
-    if (p->start_rule == Py_file_input) { 
-        error_line = PyErr_ProgramTextObject(p->tok->filename, (int) lineno); 
-    } 
- 
-    if (!error_line) { 
-        Py_ssize_t size = p->tok->inp - p->tok->buf; 
-        error_line = PyUnicode_DecodeUTF8(p->tok->buf, size, "replace"); 
-        if (!error_line) { 
-            goto error; 
-        } 
-    } 
- 
-    if (p->start_rule == Py_fstring_input) { 
-        col_offset -= p->starting_col_offset; 
-    } 
-    Py_ssize_t col_number = col_offset; 
- 
-    if (p->tok->encoding != NULL) { 
-        col_number = byte_offset_to_character_offset(error_line, col_offset); 
-    } 
- 
-    tmp = Py_BuildValue("(OiiN)", p->tok->filename, lineno, col_number, error_line); 
-    if (!tmp) { 
-        goto error; 
-    } 
-    value = PyTuple_Pack(2, errstr, tmp); 
-    Py_DECREF(tmp); 
-    if (!value) { 
-        goto error; 
-    } 
-    PyErr_SetObject(errtype, value); 
- 
-    Py_DECREF(errstr); 
-    Py_DECREF(value); 
-    if (p->start_rule == Py_fstring_input) { 
-        PyMem_RawFree((void *)errmsg); 
-    } 
-    return NULL; 
- 
-error: 
-    Py_XDECREF(errstr); 
-    Py_XDECREF(error_line); 
-    if (p->start_rule == Py_fstring_input) { 
-        PyMem_RawFree((void *)errmsg); 
-    } 
-    return NULL; 
-} 
- 
-#if 0 
-static const char * 
-token_name(int type) 
-{ 
-    if (0 <= type && type <= N_TOKENS) { 
-        return _PyParser_TokenNames[type]; 
-    } 
-    return "<Huh?>"; 
-} 
-#endif 
- 
-// Here, mark is the start of the node, while p->mark is the end. 
-// If node==NULL, they should be the same. 
-int 
-_PyPegen_insert_memo(Parser *p, int mark, int type, void *node) 
-{ 
-    // Insert in front 
-    Memo *m = PyArena_Malloc(p->arena, sizeof(Memo)); 
-    if (m == NULL) { 
-        return -1; 
-    } 
-    m->type = type; 
-    m->node = node; 
-    m->mark = p->mark; 
-    m->next = p->tokens[mark]->memo; 
-    p->tokens[mark]->memo = m; 
-    return 0; 
-} 
- 
-// Like _PyPegen_insert_memo(), but updates an existing node if found. 
-int 
-_PyPegen_update_memo(Parser *p, int mark, int type, void *node) 
-{ 
-    for (Memo *m = p->tokens[mark]->memo; m != NULL; m = m->next) { 
-        if (m->type == type) { 
-            // Update existing node. 
-            m->node = node; 
-            m->mark = p->mark; 
-            return 0; 
-        } 
-    } 
-    // Insert new node. 
-    return _PyPegen_insert_memo(p, mark, type, node); 
-} 
- 
-// Return dummy NAME. 
-void * 
-_PyPegen_dummy_name(Parser *p, ...) 
-{ 
-    static void *cache = NULL; 
- 
-    if (cache != NULL) { 
-        return cache; 
-    } 
- 
-    PyObject *id = _create_dummy_identifier(p); 
-    if (!id) { 
-        return NULL; 
-    } 
-    cache = Name(id, Load, 1, 0, 1, 0, p->arena); 
-    return cache; 
-} 
- 
-static int 
-_get_keyword_or_name_type(Parser *p, const char *name, int name_len) 
-{ 
-    assert(name_len > 0); 
-    if (name_len >= p->n_keyword_lists || 
-        p->keywords[name_len] == NULL || 
-        p->keywords[name_len]->type == -1) { 
-        return NAME; 
-    } 
-    for (KeywordToken *k = p->keywords[name_len]; k != NULL && k->type != -1; k++) { 
-        if (strncmp(k->str, name, name_len) == 0) { 
-            return k->type; 
-        } 
-    } 
-    return NAME; 
-} 
- 
-static int 
-growable_comment_array_init(growable_comment_array *arr, size_t initial_size) { 
-    assert(initial_size > 0); 
-    arr->items = PyMem_Malloc(initial_size * sizeof(*arr->items)); 
-    arr->size = initial_size; 
-    arr->num_items = 0; 
- 
-    return arr->items != NULL; 
-} 
- 
-static int 
-growable_comment_array_add(growable_comment_array *arr, int lineno, char *comment) { 
-    if (arr->num_items >= arr->size) { 
-        size_t new_size = arr->size * 2; 
-        void *new_items_array = PyMem_Realloc(arr->items, new_size * sizeof(*arr->items)); 
-        if (!new_items_array) { 
-            return 0; 
-        } 
-        arr->items = new_items_array; 
-        arr->size = new_size; 
-    } 
- 
-    arr->items[arr->num_items].lineno = lineno; 
-    arr->items[arr->num_items].comment = comment;  // Take ownership 
-    arr->num_items++; 
-    return 1; 
-} 
- 
-static void 
-growable_comment_array_deallocate(growable_comment_array *arr) { 
-    for (unsigned i = 0; i < arr->num_items; i++) { 
-        PyMem_Free(arr->items[i].comment); 
-    } 
-    PyMem_Free(arr->items); 
-} 
- 
-int 
-_PyPegen_fill_token(Parser *p) 
-{ 
-    const char *start; 
-    const char *end; 
-    int type = PyTokenizer_Get(p->tok, &start, &end); 
- 
-    // Record and skip '# type: ignore' comments 
-    while (type == TYPE_IGNORE) { 
-        Py_ssize_t len = end - start; 
-        char *tag = PyMem_Malloc(len + 1); 
-        if (tag == NULL) { 
-            PyErr_NoMemory(); 
-            return -1; 
-        } 
-        strncpy(tag, start, len); 
-        tag[len] = '\0'; 
-        // Ownership of tag passes to the growable array 
-        if (!growable_comment_array_add(&p->type_ignore_comments, p->tok->lineno, tag)) { 
-            PyErr_NoMemory(); 
-            return -1; 
-        } 
-        type = PyTokenizer_Get(p->tok, &start, &end); 
-    } 
- 
-    if (type == ENDMARKER && p->start_rule == Py_single_input && p->parsing_started) { 
-        type = NEWLINE; /* Add an extra newline */ 
-        p->parsing_started = 0; 
- 
-        if (p->tok->indent && !(p->flags & PyPARSE_DONT_IMPLY_DEDENT)) { 
-            p->tok->pendin = -p->tok->indent; 
-            p->tok->indent = 0; 
-        } 
-    } 
-    else { 
-        p->parsing_started = 1; 
-    } 
- 
-    if (p->fill == p->size) { 
-        int newsize = p->size * 2; 
-        Token **new_tokens = PyMem_Realloc(p->tokens, newsize * sizeof(Token *)); 
-        if (new_tokens == NULL) { 
-            PyErr_NoMemory(); 
-            return -1; 
-        } 
-        p->tokens = new_tokens; 
- 
-        for (int i = p->size; i < newsize; i++) { 
-            p->tokens[i] = PyMem_Malloc(sizeof(Token)); 
-            if (p->tokens[i] == NULL) { 
-                p->size = i; // Needed, in order to cleanup correctly after parser fails 
-                PyErr_NoMemory(); 
-                return -1; 
-            } 
-            memset(p->tokens[i], '\0', sizeof(Token)); 
-        } 
-        p->size = newsize; 
-    } 
- 
-    Token *t = p->tokens[p->fill]; 
-    t->type = (type == NAME) ? _get_keyword_or_name_type(p, start, (int)(end - start)) : type; 
-    t->bytes = PyBytes_FromStringAndSize(start, end - start); 
-    if (t->bytes == NULL) { 
-        return -1; 
-    } 
-    if (PyArena_AddPyObject(p->arena, t->bytes) < 0) { 
-        Py_DECREF(t->bytes); 
-        return -1; 
-    } 
- 
-    int lineno = type == STRING ? p->tok->first_lineno : p->tok->lineno; 
-    const char *line_start = type == STRING ? p->tok->multi_line_start : p->tok->line_start; 
-    int end_lineno = p->tok->lineno; 
-    int col_offset = -1; 
-    int end_col_offset = -1; 
-    if (start != NULL && start >= line_start) { 
-        col_offset = (int)(start - line_start); 
-    } 
-    if (end != NULL && end >= p->tok->line_start) { 
-        end_col_offset = (int)(end - p->tok->line_start); 
-    } 
- 
-    t->lineno = p->starting_lineno + lineno; 
-    t->col_offset = p->tok->lineno == 1 ? p->starting_col_offset + col_offset : col_offset; 
-    t->end_lineno = p->starting_lineno + end_lineno; 
-    t->end_col_offset = p->tok->lineno == 1 ? p->starting_col_offset + end_col_offset : end_col_offset; 
- 
-    p->fill += 1; 
- 
-    if (type == ERRORTOKEN) { 
-        if (p->tok->done == E_DECODE) { 
-            return raise_decode_error(p); 
-        } 
-        return tokenizer_error(p); 
- 
-    } 
- 
-    return 0; 
-} 
- 
-// Instrumentation to count the effectiveness of memoization. 
-// The array counts the number of tokens skipped by memoization, 
-// indexed by type. 
- 
-#define NSTATISTICS 2000 
-static long memo_statistics[NSTATISTICS]; 
- 
-void 
-_PyPegen_clear_memo_statistics() 
-{ 
-    for (int i = 0; i < NSTATISTICS; i++) { 
-        memo_statistics[i] = 0; 
-    } 
-} 
- 
-PyObject * 
-_PyPegen_get_memo_statistics() 
-{ 
-    PyObject *ret = PyList_New(NSTATISTICS); 
-    if (ret == NULL) { 
-        return NULL; 
-    } 
-    for (int i = 0; i < NSTATISTICS; i++) { 
-        PyObject *value = PyLong_FromLong(memo_statistics[i]); 
-        if (value == NULL) { 
-            Py_DECREF(ret); 
-            return NULL; 
-        } 
-        // PyList_SetItem borrows a reference to value. 
-        if (PyList_SetItem(ret, i, value) < 0) { 
-            Py_DECREF(ret); 
-            return NULL; 
-        } 
-    } 
-    return ret; 
-} 
- 
-int  // bool 
-_PyPegen_is_memoized(Parser *p, int type, void *pres) 
-{ 
-    if (p->mark == p->fill) { 
-        if (_PyPegen_fill_token(p) < 0) { 
-            p->error_indicator = 1; 
-            return -1; 
-        } 
-    } 
- 
-    Token *t = p->tokens[p->mark]; 
- 
-    for (Memo *m = t->memo; m != NULL; m = m->next) { 
-        if (m->type == type) { 
-            if (0 <= type && type < NSTATISTICS) { 
-                long count = m->mark - p->mark; 
-                // A memoized negative result counts for one. 
-                if (count <= 0) { 
-                    count = 1; 
-                } 
-                memo_statistics[type] += count; 
-            } 
-            p->mark = m->mark; 
-            *(void **)(pres) = m->node; 
-            return 1; 
-        } 
-    } 
-    return 0; 
-} 
- 
-int 
-_PyPegen_lookahead_with_name(int positive, expr_ty (func)(Parser *), Parser *p) 
-{ 
-    int mark = p->mark; 
-    void *res = func(p); 
-    p->mark = mark; 
-    return (res != NULL) == positive; 
-} 
- 
-int 
-_PyPegen_lookahead_with_string(int positive, expr_ty (func)(Parser *, const char*), Parser *p, const char* arg) 
-{ 
-    int mark = p->mark; 
-    void *res = func(p, arg); 
-    p->mark = mark; 
-    return (res != NULL) == positive; 
-} 
- 
-int 
-_PyPegen_lookahead_with_int(int positive, Token *(func)(Parser *, int), Parser *p, int arg) 
-{ 
-    int mark = p->mark; 
-    void *res = func(p, arg); 
-    p->mark = mark; 
-    return (res != NULL) == positive; 
-} 
- 
-int 
-_PyPegen_lookahead(int positive, void *(func)(Parser *), Parser *p) 
-{ 
-    int mark = p->mark; 
-    void *res = (void*)func(p); 
-    p->mark = mark; 
-    return (res != NULL) == positive; 
-} 
- 
-Token * 
-_PyPegen_expect_token(Parser *p, int type) 
-{ 
-    if (p->mark == p->fill) { 
-        if (_PyPegen_fill_token(p) < 0) { 
-            p->error_indicator = 1; 
-            return NULL; 
-        } 
-    } 
-    Token *t = p->tokens[p->mark]; 
-    if (t->type != type) { 
-        return NULL; 
-    } 
-    p->mark += 1; 
-    return t; 
-} 
- 
-expr_ty 
-_PyPegen_expect_soft_keyword(Parser *p, const char *keyword) 
-{ 
-    if (p->mark == p->fill) { 
-        if (_PyPegen_fill_token(p) < 0) { 
-            p->error_indicator = 1; 
-            return NULL; 
-        } 
-    } 
-    Token *t = p->tokens[p->mark]; 
-    if (t->type != NAME) { 
-        return NULL; 
-    } 
-    char* s = PyBytes_AsString(t->bytes); 
-    if (!s) { 
-        p->error_indicator = 1; 
-        return NULL; 
-    } 
-    if (strcmp(s, keyword) != 0) { 
-        return NULL; 
-    } 
-    return _PyPegen_name_token(p); 
-} 
- 
-Token * 
-_PyPegen_get_last_nonnwhitespace_token(Parser *p) 
-{ 
-    assert(p->mark >= 0); 
-    Token *token = NULL; 
-    for (int m = p->mark - 1; m >= 0; m--) { 
-        token = p->tokens[m]; 
-        if (token->type != ENDMARKER && (token->type < NEWLINE || token->type > DEDENT)) { 
-            break; 
-        } 
-    } 
-    return token; 
-} 
- 
-expr_ty 
-_PyPegen_name_token(Parser *p) 
-{ 
-    Token *t = _PyPegen_expect_token(p, NAME); 
-    if (t == NULL) { 
-        return NULL; 
-    } 
-    char* s = PyBytes_AsString(t->bytes); 
-    if (!s) { 
-        p->error_indicator = 1; 
-        return NULL; 
-    } 
-    PyObject *id = _PyPegen_new_identifier(p, s); 
-    if (id == NULL) { 
-        p->error_indicator = 1; 
-        return NULL; 
-    } 
-    return Name(id, Load, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset, 
-                p->arena); 
-} 
- 
-void * 
-_PyPegen_string_token(Parser *p) 
-{ 
-    return _PyPegen_expect_token(p, STRING); 
-} 
- 
-static PyObject * 
-parsenumber_raw(const char *s) 
-{ 
-    const char *end; 
-    long x; 
-    double dx; 
-    Py_complex compl; 
-    int imflag; 
- 
-    assert(s != NULL); 
-    errno = 0; 
-    end = s + strlen(s) - 1; 
-    imflag = *end == 'j' || *end == 'J'; 
-    if (s[0] == '0') { 
-        x = (long)PyOS_strtoul(s, (char **)&end, 0); 
-        if (x < 0 && errno == 0) { 
-            return PyLong_FromString(s, (char **)0, 0); 
-        } 
-    } 
-    else { 
-        x = PyOS_strtol(s, (char **)&end, 0); 
-    } 
-    if (*end == '\0') { 
-        if (errno != 0) { 
-            return PyLong_FromString(s, (char **)0, 0); 
-        } 
-        return PyLong_FromLong(x); 
-    } 
-    /* XXX Huge floats may silently fail */ 
-    if (imflag) { 
-        compl.real = 0.; 
-        compl.imag = PyOS_string_to_double(s, (char **)&end, NULL); 
-        if (compl.imag == -1.0 && PyErr_Occurred()) { 
-            return NULL; 
-        } 
-        return PyComplex_FromCComplex(compl); 
-    } 
-    dx = PyOS_string_to_double(s, NULL, NULL); 
-    if (dx == -1.0 && PyErr_Occurred()) { 
-        return NULL; 
-    } 
-    return PyFloat_FromDouble(dx); 
-} 
- 
-static PyObject * 
-parsenumber(const char *s) 
-{ 
-    char *dup; 
-    char *end; 
-    PyObject *res = NULL; 
- 
-    assert(s != NULL); 
- 
-    if (strchr(s, '_') == NULL) { 
-        return parsenumber_raw(s); 
-    } 
-    /* Create a duplicate without underscores. */ 
-    dup = PyMem_Malloc(strlen(s) + 1); 
-    if (dup == NULL) { 
-        return PyErr_NoMemory(); 
-    } 
-    end = dup; 
-    for (; *s; s++) { 
-        if (*s != '_') { 
-            *end++ = *s; 
-        } 
-    } 
-    *end = '\0'; 
-    res = parsenumber_raw(dup); 
-    PyMem_Free(dup); 
-    return res; 
-} 
- 
-expr_ty 
-_PyPegen_number_token(Parser *p) 
-{ 
-    Token *t = _PyPegen_expect_token(p, NUMBER); 
-    if (t == NULL) { 
-        return NULL; 
-    } 
- 
-    char *num_raw = PyBytes_AsString(t->bytes); 
-    if (num_raw == NULL) { 
-        p->error_indicator = 1; 
-        return NULL; 
-    } 
- 
-    if (p->feature_version < 6 && strchr(num_raw, '_') != NULL) { 
-        p->error_indicator = 1; 
-        return RAISE_SYNTAX_ERROR("Underscores in numeric literals are only supported " 
-                                  "in Python 3.6 and greater"); 
-    } 
- 
-    PyObject *c = parsenumber(num_raw); 
- 
-    if (c == NULL) { 
-        p->error_indicator = 1; 
-        return NULL; 
-    } 
- 
-    if (PyArena_AddPyObject(p->arena, c) < 0) { 
-        Py_DECREF(c); 
-        p->error_indicator = 1; 
-        return NULL; 
-    } 
- 
-    return Constant(c, NULL, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset, 
-                    p->arena); 
-} 
- 
-static int // bool 
-newline_in_string(Parser *p, const char *cur) 
-{ 
-    for (const char *c = cur; c >= p->tok->buf; c--) { 
-        if (*c == '\'' || *c == '"') { 
-            return 1; 
-        } 
-    } 
-    return 0; 
-} 
- 
-/* Check that the source for a single input statement really is a single 
-   statement by looking at what is left in the buffer after parsing. 
-   Trailing whitespace and comments are OK. */ 
-static int // bool 
-bad_single_statement(Parser *p) 
-{ 
-    const char *cur = strchr(p->tok->buf, '\n'); 
- 
-    /* Newlines are allowed if preceded by a line continuation character 
-       or if they appear inside a string. */ 
-    if (!cur || (cur != p->tok->buf && *(cur - 1) == '\\') 
-             || newline_in_string(p, cur)) { 
-        return 0; 
-    } 
-    char c = *cur; 
- 
-    for (;;) { 
-        while (c == ' ' || c == '\t' || c == '\n' || c == '\014') { 
-            c = *++cur; 
-        } 
- 
-        if (!c) { 
-            return 0; 
-        } 
- 
-        if (c != '#') { 
-            return 1; 
-        } 
- 
-        /* Suck up comment. */ 
-        while (c && c != '\n') { 
-            c = *++cur; 
-        } 
-    } 
-} 
- 
-void 
-_PyPegen_Parser_Free(Parser *p) 
-{ 
-    Py_XDECREF(p->normalize); 
-    for (int i = 0; i < p->size; i++) { 
-        PyMem_Free(p->tokens[i]); 
-    } 
-    PyMem_Free(p->tokens); 
-    growable_comment_array_deallocate(&p->type_ignore_comments); 
-    PyMem_Free(p); 
-} 
- 
-static int 
-compute_parser_flags(PyCompilerFlags *flags) 
-{ 
-    int parser_flags = 0; 
-    if (!flags) { 
-        return 0; 
-    } 
-    if (flags->cf_flags & PyCF_DONT_IMPLY_DEDENT) { 
-        parser_flags |= PyPARSE_DONT_IMPLY_DEDENT; 
-    } 
-    if (flags->cf_flags & PyCF_IGNORE_COOKIE) { 
-        parser_flags |= PyPARSE_IGNORE_COOKIE; 
-    } 
-    if (flags->cf_flags & CO_FUTURE_BARRY_AS_BDFL) { 
-        parser_flags |= PyPARSE_BARRY_AS_BDFL; 
-    } 
-    if (flags->cf_flags & PyCF_TYPE_COMMENTS) { 
-        parser_flags |= PyPARSE_TYPE_COMMENTS; 
-    } 
-    if ((flags->cf_flags & PyCF_ONLY_AST) && flags->cf_feature_version < 7) { 
-        parser_flags |= PyPARSE_ASYNC_HACKS; 
-    } 
-    return parser_flags; 
-} 
- 
-Parser * 
-_PyPegen_Parser_New(struct tok_state *tok, int start_rule, int flags, 
-                    int feature_version, int *errcode, PyArena *arena) 
-{ 
-    Parser *p = PyMem_Malloc(sizeof(Parser)); 
-    if (p == NULL) { 
-        return (Parser *) PyErr_NoMemory(); 
-    } 
-    assert(tok != NULL); 
-    tok->type_comments = (flags & PyPARSE_TYPE_COMMENTS) > 0; 
-    tok->async_hacks = (flags & PyPARSE_ASYNC_HACKS) > 0; 
-    p->tok = tok; 
-    p->keywords = NULL; 
-    p->n_keyword_lists = -1; 
-    p->tokens = PyMem_Malloc(sizeof(Token *)); 
-    if (!p->tokens) { 
-        PyMem_Free(p); 
-        return (Parser *) PyErr_NoMemory(); 
-    } 
-    p->tokens[0] = PyMem_Calloc(1, sizeof(Token)); 
-    if (!p->tokens) { 
-        PyMem_Free(p->tokens); 
-        PyMem_Free(p); 
-        return (Parser *) PyErr_NoMemory(); 
-    } 
-    if (!growable_comment_array_init(&p->type_ignore_comments, 10)) { 
-        PyMem_Free(p->tokens[0]); 
-        PyMem_Free(p->tokens); 
-        PyMem_Free(p); 
-        return (Parser *) PyErr_NoMemory(); 
-    } 
- 
-    p->mark = 0; 
-    p->fill = 0; 
-    p->size = 1; 
- 
-    p->errcode = errcode; 
-    p->arena = arena; 
-    p->start_rule = start_rule; 
-    p->parsing_started = 0; 
-    p->normalize = NULL; 
-    p->error_indicator = 0; 
- 
-    p->starting_lineno = 0; 
-    p->starting_col_offset = 0; 
-    p->flags = flags; 
-    p->feature_version = feature_version; 
-    p->known_err_token = NULL; 
-    p->level = 0; 
-    p->call_invalid_rules = 0; 
- 
-    return p; 
-} 
- 
-static void 
-reset_parser_state(Parser *p) 
-{ 
-    for (int i = 0; i < p->fill; i++) { 
-        p->tokens[i]->memo = NULL; 
-    } 
-    p->mark = 0; 
-    p->call_invalid_rules = 1; 
-} 
- 
-void * 
-_PyPegen_run_parser(Parser *p) 
-{ 
-    void *res = _PyPegen_parse(p); 
-    if (res == NULL) { 
-        reset_parser_state(p); 
-        _PyPegen_parse(p); 
-        if (PyErr_Occurred()) { 
-            return NULL; 
-        } 
-        if (p->fill == 0) { 
-            RAISE_SYNTAX_ERROR("error at start before reading any input"); 
-        } 
-        else if (p->tok->done == E_EOF) { 
-            RAISE_SYNTAX_ERROR("unexpected EOF while parsing"); 
-        } 
-        else { 
-            if (p->tokens[p->fill-1]->type == INDENT) { 
-                RAISE_INDENTATION_ERROR("unexpected indent"); 
-            } 
-            else if (p->tokens[p->fill-1]->type == DEDENT) { 
-                RAISE_INDENTATION_ERROR("unexpected unindent"); 
-            } 
-            else { 
-                RAISE_SYNTAX_ERROR("invalid syntax"); 
-            } 
-        } 
-        return NULL; 
-    } 
- 
-    if (p->start_rule == Py_single_input && bad_single_statement(p)) { 
-        p->tok->done = E_BADSINGLE; // This is not necessary for now, but might be in the future 
-        return RAISE_SYNTAX_ERROR("multiple statements found while compiling a single statement"); 
-    } 
- 
-#if defined(Py_DEBUG) && defined(Py_BUILD_CORE) 
-    if (p->start_rule == Py_single_input || 
-        p->start_rule == Py_file_input || 
-        p->start_rule == Py_eval_input) 
-    { 
-        assert(PyAST_Validate(res)); 
-    } 
-#endif 
-    return res; 
-} 
- 
-mod_ty 
-_PyPegen_run_parser_from_file_pointer(FILE *fp, int start_rule, PyObject *filename_ob, 
-                             const char *enc, const char *ps1, const char *ps2, 
-                             PyCompilerFlags *flags, int *errcode, PyArena *arena) 
-{ 
-    struct tok_state *tok = PyTokenizer_FromFile(fp, enc, ps1, ps2); 
-    if (tok == NULL) { 
-        if (PyErr_Occurred()) { 
-            raise_tokenizer_init_error(filename_ob); 
-            return NULL; 
-        } 
-        return NULL; 
-    } 
-    // This transfers the ownership to the tokenizer 
-    tok->filename = filename_ob; 
-    Py_INCREF(filename_ob); 
- 
-    // From here on we need to clean up even if there's an error 
-    mod_ty result = NULL; 
- 
-    int parser_flags = compute_parser_flags(flags); 
-    Parser *p = _PyPegen_Parser_New(tok, start_rule, parser_flags, PY_MINOR_VERSION, 
-                                    errcode, arena); 
-    if (p == NULL) { 
-        goto error; 
-    } 
- 
-    result = _PyPegen_run_parser(p); 
-    _PyPegen_Parser_Free(p); 
- 
-error: 
-    PyTokenizer_Free(tok); 
-    return result; 
-} 
- 
-mod_ty 
-_PyPegen_run_parser_from_file(const char *filename, int start_rule, 
-                     PyObject *filename_ob, PyCompilerFlags *flags, PyArena *arena) 
-{ 
-    FILE *fp = fopen(filename, "rb"); 
-    if (fp == NULL) { 
-        PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename); 
-        return NULL; 
-    } 
- 
-    mod_ty result = _PyPegen_run_parser_from_file_pointer(fp, start_rule, filename_ob, 
-                                                 NULL, NULL, NULL, flags, NULL, arena); 
- 
-    fclose(fp); 
-    return result; 
-} 
- 
-mod_ty 
-_PyPegen_run_parser_from_string(const char *str, int start_rule, PyObject *filename_ob, 
-                       PyCompilerFlags *flags, PyArena *arena) 
-{ 
-    int exec_input = start_rule == Py_file_input; 
- 
-    struct tok_state *tok; 
-    if (flags != NULL && flags->cf_flags & PyCF_IGNORE_COOKIE) { 
-        tok = PyTokenizer_FromUTF8(str, exec_input); 
-    } else { 
-        tok = PyTokenizer_FromString(str, exec_input); 
-    } 
-    if (tok == NULL) { 
-        if (PyErr_Occurred()) { 
-            raise_tokenizer_init_error(filename_ob); 
-        } 
-        return NULL; 
-    } 
-    // This transfers the ownership to the tokenizer 
-    tok->filename = filename_ob; 
-    Py_INCREF(filename_ob); 
- 
-    // We need to clear up from here on 
-    mod_ty result = NULL; 
- 
-    int parser_flags = compute_parser_flags(flags); 
-    int feature_version = flags && (flags->cf_flags & PyCF_ONLY_AST) ? 
-        flags->cf_feature_version : PY_MINOR_VERSION; 
-    Parser *p = _PyPegen_Parser_New(tok, start_rule, parser_flags, feature_version, 
-                                    NULL, arena); 
-    if (p == NULL) { 
-        goto error; 
-    } 
- 
-    result = _PyPegen_run_parser(p); 
-    _PyPegen_Parser_Free(p); 
- 
-error: 
-    PyTokenizer_Free(tok); 
-    return result; 
-} 
- 
-void * 
-_PyPegen_interactive_exit(Parser *p) 
-{ 
-    if (p->errcode) { 
-        *(p->errcode) = E_EOF; 
-    } 
-    return NULL; 
-} 
- 
-/* Creates a single-element asdl_seq* that contains a */ 
-asdl_seq * 
-_PyPegen_singleton_seq(Parser *p, void *a) 
-{ 
-    assert(a != NULL); 
-    asdl_seq *seq = _Py_asdl_seq_new(1, p->arena); 
-    if (!seq) { 
-        return NULL; 
-    } 
-    asdl_seq_SET(seq, 0, a); 
-    return seq; 
-} 
- 
-/* Creates a copy of seq and prepends a to it */ 
-asdl_seq * 
-_PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq) 
-{ 
-    assert(a != NULL); 
-    if (!seq) { 
-        return _PyPegen_singleton_seq(p, a); 
-    } 
- 
-    asdl_seq *new_seq = _Py_asdl_seq_new(asdl_seq_LEN(seq) + 1, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
- 
-    asdl_seq_SET(new_seq, 0, a); 
-    for (Py_ssize_t i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) { 
-        asdl_seq_SET(new_seq, i, asdl_seq_GET(seq, i - 1)); 
-    } 
-    return new_seq; 
-} 
- 
-/* Creates a copy of seq and appends a to it */ 
-asdl_seq * 
-_PyPegen_seq_append_to_end(Parser *p, asdl_seq *seq, void *a) 
-{ 
-    assert(a != NULL); 
-    if (!seq) { 
-        return _PyPegen_singleton_seq(p, a); 
-    } 
- 
-    asdl_seq *new_seq = _Py_asdl_seq_new(asdl_seq_LEN(seq) + 1, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
- 
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(new_seq); i + 1 < l; i++) { 
-        asdl_seq_SET(new_seq, i, asdl_seq_GET(seq, i)); 
-    } 
-    asdl_seq_SET(new_seq, asdl_seq_LEN(new_seq) - 1, a); 
-    return new_seq; 
-} 
- 
-static Py_ssize_t 
-_get_flattened_seq_size(asdl_seq *seqs) 
-{ 
-    Py_ssize_t size = 0; 
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) { 
-        asdl_seq *inner_seq = asdl_seq_GET(seqs, i); 
-        size += asdl_seq_LEN(inner_seq); 
-    } 
-    return size; 
-} 
- 
-/* Flattens an asdl_seq* of asdl_seq*s */ 
-asdl_seq * 
-_PyPegen_seq_flatten(Parser *p, asdl_seq *seqs) 
-{ 
-    Py_ssize_t flattened_seq_size = _get_flattened_seq_size(seqs); 
-    assert(flattened_seq_size > 0); 
- 
-    asdl_seq *flattened_seq = _Py_asdl_seq_new(flattened_seq_size, p->arena); 
-    if (!flattened_seq) { 
-        return NULL; 
-    } 
- 
-    int flattened_seq_idx = 0; 
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) { 
-        asdl_seq *inner_seq = asdl_seq_GET(seqs, i); 
-        for (Py_ssize_t j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) { 
-            asdl_seq_SET(flattened_seq, flattened_seq_idx++, asdl_seq_GET(inner_seq, j)); 
-        } 
-    } 
-    assert(flattened_seq_idx == flattened_seq_size); 
- 
-    return flattened_seq; 
-} 
- 
-/* Creates a new name of the form <first_name>.<second_name> */ 
-expr_ty 
-_PyPegen_join_names_with_dot(Parser *p, expr_ty first_name, expr_ty second_name) 
-{ 
-    assert(first_name != NULL && second_name != NULL); 
-    PyObject *first_identifier = first_name->v.Name.id; 
-    PyObject *second_identifier = second_name->v.Name.id; 
- 
-    if (PyUnicode_READY(first_identifier) == -1) { 
-        return NULL; 
-    } 
-    if (PyUnicode_READY(second_identifier) == -1) { 
-        return NULL; 
-    } 
-    const char *first_str = PyUnicode_AsUTF8(first_identifier); 
-    if (!first_str) { 
-        return NULL; 
-    } 
-    const char *second_str = PyUnicode_AsUTF8(second_identifier); 
-    if (!second_str) { 
-        return NULL; 
-    } 
-    Py_ssize_t len = strlen(first_str) + strlen(second_str) + 1;  // +1 for the dot 
- 
-    PyObject *str = PyBytes_FromStringAndSize(NULL, len); 
-    if (!str) { 
-        return NULL; 
-    } 
- 
-    char *s = PyBytes_AS_STRING(str); 
-    if (!s) { 
-        return NULL; 
-    } 
- 
-    strcpy(s, first_str); 
-    s += strlen(first_str); 
-    *s++ = '.'; 
-    strcpy(s, second_str); 
-    s += strlen(second_str); 
-    *s = '\0'; 
- 
-    PyObject *uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL); 
-    Py_DECREF(str); 
-    if (!uni) { 
-        return NULL; 
-    } 
-    PyUnicode_InternInPlace(&uni); 
-    if (PyArena_AddPyObject(p->arena, uni) < 0) { 
-        Py_DECREF(uni); 
-        return NULL; 
-    } 
- 
-    return _Py_Name(uni, Load, EXTRA_EXPR(first_name, second_name)); 
-} 
- 
-/* Counts the total number of dots in seq's tokens */ 
-int 
-_PyPegen_seq_count_dots(asdl_seq *seq) 
-{ 
-    int number_of_dots = 0; 
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) { 
-        Token *current_expr = asdl_seq_GET(seq, i); 
-        switch (current_expr->type) { 
-            case ELLIPSIS: 
-                number_of_dots += 3; 
-                break; 
-            case DOT: 
-                number_of_dots += 1; 
-                break; 
-            default: 
-                Py_UNREACHABLE(); 
-        } 
-    } 
- 
-    return number_of_dots; 
-} 
- 
-/* Creates an alias with '*' as the identifier name */ 
-alias_ty 
-_PyPegen_alias_for_star(Parser *p) 
-{ 
-    PyObject *str = PyUnicode_InternFromString("*"); 
-    if (!str) { 
-        return NULL; 
-    } 
-    if (PyArena_AddPyObject(p->arena, str) < 0) { 
-        Py_DECREF(str); 
-        return NULL; 
-    } 
-    return alias(str, NULL, p->arena); 
-} 
- 
-/* Creates a new asdl_seq* with the identifiers of all the names in seq */ 
-asdl_seq * 
-_PyPegen_map_names_to_ids(Parser *p, asdl_seq *seq) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(seq); 
-    assert(len > 0); 
- 
-    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        expr_ty e = asdl_seq_GET(seq, i); 
-        asdl_seq_SET(new_seq, i, e->v.Name.id); 
-    } 
-    return new_seq; 
-} 
- 
-/* Constructs a CmpopExprPair */ 
-CmpopExprPair * 
-_PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop, expr_ty expr) 
-{ 
-    assert(expr != NULL); 
-    CmpopExprPair *a = PyArena_Malloc(p->arena, sizeof(CmpopExprPair)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->cmpop = cmpop; 
-    a->expr = expr; 
-    return a; 
-} 
- 
-asdl_int_seq * 
-_PyPegen_get_cmpops(Parser *p, asdl_seq *seq) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(seq); 
-    assert(len > 0); 
- 
-    asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        CmpopExprPair *pair = asdl_seq_GET(seq, i); 
-        asdl_seq_SET(new_seq, i, pair->cmpop); 
-    } 
-    return new_seq; 
-} 
- 
-asdl_seq * 
-_PyPegen_get_exprs(Parser *p, asdl_seq *seq) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(seq); 
-    assert(len > 0); 
- 
-    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        CmpopExprPair *pair = asdl_seq_GET(seq, i); 
-        asdl_seq_SET(new_seq, i, pair->expr); 
-    } 
-    return new_seq; 
-} 
- 
-/* Creates an asdl_seq* where all the elements have been changed to have ctx as context */ 
-static asdl_seq * 
-_set_seq_context(Parser *p, asdl_seq *seq, expr_context_ty ctx) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(seq); 
-    if (len == 0) { 
-        return NULL; 
-    } 
- 
-    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        expr_ty e = asdl_seq_GET(seq, i); 
-        asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx)); 
-    } 
-    return new_seq; 
-} 
- 
-static expr_ty 
-_set_name_context(Parser *p, expr_ty e, expr_context_ty ctx) 
-{ 
-    return _Py_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e)); 
-} 
- 
-static expr_ty 
-_set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx) 
-{ 
-    return _Py_Tuple(_set_seq_context(p, e->v.Tuple.elts, ctx), ctx, EXTRA_EXPR(e, e)); 
-} 
- 
-static expr_ty 
-_set_list_context(Parser *p, expr_ty e, expr_context_ty ctx) 
-{ 
-    return _Py_List(_set_seq_context(p, e->v.List.elts, ctx), ctx, EXTRA_EXPR(e, e)); 
-} 
- 
-static expr_ty 
-_set_subscript_context(Parser *p, expr_ty e, expr_context_ty ctx) 
-{ 
-    return _Py_Subscript(e->v.Subscript.value, e->v.Subscript.slice, ctx, EXTRA_EXPR(e, e)); 
-} 
- 
-static expr_ty 
-_set_attribute_context(Parser *p, expr_ty e, expr_context_ty ctx) 
-{ 
-    return _Py_Attribute(e->v.Attribute.value, e->v.Attribute.attr, ctx, EXTRA_EXPR(e, e)); 
-} 
- 
-static expr_ty 
-_set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx) 
-{ 
-    return _Py_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx), ctx, EXTRA_EXPR(e, e)); 
-} 
- 
-/* Creates an `expr_ty` equivalent to `expr` but with `ctx` as context */ 
-expr_ty 
-_PyPegen_set_expr_context(Parser *p, expr_ty expr, expr_context_ty ctx) 
-{ 
-    assert(expr != NULL); 
- 
-    expr_ty new = NULL; 
-    switch (expr->kind) { 
-        case Name_kind: 
-            new = _set_name_context(p, expr, ctx); 
-            break; 
-        case Tuple_kind: 
-            new = _set_tuple_context(p, expr, ctx); 
-            break; 
-        case List_kind: 
-            new = _set_list_context(p, expr, ctx); 
-            break; 
-        case Subscript_kind: 
-            new = _set_subscript_context(p, expr, ctx); 
-            break; 
-        case Attribute_kind: 
-            new = _set_attribute_context(p, expr, ctx); 
-            break; 
-        case Starred_kind: 
-            new = _set_starred_context(p, expr, ctx); 
-            break; 
-        default: 
-            new = expr; 
-    } 
-    return new; 
-} 
- 
-/* Constructs a KeyValuePair that is used when parsing a dict's key value pairs */ 
-KeyValuePair * 
-_PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value) 
-{ 
-    KeyValuePair *a = PyArena_Malloc(p->arena, sizeof(KeyValuePair)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->key = key; 
-    a->value = value; 
-    return a; 
-} 
- 
-/* Extracts all keys from an asdl_seq* of KeyValuePair*'s */ 
-asdl_seq * 
-_PyPegen_get_keys(Parser *p, asdl_seq *seq) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(seq); 
-    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        KeyValuePair *pair = asdl_seq_GET(seq, i); 
-        asdl_seq_SET(new_seq, i, pair->key); 
-    } 
-    return new_seq; 
-} 
- 
-/* Extracts all values from an asdl_seq* of KeyValuePair*'s */ 
-asdl_seq * 
-_PyPegen_get_values(Parser *p, asdl_seq *seq) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(seq); 
-    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        KeyValuePair *pair = asdl_seq_GET(seq, i); 
-        asdl_seq_SET(new_seq, i, pair->value); 
-    } 
-    return new_seq; 
-} 
- 
-/* Constructs a NameDefaultPair */ 
-NameDefaultPair * 
-_PyPegen_name_default_pair(Parser *p, arg_ty arg, expr_ty value, Token *tc) 
-{ 
-    NameDefaultPair *a = PyArena_Malloc(p->arena, sizeof(NameDefaultPair)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->arg = _PyPegen_add_type_comment_to_arg(p, arg, tc); 
-    a->value = value; 
-    return a; 
-} 
- 
-/* Constructs a SlashWithDefault */ 
-SlashWithDefault * 
-_PyPegen_slash_with_default(Parser *p, asdl_seq *plain_names, asdl_seq *names_with_defaults) 
-{ 
-    SlashWithDefault *a = PyArena_Malloc(p->arena, sizeof(SlashWithDefault)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->plain_names = plain_names; 
-    a->names_with_defaults = names_with_defaults; 
-    return a; 
-} 
- 
-/* Constructs a StarEtc */ 
-StarEtc * 
-_PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs, arg_ty kwarg) 
-{ 
-    StarEtc *a = PyArena_Malloc(p->arena, sizeof(StarEtc)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->vararg = vararg; 
-    a->kwonlyargs = kwonlyargs; 
-    a->kwarg = kwarg; 
-    return a; 
-} 
- 
-asdl_seq * 
-_PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b) 
-{ 
-    Py_ssize_t first_len = asdl_seq_LEN(a); 
-    Py_ssize_t second_len = asdl_seq_LEN(b); 
-    asdl_seq *new_seq = _Py_asdl_seq_new(first_len + second_len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
- 
-    int k = 0; 
-    for (Py_ssize_t i = 0; i < first_len; i++) { 
-        asdl_seq_SET(new_seq, k++, asdl_seq_GET(a, i)); 
-    } 
-    for (Py_ssize_t i = 0; i < second_len; i++) { 
-        asdl_seq_SET(new_seq, k++, asdl_seq_GET(b, i)); 
-    } 
- 
-    return new_seq; 
-} 
- 
-static asdl_seq * 
-_get_names(Parser *p, asdl_seq *names_with_defaults) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(names_with_defaults); 
-    asdl_seq *seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i); 
-        asdl_seq_SET(seq, i, pair->arg); 
-    } 
-    return seq; 
-} 
- 
-static asdl_seq * 
-_get_defaults(Parser *p, asdl_seq *names_with_defaults) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(names_with_defaults); 
-    asdl_seq *seq = _Py_asdl_seq_new(len, p->arena); 
-    if (!seq) { 
-        return NULL; 
-    } 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i); 
-        asdl_seq_SET(seq, i, pair->value); 
-    } 
-    return seq; 
-} 
- 
-/* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */ 
-arguments_ty 
-_PyPegen_make_arguments(Parser *p, asdl_seq *slash_without_default, 
-                        SlashWithDefault *slash_with_default, asdl_seq *plain_names, 
-                        asdl_seq *names_with_default, StarEtc *star_etc) 
-{ 
-    asdl_seq *posonlyargs; 
-    if (slash_without_default != NULL) { 
-        posonlyargs = slash_without_default; 
-    } 
-    else if (slash_with_default != NULL) { 
-        asdl_seq *slash_with_default_names = 
-            _get_names(p, slash_with_default->names_with_defaults); 
-        if (!slash_with_default_names) { 
-            return NULL; 
-        } 
-        posonlyargs = _PyPegen_join_sequences(p, slash_with_default->plain_names, slash_with_default_names); 
-        if (!posonlyargs) { 
-            return NULL; 
-        } 
-    } 
-    else { 
-        posonlyargs = _Py_asdl_seq_new(0, p->arena); 
-        if (!posonlyargs) { 
-            return NULL; 
-        } 
-    } 
- 
-    asdl_seq *posargs; 
-    if (plain_names != NULL && names_with_default != NULL) { 
-        asdl_seq *names_with_default_names = _get_names(p, names_with_default); 
-        if (!names_with_default_names) { 
-            return NULL; 
-        } 
-        posargs = _PyPegen_join_sequences(p, plain_names, names_with_default_names); 
-        if (!posargs) { 
-            return NULL; 
-        } 
-    } 
-    else if (plain_names == NULL && names_with_default != NULL) { 
-        posargs = _get_names(p, names_with_default); 
-        if (!posargs) { 
-            return NULL; 
-        } 
-    } 
-    else if (plain_names != NULL && names_with_default == NULL) { 
-        posargs = plain_names; 
-    } 
-    else { 
-        posargs = _Py_asdl_seq_new(0, p->arena); 
-        if (!posargs) { 
-            return NULL; 
-        } 
-    } 
- 
-    asdl_seq *posdefaults; 
-    if (slash_with_default != NULL && names_with_default != NULL) { 
-        asdl_seq *slash_with_default_values = 
-            _get_defaults(p, slash_with_default->names_with_defaults); 
-        if (!slash_with_default_values) { 
-            return NULL; 
-        } 
-        asdl_seq *names_with_default_values = _get_defaults(p, names_with_default); 
-        if (!names_with_default_values) { 
-            return NULL; 
-        } 
-        posdefaults = _PyPegen_join_sequences(p, slash_with_default_values, names_with_default_values); 
-        if (!posdefaults) { 
-            return NULL; 
-        } 
-    } 
-    else if (slash_with_default == NULL && names_with_default != NULL) { 
-        posdefaults = _get_defaults(p, names_with_default); 
-        if (!posdefaults) { 
-            return NULL; 
-        } 
-    } 
-    else if (slash_with_default != NULL && names_with_default == NULL) { 
-        posdefaults = _get_defaults(p, slash_with_default->names_with_defaults); 
-        if (!posdefaults) { 
-            return NULL; 
-        } 
-    } 
-    else { 
-        posdefaults = _Py_asdl_seq_new(0, p->arena); 
-        if (!posdefaults) { 
-            return NULL; 
-        } 
-    } 
- 
-    arg_ty vararg = NULL; 
-    if (star_etc != NULL && star_etc->vararg != NULL) { 
-        vararg = star_etc->vararg; 
-    } 
- 
-    asdl_seq *kwonlyargs; 
-    if (star_etc != NULL && star_etc->kwonlyargs != NULL) { 
-        kwonlyargs = _get_names(p, star_etc->kwonlyargs); 
-        if (!kwonlyargs) { 
-            return NULL; 
-        } 
-    } 
-    else { 
-        kwonlyargs = _Py_asdl_seq_new(0, p->arena); 
-        if (!kwonlyargs) { 
-            return NULL; 
-        } 
-    } 
- 
-    asdl_seq *kwdefaults; 
-    if (star_etc != NULL && star_etc->kwonlyargs != NULL) { 
-        kwdefaults = _get_defaults(p, star_etc->kwonlyargs); 
-        if (!kwdefaults) { 
-            return NULL; 
-        } 
-    } 
-    else { 
-        kwdefaults = _Py_asdl_seq_new(0, p->arena); 
-        if (!kwdefaults) { 
-            return NULL; 
-        } 
-    } 
- 
-    arg_ty kwarg = NULL; 
-    if (star_etc != NULL && star_etc->kwarg != NULL) { 
-        kwarg = star_etc->kwarg; 
-    } 
- 
-    return _Py_arguments(posonlyargs, posargs, vararg, kwonlyargs, kwdefaults, kwarg, 
-                         posdefaults, p->arena); 
-} 
- 
-/* Constructs an empty arguments_ty object, that gets used when a function accepts no 
- * arguments. */ 
-arguments_ty 
-_PyPegen_empty_arguments(Parser *p) 
-{ 
-    asdl_seq *posonlyargs = _Py_asdl_seq_new(0, p->arena); 
-    if (!posonlyargs) { 
-        return NULL; 
-    } 
-    asdl_seq *posargs = _Py_asdl_seq_new(0, p->arena); 
-    if (!posargs) { 
-        return NULL; 
-    } 
-    asdl_seq *posdefaults = _Py_asdl_seq_new(0, p->arena); 
-    if (!posdefaults) { 
-        return NULL; 
-    } 
-    asdl_seq *kwonlyargs = _Py_asdl_seq_new(0, p->arena); 
-    if (!kwonlyargs) { 
-        return NULL; 
-    } 
-    asdl_seq *kwdefaults = _Py_asdl_seq_new(0, p->arena); 
-    if (!kwdefaults) { 
-        return NULL; 
-    } 
- 
-    return _Py_arguments(posonlyargs, posargs, NULL, kwonlyargs, kwdefaults, NULL, kwdefaults, 
-                         p->arena); 
-} 
- 
-/* Encapsulates the value of an operator_ty into an AugOperator struct */ 
-AugOperator * 
-_PyPegen_augoperator(Parser *p, operator_ty kind) 
-{ 
-    AugOperator *a = PyArena_Malloc(p->arena, sizeof(AugOperator)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->kind = kind; 
-    return a; 
-} 
- 
-/* Construct a FunctionDef equivalent to function_def, but with decorators */ 
-stmt_ty 
-_PyPegen_function_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty function_def) 
-{ 
-    assert(function_def != NULL); 
-    if (function_def->kind == AsyncFunctionDef_kind) { 
-        return _Py_AsyncFunctionDef( 
-            function_def->v.FunctionDef.name, function_def->v.FunctionDef.args, 
-            function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns, 
-            function_def->v.FunctionDef.type_comment, function_def->lineno, 
-            function_def->col_offset, function_def->end_lineno, function_def->end_col_offset, 
-            p->arena); 
-    } 
- 
-    return _Py_FunctionDef(function_def->v.FunctionDef.name, function_def->v.FunctionDef.args, 
-                           function_def->v.FunctionDef.body, decorators, 
-                           function_def->v.FunctionDef.returns, 
-                           function_def->v.FunctionDef.type_comment, function_def->lineno, 
-                           function_def->col_offset, function_def->end_lineno, 
-                           function_def->end_col_offset, p->arena); 
-} 
- 
-/* Construct a ClassDef equivalent to class_def, but with decorators */ 
-stmt_ty 
-_PyPegen_class_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty class_def) 
-{ 
-    assert(class_def != NULL); 
-    return _Py_ClassDef(class_def->v.ClassDef.name, class_def->v.ClassDef.bases, 
-                        class_def->v.ClassDef.keywords, class_def->v.ClassDef.body, decorators, 
-                        class_def->lineno, class_def->col_offset, class_def->end_lineno, 
-                        class_def->end_col_offset, p->arena); 
-} 
- 
-/* Construct a KeywordOrStarred */ 
-KeywordOrStarred * 
-_PyPegen_keyword_or_starred(Parser *p, void *element, int is_keyword) 
-{ 
-    KeywordOrStarred *a = PyArena_Malloc(p->arena, sizeof(KeywordOrStarred)); 
-    if (!a) { 
-        return NULL; 
-    } 
-    a->element = element; 
-    a->is_keyword = is_keyword; 
-    return a; 
-} 
- 
-/* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s */ 
-static int 
-_seq_number_of_starred_exprs(asdl_seq *seq) 
-{ 
-    int n = 0; 
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) { 
-        KeywordOrStarred *k = asdl_seq_GET(seq, i); 
-        if (!k->is_keyword) { 
-            n++; 
-        } 
-    } 
-    return n; 
-} 
- 
-/* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */ 
-asdl_seq * 
-_PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs) 
-{ 
-    int new_len = _seq_number_of_starred_exprs(kwargs); 
-    if (new_len == 0) { 
-        return NULL; 
-    } 
-    asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
- 
-    int idx = 0; 
-    for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) { 
-        KeywordOrStarred *k = asdl_seq_GET(kwargs, i); 
-        if (!k->is_keyword) { 
-            asdl_seq_SET(new_seq, idx++, k->element); 
-        } 
-    } 
-    return new_seq; 
-} 
- 
-/* Return a new asdl_seq* with only the keywords in kwargs */ 
-asdl_seq * 
-_PyPegen_seq_delete_starred_exprs(Parser *p, asdl_seq *kwargs) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(kwargs); 
-    Py_ssize_t new_len = len - _seq_number_of_starred_exprs(kwargs); 
-    if (new_len == 0) { 
-        return NULL; 
-    } 
-    asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena); 
-    if (!new_seq) { 
-        return NULL; 
-    } 
- 
-    int idx = 0; 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        KeywordOrStarred *k = asdl_seq_GET(kwargs, i); 
-        if (k->is_keyword) { 
-            asdl_seq_SET(new_seq, idx++, k->element); 
-        } 
-    } 
-    return new_seq; 
-} 
- 
-expr_ty 
-_PyPegen_concatenate_strings(Parser *p, asdl_seq *strings) 
-{ 
-    Py_ssize_t len = asdl_seq_LEN(strings); 
-    assert(len > 0); 
- 
-    Token *first = asdl_seq_GET(strings, 0); 
-    Token *last = asdl_seq_GET(strings, len - 1); 
- 
-    int bytesmode = 0; 
-    PyObject *bytes_str = NULL; 
- 
-    FstringParser state; 
-    _PyPegen_FstringParser_Init(&state); 
- 
-    for (Py_ssize_t i = 0; i < len; i++) { 
-        Token *t = asdl_seq_GET(strings, i); 
- 
-        int this_bytesmode; 
-        int this_rawmode; 
-        PyObject *s; 
-        const char *fstr; 
-        Py_ssize_t fstrlen = -1; 
- 
-        if (_PyPegen_parsestr(p, &this_bytesmode, &this_rawmode, &s, &fstr, &fstrlen, t) != 0) { 
-            goto error; 
-        } 
- 
-        /* Check that we are not mixing bytes with unicode. */ 
-        if (i != 0 && bytesmode != this_bytesmode) { 
-            RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals"); 
-            Py_XDECREF(s); 
-            goto error; 
-        } 
-        bytesmode = this_bytesmode; 
- 
-        if (fstr != NULL) { 
-            assert(s == NULL && !bytesmode); 
- 
-            int result = _PyPegen_FstringParser_ConcatFstring(p, &state, &fstr, fstr + fstrlen, 
-                                                     this_rawmode, 0, first, t, last); 
-            if (result < 0) { 
-                goto error; 
-            } 
-        } 
-        else { 
-            /* String or byte string. */ 
-            assert(s != NULL && fstr == NULL); 
-            assert(bytesmode ? PyBytes_CheckExact(s) : PyUnicode_CheckExact(s)); 
- 
-            if (bytesmode) { 
-                if (i == 0) { 
-                    bytes_str = s; 
-                } 
-                else { 
-                    PyBytes_ConcatAndDel(&bytes_str, s); 
-                    if (!bytes_str) { 
-                        goto error; 
-                    } 
-                } 
-            } 
-            else { 
-                /* This is a regular string. Concatenate it. */ 
-                if (_PyPegen_FstringParser_ConcatAndDel(&state, s) < 0) { 
-                    goto error; 
-                } 
-            } 
-        } 
-    } 
- 
-    if (bytesmode) { 
-        if (PyArena_AddPyObject(p->arena, bytes_str) < 0) { 
-            goto error; 
-        } 
-        return Constant(bytes_str, NULL, first->lineno, first->col_offset, last->end_lineno, 
-                        last->end_col_offset, p->arena); 
-    } 
- 
-    return _PyPegen_FstringParser_Finish(p, &state, first, last); 
- 
-error: 
-    Py_XDECREF(bytes_str); 
-    _PyPegen_FstringParser_Dealloc(&state); 
-    if (PyErr_Occurred()) { 
-        raise_decode_error(p); 
-    } 
-    return NULL; 
-} 
- 
-mod_ty 
-_PyPegen_make_module(Parser *p, asdl_seq *a) { 
-    asdl_seq *type_ignores = NULL; 
-    Py_ssize_t num = p->type_ignore_comments.num_items; 
-    if (num > 0) { 
-        // Turn the raw (comment, lineno) pairs into TypeIgnore objects in the arena 
-        type_ignores = _Py_asdl_seq_new(num, p->arena); 
-        if (type_ignores == NULL) { 
-            return NULL; 
-        } 
-        for (int i = 0; i < num; i++) { 
-            PyObject *tag = _PyPegen_new_type_comment(p, p->type_ignore_comments.items[i].comment); 
-            if (tag == NULL) { 
-                return NULL; 
-            } 
-            type_ignore_ty ti = TypeIgnore(p->type_ignore_comments.items[i].lineno, tag, p->arena); 
-            if (ti == NULL) { 
-                return NULL; 
-            } 
-            asdl_seq_SET(type_ignores, i, ti); 
-        } 
-    } 
-    return Module(a, type_ignores, p->arena); 
-} 
- 
-// Error reporting helpers 
- 
-expr_ty 
-_PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) 
-{ 
-    if (e == NULL) { 
-        return NULL; 
-    } 
- 
-#define VISIT_CONTAINER(CONTAINER, TYPE) do { \ 
-        Py_ssize_t len = asdl_seq_LEN(CONTAINER->v.TYPE.elts);\ 
-        for (Py_ssize_t i = 0; i < len; i++) {\ 
-            expr_ty other = asdl_seq_GET(CONTAINER->v.TYPE.elts, i);\ 
-            expr_ty child = _PyPegen_get_invalid_target(other, targets_type);\ 
-            if (child != NULL) {\ 
-                return child;\ 
-            }\ 
-        }\ 
-    } while (0) 
- 
-    // We only need to visit List and Tuple nodes recursively as those 
-    // are the only ones that can contain valid names in targets when 
-    // they are parsed as expressions. Any other kind of expression 
-    // that is a container (like Sets or Dicts) is directly invalid and 
-    // we don't need to visit it recursively. 
- 
-    switch (e->kind) { 
-        case List_kind: 
-            VISIT_CONTAINER(e, List); 
-            return NULL; 
-        case Tuple_kind: 
-            VISIT_CONTAINER(e, Tuple); 
-            return NULL; 
-        case Starred_kind: 
-            if (targets_type == DEL_TARGETS) { 
-                return e; 
-            } 
-            return _PyPegen_get_invalid_target(e->v.Starred.value, targets_type); 
-        case Compare_kind: 
-            // This is needed, because the `a in b` in `for a in b` gets parsed 
-            // as a comparison, and so we need to search the left side of the comparison 
-            // for invalid targets. 
-            if (targets_type == FOR_TARGETS) { 
-                cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.ops, 0); 
-                if (cmpop == In) { 
-                    return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type); 
-                } 
-                return NULL; 
-            } 
-            return e; 
-        case Name_kind: 
-        case Subscript_kind: 
-        case Attribute_kind: 
-            return NULL; 
-        default: 
-            return e; 
-    } 
-} 
- 
-void *_PyPegen_arguments_parsing_error(Parser *p, expr_ty e) { 
-    int kwarg_unpacking = 0; 
-    for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) { 
-        keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i); 
-        if (!keyword->arg) { 
-            kwarg_unpacking = 1; 
-        } 
-    } 
- 
-    const char *msg = NULL; 
-    if (kwarg_unpacking) { 
-        msg = "positional argument follows keyword argument unpacking"; 
-    } else { 
-        msg = "positional argument follows keyword argument"; 
-    } 
- 
-    return RAISE_SYNTAX_ERROR(msg); 
-} 
- 
-void * 
-_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args) 
-{ 
-    /* The rule that calls this function is 'args for_if_clauses'. 
-       For the input f(L, x for x in y), L and x are in args and 
-       the for is parsed as a for_if_clause. We have to check if 
-       len <= 1, so that input like dict((a, b) for a, b in x) 
-       gets successfully parsed and then we pass the last 
-       argument (x in the above example) as the location of the 
-       error */ 
-    Py_ssize_t len = asdl_seq_LEN(args->v.Call.args); 
-    if (len <= 1) { 
-        return NULL; 
-    } 
- 
-    return RAISE_SYNTAX_ERROR_KNOWN_LOCATION( 
-        (expr_ty) asdl_seq_GET(args->v.Call.args, len - 1), 
-        "Generator expression must be parenthesized" 
-    ); 
-} 
- 
- 
-expr_ty _PyPegen_collect_call_seqs(Parser *p, asdl_seq *a, asdl_seq *b, 
-                     int lineno, int col_offset, int end_lineno, 
-                     int end_col_offset, PyArena *arena) { 
-    Py_ssize_t args_len = asdl_seq_LEN(a); 
-    Py_ssize_t total_len = args_len; 
- 
-    if (b == NULL) { 
-        return _Py_Call(_PyPegen_dummy_name(p), a, NULL, lineno, col_offset, 
-                        end_lineno, end_col_offset, arena); 
- 
-    } 
- 
-    asdl_seq *starreds = _PyPegen_seq_extract_starred_exprs(p, b); 
-    asdl_seq *keywords = _PyPegen_seq_delete_starred_exprs(p, b); 
- 
-    if (starreds) { 
-        total_len += asdl_seq_LEN(starreds); 
-    } 
- 
-    asdl_seq *args = _Py_asdl_seq_new(total_len, arena); 
- 
-    Py_ssize_t i = 0; 
-    for (i = 0; i < args_len; i++) { 
-        asdl_seq_SET(args, i, asdl_seq_GET(a, i)); 
-    } 
-    for (; i < total_len; i++) { 
-        asdl_seq_SET(args, i, asdl_seq_GET(starreds, i - args_len)); 
-    } 
- 
-    return _Py_Call(_PyPegen_dummy_name(p), args, keywords, lineno, 
-                    col_offset, end_lineno, end_col_offset, arena); 
- 
- 
-} 
+#include <Python.h>
+#include <errcode.h>
+#include "../tokenizer.h"
+
+#include "pegen.h"
+#include "parse_string.h"
+#include "ast.h"
+
+PyObject *
+_PyPegen_new_type_comment(Parser *p, char *s)
+{
+    PyObject *res = PyUnicode_DecodeUTF8(s, strlen(s), NULL);
+    if (res == NULL) {
+        return NULL;
+    }
+    if (PyArena_AddPyObject(p->arena, res) < 0) {
+        Py_DECREF(res);
+        return NULL;
+    }
+    return res;
+}
+
+arg_ty
+_PyPegen_add_type_comment_to_arg(Parser *p, arg_ty a, Token *tc)
+{
+    if (tc == NULL) {
+        return a;
+    }
+    char *bytes = PyBytes_AsString(tc->bytes);
+    if (bytes == NULL) {
+        return NULL;
+    }
+    PyObject *tco = _PyPegen_new_type_comment(p, bytes);
+    if (tco == NULL) {
+        return NULL;
+    }
+    return arg(a->arg, a->annotation, tco,
+               a->lineno, a->col_offset, a->end_lineno, a->end_col_offset,
+               p->arena);
+}
+
+static int
+init_normalization(Parser *p)
+{
+    if (p->normalize) {
+        return 1;
+    }
+    PyObject *m = PyImport_ImportModuleNoBlock("unicodedata");
+    if (!m)
+    {
+        return 0;
+    }
+    p->normalize = PyObject_GetAttrString(m, "normalize");
+    Py_DECREF(m);
+    if (!p->normalize)
+    {
+        return 0;
+    }
+    return 1;
+}
+
+/* Checks if the NOTEQUAL token is valid given the current parser flags
+0 indicates success and nonzero indicates failure (an exception may be set) */
+int
+_PyPegen_check_barry_as_flufl(Parser *p, Token* t) {
+    assert(t->bytes != NULL);
+    assert(t->type == NOTEQUAL);
+
+    char* tok_str = PyBytes_AS_STRING(t->bytes);
+    if (p->flags & PyPARSE_BARRY_AS_BDFL && strcmp(tok_str, "<>") != 0) {
+        RAISE_SYNTAX_ERROR("with Barry as BDFL, use '<>' instead of '!='");
+        return -1;
+    }
+    if (!(p->flags & PyPARSE_BARRY_AS_BDFL)) {
+        return strcmp(tok_str, "!=");
+    }
+    return 0;
+}
+
+PyObject *
+_PyPegen_new_identifier(Parser *p, char *n)
+{
+    PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL);
+    if (!id) {
+        goto error;
+    }
+    /* PyUnicode_DecodeUTF8 should always return a ready string. */
+    assert(PyUnicode_IS_READY(id));
+    /* Check whether there are non-ASCII characters in the
+       identifier; if so, normalize to NFKC. */
+    if (!PyUnicode_IS_ASCII(id))
+    {
+        PyObject *id2;
+        if (!init_normalization(p))
+        {
+            Py_DECREF(id);
+            goto error;
+        }
+        PyObject *form = PyUnicode_InternFromString("NFKC");
+        if (form == NULL)
+        {
+            Py_DECREF(id);
+            goto error;
+        }
+        PyObject *args[2] = {form, id};
+        id2 = _PyObject_FastCall(p->normalize, args, 2);
+        Py_DECREF(id);
+        Py_DECREF(form);
+        if (!id2) {
+            goto error;
+        }
+        if (!PyUnicode_Check(id2))
+        {
+            PyErr_Format(PyExc_TypeError,
+                         "unicodedata.normalize() must return a string, not "
+                         "%.200s",
+                         _PyType_Name(Py_TYPE(id2)));
+            Py_DECREF(id2);
+            goto error;
+        }
+        id = id2;
+    }
+    PyUnicode_InternInPlace(&id);
+    if (PyArena_AddPyObject(p->arena, id) < 0)
+    {
+        Py_DECREF(id);
+        goto error;
+    }
+    return id;
+
+error:
+    p->error_indicator = 1;
+    return NULL;
+}
+
+static PyObject *
+_create_dummy_identifier(Parser *p)
+{
+    return _PyPegen_new_identifier(p, "");
+}
+
+static inline Py_ssize_t
+byte_offset_to_character_offset(PyObject *line, Py_ssize_t col_offset)
+{
+    const char *str = PyUnicode_AsUTF8(line);
+    if (!str) {
+        return 0;
+    }
+    assert(col_offset >= 0 && (unsigned long)col_offset <= strlen(str));
+    PyObject *text = PyUnicode_DecodeUTF8(str, col_offset, "replace");
+    if (!text) {
+        return 0;
+    }
+    Py_ssize_t size = PyUnicode_GET_LENGTH(text);
+    Py_DECREF(text);
+    return size;
+}
+
+const char *
+_PyPegen_get_expr_name(expr_ty e)
+{
+    assert(e != NULL);
+    switch (e->kind) {
+        case Attribute_kind:
+            return "attribute";
+        case Subscript_kind:
+            return "subscript";
+        case Starred_kind:
+            return "starred";
+        case Name_kind:
+            return "name";
+        case List_kind:
+            return "list";
+        case Tuple_kind:
+            return "tuple";
+        case Lambda_kind:
+            return "lambda";
+        case Call_kind:
+            return "function call";
+        case BoolOp_kind:
+        case BinOp_kind:
+        case UnaryOp_kind:
+            return "operator";
+        case GeneratorExp_kind:
+            return "generator expression";
+        case Yield_kind:
+        case YieldFrom_kind:
+            return "yield expression";
+        case Await_kind:
+            return "await expression";
+        case ListComp_kind:
+            return "list comprehension";
+        case SetComp_kind:
+            return "set comprehension";
+        case DictComp_kind:
+            return "dict comprehension";
+        case Dict_kind:
+            return "dict display";
+        case Set_kind:
+            return "set display";
+        case JoinedStr_kind:
+        case FormattedValue_kind:
+            return "f-string expression";
+        case Constant_kind: {
+            PyObject *value = e->v.Constant.value;
+            if (value == Py_None) {
+                return "None";
+            }
+            if (value == Py_False) {
+                return "False";
+            }
+            if (value == Py_True) {
+                return "True";
+            }
+            if (value == Py_Ellipsis) {
+                return "Ellipsis";
+            }
+            return "literal";
+        }
+        case Compare_kind:
+            return "comparison";
+        case IfExp_kind:
+            return "conditional expression";
+        case NamedExpr_kind:
+            return "named expression";
+        default:
+            PyErr_Format(PyExc_SystemError,
+                         "unexpected expression in assignment %d (line %d)",
+                         e->kind, e->lineno);
+            return NULL;
+    }
+}
+
+static int
+raise_decode_error(Parser *p)
+{
+    assert(PyErr_Occurred());
+    const char *errtype = NULL;
+    if (PyErr_ExceptionMatches(PyExc_UnicodeError)) {
+        errtype = "unicode error";
+    }
+    else if (PyErr_ExceptionMatches(PyExc_ValueError)) {
+        errtype = "value error";
+    }
+    if (errtype) {
+        PyObject *type;
+        PyObject *value;
+        PyObject *tback;
+        PyObject *errstr;
+        PyErr_Fetch(&type, &value, &tback);
+        errstr = PyObject_Str(value);
+        if (errstr) {
+            RAISE_SYNTAX_ERROR("(%s) %U", errtype, errstr);
+            Py_DECREF(errstr);
+        }
+        else {
+            PyErr_Clear();
+            RAISE_SYNTAX_ERROR("(%s) unknown error", errtype);
+        }
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(tback);
+    }
+
+    return -1;
+}
+
+static void
+raise_tokenizer_init_error(PyObject *filename)
+{
+    if (!(PyErr_ExceptionMatches(PyExc_LookupError)
+          || PyErr_ExceptionMatches(PyExc_SyntaxError)
+          || PyErr_ExceptionMatches(PyExc_ValueError)
+          || PyErr_ExceptionMatches(PyExc_UnicodeDecodeError))) {
+        return;
+    }
+    PyObject *errstr = NULL;
+    PyObject *tuple = NULL;
+    PyObject *type;
+    PyObject *value;
+    PyObject *tback;
+    PyErr_Fetch(&type, &value, &tback);
+    errstr = PyObject_Str(value);
+    if (!errstr) {
+        goto error;
+    }
+
+    PyObject *tmp = Py_BuildValue("(OiiO)", filename, 0, -1, Py_None);
+    if (!tmp) {
+        goto error;
+    }
+
+    tuple = PyTuple_Pack(2, errstr, tmp);
+    Py_DECREF(tmp);
+    if (!value) {
+        goto error;
+    }
+    PyErr_SetObject(PyExc_SyntaxError, tuple);
+
+error:
+    Py_XDECREF(type);
+    Py_XDECREF(value);
+    Py_XDECREF(tback);
+    Py_XDECREF(errstr);
+    Py_XDECREF(tuple);
+}
+
+static int
+tokenizer_error(Parser *p)
+{
+    if (PyErr_Occurred()) {
+        return -1;
+    }
+
+    const char *msg = NULL;
+    PyObject* errtype = PyExc_SyntaxError;
+    Py_ssize_t col_offset = -1;
+    switch (p->tok->done) {
+        case E_TOKEN:
+            msg = "invalid token";
+            break;
+        case E_EOFS:
+            RAISE_SYNTAX_ERROR("EOF while scanning triple-quoted string literal");
+            return -1;
+        case E_EOLS:
+            RAISE_SYNTAX_ERROR("EOL while scanning string literal");
+            return -1;
+        case E_EOF:
+            RAISE_SYNTAX_ERROR("unexpected EOF while parsing");
+            return -1;
+        case E_DEDENT:
+            RAISE_INDENTATION_ERROR("unindent does not match any outer indentation level");
+            return -1;
+        case E_INTR:
+            if (!PyErr_Occurred()) {
+                PyErr_SetNone(PyExc_KeyboardInterrupt);
+            }
+            return -1;
+        case E_NOMEM:
+            PyErr_NoMemory();
+            return -1;
+        case E_TABSPACE:
+            errtype = PyExc_TabError;
+            msg = "inconsistent use of tabs and spaces in indentation";
+            break;
+        case E_TOODEEP:
+            errtype = PyExc_IndentationError;
+            msg = "too many levels of indentation";
+            break;
+        case E_LINECONT: {
+            col_offset = p->tok->cur - p->tok->buf - 1;
+            msg = "unexpected character after line continuation character";
+            break;
+        }
+        default:
+            msg = "unknown parsing error";
+    }
+
+    RAISE_ERROR_KNOWN_LOCATION(p, errtype, p->tok->lineno,
+                               col_offset >= 0 ? col_offset : 0, msg);
+    return -1;
+}
+
+void *
+_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...)
+{
+    if (p->fill == 0) {
+        va_list va;
+        va_start(va, errmsg);
+        _PyPegen_raise_error_known_location(p, errtype, 0, 0, errmsg, va);
+        va_end(va);
+        return NULL;
+    }
+
+    Token *t = p->known_err_token != NULL ? p->known_err_token : p->tokens[p->fill - 1];
+    Py_ssize_t col_offset;
+    if (t->col_offset == -1) {
+        col_offset = Py_SAFE_DOWNCAST(p->tok->cur - p->tok->buf,
+                                      intptr_t, int);
+    } else {
+        col_offset = t->col_offset + 1;
+    }
+
+    va_list va;
+    va_start(va, errmsg);
+    _PyPegen_raise_error_known_location(p, errtype, t->lineno,
+                                        col_offset, errmsg, va);
+    va_end(va);
+
+    return NULL;
+}
+
+void *
+_PyPegen_raise_error_known_location(Parser *p, PyObject *errtype,
+                                    Py_ssize_t lineno, Py_ssize_t col_offset,
+                                    const char *errmsg, va_list va)
+{
+    PyObject *value = NULL;
+    PyObject *errstr = NULL;
+    PyObject *error_line = NULL;
+    PyObject *tmp = NULL;
+    p->error_indicator = 1;
+
+    if (p->start_rule == Py_fstring_input) {
+        const char *fstring_msg = "f-string: ";
+        Py_ssize_t len = strlen(fstring_msg) + strlen(errmsg);
+
+        char *new_errmsg = PyMem_RawMalloc(len + 1); // Lengths of both strings plus NULL character
+        if (!new_errmsg) {
+            return (void *) PyErr_NoMemory();
+        }
+
+        // Copy both strings into new buffer
+        memcpy(new_errmsg, fstring_msg, strlen(fstring_msg));
+        memcpy(new_errmsg + strlen(fstring_msg), errmsg, strlen(errmsg));
+        new_errmsg[len] = 0;
+        errmsg = new_errmsg;
+    }
+    errstr = PyUnicode_FromFormatV(errmsg, va);
+    if (!errstr) {
+        goto error;
+    }
+
+    if (p->start_rule == Py_file_input) {
+        error_line = PyErr_ProgramTextObject(p->tok->filename, (int) lineno);
+    }
+
+    if (!error_line) {
+        Py_ssize_t size = p->tok->inp - p->tok->buf;
+        error_line = PyUnicode_DecodeUTF8(p->tok->buf, size, "replace");
+        if (!error_line) {
+            goto error;
+        }
+    }
+
+    if (p->start_rule == Py_fstring_input) {
+        col_offset -= p->starting_col_offset;
+    }
+    Py_ssize_t col_number = col_offset;
+
+    if (p->tok->encoding != NULL) {
+        col_number = byte_offset_to_character_offset(error_line, col_offset);
+    }
+
+    tmp = Py_BuildValue("(OiiN)", p->tok->filename, lineno, col_number, error_line);
+    if (!tmp) {
+        goto error;
+    }
+    value = PyTuple_Pack(2, errstr, tmp);
+    Py_DECREF(tmp);
+    if (!value) {
+        goto error;
+    }
+    PyErr_SetObject(errtype, value);
+
+    Py_DECREF(errstr);
+    Py_DECREF(value);
+    if (p->start_rule == Py_fstring_input) {
+        PyMem_RawFree((void *)errmsg);
+    }
+    return NULL;
+
+error:
+    Py_XDECREF(errstr);
+    Py_XDECREF(error_line);
+    if (p->start_rule == Py_fstring_input) {
+        PyMem_RawFree((void *)errmsg);
+    }
+    return NULL;
+}
+
+#if 0
+static const char *
+token_name(int type)
+{
+    if (0 <= type && type <= N_TOKENS) {
+        return _PyParser_TokenNames[type];
+    }
+    return "<Huh?>";
+}
+#endif
+
+// Here, mark is the start of the node, while p->mark is the end.
+// If node==NULL, they should be the same.
+int
+_PyPegen_insert_memo(Parser *p, int mark, int type, void *node)
+{
+    // Insert in front
+    Memo *m = PyArena_Malloc(p->arena, sizeof(Memo));
+    if (m == NULL) {
+        return -1;
+    }
+    m->type = type;
+    m->node = node;
+    m->mark = p->mark;
+    m->next = p->tokens[mark]->memo;
+    p->tokens[mark]->memo = m;
+    return 0;
+}
+
+// Like _PyPegen_insert_memo(), but updates an existing node if found.
+int
+_PyPegen_update_memo(Parser *p, int mark, int type, void *node)
+{
+    for (Memo *m = p->tokens[mark]->memo; m != NULL; m = m->next) {
+        if (m->type == type) {
+            // Update existing node.
+            m->node = node;
+            m->mark = p->mark;
+            return 0;
+        }
+    }
+    // Insert new node.
+    return _PyPegen_insert_memo(p, mark, type, node);
+}
+
+// Return dummy NAME.
+void *
+_PyPegen_dummy_name(Parser *p, ...)
+{
+    static void *cache = NULL;
+
+    if (cache != NULL) {
+        return cache;
+    }
+
+    PyObject *id = _create_dummy_identifier(p);
+    if (!id) {
+        return NULL;
+    }
+    cache = Name(id, Load, 1, 0, 1, 0, p->arena);
+    return cache;
+}
+
+static int
+_get_keyword_or_name_type(Parser *p, const char *name, int name_len)
+{
+    assert(name_len > 0);
+    if (name_len >= p->n_keyword_lists ||
+        p->keywords[name_len] == NULL ||
+        p->keywords[name_len]->type == -1) {
+        return NAME;
+    }
+    for (KeywordToken *k = p->keywords[name_len]; k != NULL && k->type != -1; k++) {
+        if (strncmp(k->str, name, name_len) == 0) {
+            return k->type;
+        }
+    }
+    return NAME;
+}
+
+static int
+growable_comment_array_init(growable_comment_array *arr, size_t initial_size) {
+    assert(initial_size > 0);
+    arr->items = PyMem_Malloc(initial_size * sizeof(*arr->items));
+    arr->size = initial_size;
+    arr->num_items = 0;
+
+    return arr->items != NULL;
+}
+
+static int
+growable_comment_array_add(growable_comment_array *arr, int lineno, char *comment) {
+    if (arr->num_items >= arr->size) {
+        size_t new_size = arr->size * 2;
+        void *new_items_array = PyMem_Realloc(arr->items, new_size * sizeof(*arr->items));
+        if (!new_items_array) {
+            return 0;
+        }
+        arr->items = new_items_array;
+        arr->size = new_size;
+    }
+
+    arr->items[arr->num_items].lineno = lineno;
+    arr->items[arr->num_items].comment = comment;  // Take ownership
+    arr->num_items++;
+    return 1;
+}
+
+static void
+growable_comment_array_deallocate(growable_comment_array *arr) {
+    for (unsigned i = 0; i < arr->num_items; i++) {
+        PyMem_Free(arr->items[i].comment);
+    }
+    PyMem_Free(arr->items);
+}
+
+int
+_PyPegen_fill_token(Parser *p)
+{
+    const char *start;
+    const char *end;
+    int type = PyTokenizer_Get(p->tok, &start, &end);
+
+    // Record and skip '# type: ignore' comments
+    while (type == TYPE_IGNORE) {
+        Py_ssize_t len = end - start;
+        char *tag = PyMem_Malloc(len + 1);
+        if (tag == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        strncpy(tag, start, len);
+        tag[len] = '\0';
+        // Ownership of tag passes to the growable array
+        if (!growable_comment_array_add(&p->type_ignore_comments, p->tok->lineno, tag)) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        type = PyTokenizer_Get(p->tok, &start, &end);
+    }
+
+    if (type == ENDMARKER && p->start_rule == Py_single_input && p->parsing_started) {
+        type = NEWLINE; /* Add an extra newline */
+        p->parsing_started = 0;
+
+        if (p->tok->indent && !(p->flags & PyPARSE_DONT_IMPLY_DEDENT)) {
+            p->tok->pendin = -p->tok->indent;
+            p->tok->indent = 0;
+        }
+    }
+    else {
+        p->parsing_started = 1;
+    }
+
+    if (p->fill == p->size) {
+        int newsize = p->size * 2;
+        Token **new_tokens = PyMem_Realloc(p->tokens, newsize * sizeof(Token *));
+        if (new_tokens == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        p->tokens = new_tokens;
+
+        for (int i = p->size; i < newsize; i++) {
+            p->tokens[i] = PyMem_Malloc(sizeof(Token));
+            if (p->tokens[i] == NULL) {
+                p->size = i; // Needed, in order to cleanup correctly after parser fails
+                PyErr_NoMemory();
+                return -1;
+            }
+            memset(p->tokens[i], '\0', sizeof(Token));
+        }
+        p->size = newsize;
+    }
+
+    Token *t = p->tokens[p->fill];
+    t->type = (type == NAME) ? _get_keyword_or_name_type(p, start, (int)(end - start)) : type;
+    t->bytes = PyBytes_FromStringAndSize(start, end - start);
+    if (t->bytes == NULL) {
+        return -1;
+    }
+    if (PyArena_AddPyObject(p->arena, t->bytes) < 0) {
+        Py_DECREF(t->bytes);
+        return -1;
+    }
+
+    int lineno = type == STRING ? p->tok->first_lineno : p->tok->lineno;
+    const char *line_start = type == STRING ? p->tok->multi_line_start : p->tok->line_start;
+    int end_lineno = p->tok->lineno;
+    int col_offset = -1;
+    int end_col_offset = -1;
+    if (start != NULL && start >= line_start) {
+        col_offset = (int)(start - line_start);
+    }
+    if (end != NULL && end >= p->tok->line_start) {
+        end_col_offset = (int)(end - p->tok->line_start);
+    }
+
+    t->lineno = p->starting_lineno + lineno;
+    t->col_offset = p->tok->lineno == 1 ? p->starting_col_offset + col_offset : col_offset;
+    t->end_lineno = p->starting_lineno + end_lineno;
+    t->end_col_offset = p->tok->lineno == 1 ? p->starting_col_offset + end_col_offset : end_col_offset;
+
+    p->fill += 1;
+
+    if (type == ERRORTOKEN) {
+        if (p->tok->done == E_DECODE) {
+            return raise_decode_error(p);
+        }
+        return tokenizer_error(p);
+
+    }
+
+    return 0;
+}
+
+// Instrumentation to count the effectiveness of memoization.
+// The array counts the number of tokens skipped by memoization,
+// indexed by type.
+
+#define NSTATISTICS 2000
+static long memo_statistics[NSTATISTICS];
+
+void
+_PyPegen_clear_memo_statistics()
+{
+    for (int i = 0; i < NSTATISTICS; i++) {
+        memo_statistics[i] = 0;
+    }
+}
+
+PyObject *
+_PyPegen_get_memo_statistics()
+{
+    PyObject *ret = PyList_New(NSTATISTICS);
+    if (ret == NULL) {
+        return NULL;
+    }
+    for (int i = 0; i < NSTATISTICS; i++) {
+        PyObject *value = PyLong_FromLong(memo_statistics[i]);
+        if (value == NULL) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+        // PyList_SetItem borrows a reference to value.
+        if (PyList_SetItem(ret, i, value) < 0) {
+            Py_DECREF(ret);
+            return NULL;
+        }
+    }
+    return ret;
+}
+
+int  // bool
+_PyPegen_is_memoized(Parser *p, int type, void *pres)
+{
+    if (p->mark == p->fill) {
+        if (_PyPegen_fill_token(p) < 0) {
+            p->error_indicator = 1;
+            return -1;
+        }
+    }
+
+    Token *t = p->tokens[p->mark];
+
+    for (Memo *m = t->memo; m != NULL; m = m->next) {
+        if (m->type == type) {
+            if (0 <= type && type < NSTATISTICS) {
+                long count = m->mark - p->mark;
+                // A memoized negative result counts for one.
+                if (count <= 0) {
+                    count = 1;
+                }
+                memo_statistics[type] += count;
+            }
+            p->mark = m->mark;
+            *(void **)(pres) = m->node;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int
+_PyPegen_lookahead_with_name(int positive, expr_ty (func)(Parser *), Parser *p)
+{
+    int mark = p->mark;
+    void *res = func(p);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead_with_string(int positive, expr_ty (func)(Parser *, const char*), Parser *p, const char* arg)
+{
+    int mark = p->mark;
+    void *res = func(p, arg);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead_with_int(int positive, Token *(func)(Parser *, int), Parser *p, int arg)
+{
+    int mark = p->mark;
+    void *res = func(p, arg);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+int
+_PyPegen_lookahead(int positive, void *(func)(Parser *), Parser *p)
+{
+    int mark = p->mark;
+    void *res = (void*)func(p);
+    p->mark = mark;
+    return (res != NULL) == positive;
+}
+
+Token *
+_PyPegen_expect_token(Parser *p, int type)
+{
+    if (p->mark == p->fill) {
+        if (_PyPegen_fill_token(p) < 0) {
+            p->error_indicator = 1;
+            return NULL;
+        }
+    }
+    Token *t = p->tokens[p->mark];
+    if (t->type != type) {
+        return NULL;
+    }
+    p->mark += 1;
+    return t;
+}
+
+expr_ty
+_PyPegen_expect_soft_keyword(Parser *p, const char *keyword)
+{
+    if (p->mark == p->fill) {
+        if (_PyPegen_fill_token(p) < 0) {
+            p->error_indicator = 1;
+            return NULL;
+        }
+    }
+    Token *t = p->tokens[p->mark];
+    if (t->type != NAME) {
+        return NULL;
+    }
+    char* s = PyBytes_AsString(t->bytes);
+    if (!s) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    if (strcmp(s, keyword) != 0) {
+        return NULL;
+    }
+    return _PyPegen_name_token(p);
+}
+
+Token *
+_PyPegen_get_last_nonnwhitespace_token(Parser *p)
+{
+    assert(p->mark >= 0);
+    Token *token = NULL;
+    for (int m = p->mark - 1; m >= 0; m--) {
+        token = p->tokens[m];
+        if (token->type != ENDMARKER && (token->type < NEWLINE || token->type > DEDENT)) {
+            break;
+        }
+    }
+    return token;
+}
+
+expr_ty
+_PyPegen_name_token(Parser *p)
+{
+    Token *t = _PyPegen_expect_token(p, NAME);
+    if (t == NULL) {
+        return NULL;
+    }
+    char* s = PyBytes_AsString(t->bytes);
+    if (!s) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    PyObject *id = _PyPegen_new_identifier(p, s);
+    if (id == NULL) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+    return Name(id, Load, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset,
+                p->arena);
+}
+
+void *
+_PyPegen_string_token(Parser *p)
+{
+    return _PyPegen_expect_token(p, STRING);
+}
+
+static PyObject *
+parsenumber_raw(const char *s)
+{
+    const char *end;
+    long x;
+    double dx;
+    Py_complex compl;
+    int imflag;
+
+    assert(s != NULL);
+    errno = 0;
+    end = s + strlen(s) - 1;
+    imflag = *end == 'j' || *end == 'J';
+    if (s[0] == '0') {
+        x = (long)PyOS_strtoul(s, (char **)&end, 0);
+        if (x < 0 && errno == 0) {
+            return PyLong_FromString(s, (char **)0, 0);
+        }
+    }
+    else {
+        x = PyOS_strtol(s, (char **)&end, 0);
+    }
+    if (*end == '\0') {
+        if (errno != 0) {
+            return PyLong_FromString(s, (char **)0, 0);
+        }
+        return PyLong_FromLong(x);
+    }
+    /* XXX Huge floats may silently fail */
+    if (imflag) {
+        compl.real = 0.;
+        compl.imag = PyOS_string_to_double(s, (char **)&end, NULL);
+        if (compl.imag == -1.0 && PyErr_Occurred()) {
+            return NULL;
+        }
+        return PyComplex_FromCComplex(compl);
+    }
+    dx = PyOS_string_to_double(s, NULL, NULL);
+    if (dx == -1.0 && PyErr_Occurred()) {
+        return NULL;
+    }
+    return PyFloat_FromDouble(dx);
+}
+
+static PyObject *
+parsenumber(const char *s)
+{
+    char *dup;
+    char *end;
+    PyObject *res = NULL;
+
+    assert(s != NULL);
+
+    if (strchr(s, '_') == NULL) {
+        return parsenumber_raw(s);
+    }
+    /* Create a duplicate without underscores. */
+    dup = PyMem_Malloc(strlen(s) + 1);
+    if (dup == NULL) {
+        return PyErr_NoMemory();
+    }
+    end = dup;
+    for (; *s; s++) {
+        if (*s != '_') {
+            *end++ = *s;
+        }
+    }
+    *end = '\0';
+    res = parsenumber_raw(dup);
+    PyMem_Free(dup);
+    return res;
+}
+
+expr_ty
+_PyPegen_number_token(Parser *p)
+{
+    Token *t = _PyPegen_expect_token(p, NUMBER);
+    if (t == NULL) {
+        return NULL;
+    }
+
+    char *num_raw = PyBytes_AsString(t->bytes);
+    if (num_raw == NULL) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+
+    if (p->feature_version < 6 && strchr(num_raw, '_') != NULL) {
+        p->error_indicator = 1;
+        return RAISE_SYNTAX_ERROR("Underscores in numeric literals are only supported "
+                                  "in Python 3.6 and greater");
+    }
+
+    PyObject *c = parsenumber(num_raw);
+
+    if (c == NULL) {
+        p->error_indicator = 1;
+        return NULL;
+    }
+
+    if (PyArena_AddPyObject(p->arena, c) < 0) {
+        Py_DECREF(c);
+        p->error_indicator = 1;
+        return NULL;
+    }
+
+    return Constant(c, NULL, t->lineno, t->col_offset, t->end_lineno, t->end_col_offset,
+                    p->arena);
+}
+
+static int // bool
+newline_in_string(Parser *p, const char *cur)
+{
+    for (const char *c = cur; c >= p->tok->buf; c--) {
+        if (*c == '\'' || *c == '"') {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/* Check that the source for a single input statement really is a single
+   statement by looking at what is left in the buffer after parsing.
+   Trailing whitespace and comments are OK. */
+static int // bool
+bad_single_statement(Parser *p)
+{
+    const char *cur = strchr(p->tok->buf, '\n');
+
+    /* Newlines are allowed if preceded by a line continuation character
+       or if they appear inside a string. */
+    if (!cur || (cur != p->tok->buf && *(cur - 1) == '\\')
+             || newline_in_string(p, cur)) {
+        return 0;
+    }
+    char c = *cur;
+
+    for (;;) {
+        while (c == ' ' || c == '\t' || c == '\n' || c == '\014') {
+            c = *++cur;
+        }
+
+        if (!c) {
+            return 0;
+        }
+
+        if (c != '#') {
+            return 1;
+        }
+
+        /* Suck up comment. */
+        while (c && c != '\n') {
+            c = *++cur;
+        }
+    }
+}
+
+void
+_PyPegen_Parser_Free(Parser *p)
+{
+    Py_XDECREF(p->normalize);
+    for (int i = 0; i < p->size; i++) {
+        PyMem_Free(p->tokens[i]);
+    }
+    PyMem_Free(p->tokens);
+    growable_comment_array_deallocate(&p->type_ignore_comments);
+    PyMem_Free(p);
+}
+
+static int
+compute_parser_flags(PyCompilerFlags *flags)
+{
+    int parser_flags = 0;
+    if (!flags) {
+        return 0;
+    }
+    if (flags->cf_flags & PyCF_DONT_IMPLY_DEDENT) {
+        parser_flags |= PyPARSE_DONT_IMPLY_DEDENT;
+    }
+    if (flags->cf_flags & PyCF_IGNORE_COOKIE) {
+        parser_flags |= PyPARSE_IGNORE_COOKIE;
+    }
+    if (flags->cf_flags & CO_FUTURE_BARRY_AS_BDFL) {
+        parser_flags |= PyPARSE_BARRY_AS_BDFL;
+    }
+    if (flags->cf_flags & PyCF_TYPE_COMMENTS) {
+        parser_flags |= PyPARSE_TYPE_COMMENTS;
+    }
+    if ((flags->cf_flags & PyCF_ONLY_AST) && flags->cf_feature_version < 7) {
+        parser_flags |= PyPARSE_ASYNC_HACKS;
+    }
+    return parser_flags;
+}
+
+Parser *
+_PyPegen_Parser_New(struct tok_state *tok, int start_rule, int flags,
+                    int feature_version, int *errcode, PyArena *arena)
+{
+    Parser *p = PyMem_Malloc(sizeof(Parser));
+    if (p == NULL) {
+        return (Parser *) PyErr_NoMemory();
+    }
+    assert(tok != NULL);
+    tok->type_comments = (flags & PyPARSE_TYPE_COMMENTS) > 0;
+    tok->async_hacks = (flags & PyPARSE_ASYNC_HACKS) > 0;
+    p->tok = tok;
+    p->keywords = NULL;
+    p->n_keyword_lists = -1;
+    p->tokens = PyMem_Malloc(sizeof(Token *));
+    if (!p->tokens) {
+        PyMem_Free(p);
+        return (Parser *) PyErr_NoMemory();
+    }
+    p->tokens[0] = PyMem_Calloc(1, sizeof(Token));
+    if (!p->tokens) {
+        PyMem_Free(p->tokens);
+        PyMem_Free(p);
+        return (Parser *) PyErr_NoMemory();
+    }
+    if (!growable_comment_array_init(&p->type_ignore_comments, 10)) {
+        PyMem_Free(p->tokens[0]);
+        PyMem_Free(p->tokens);
+        PyMem_Free(p);
+        return (Parser *) PyErr_NoMemory();
+    }
+
+    p->mark = 0;
+    p->fill = 0;
+    p->size = 1;
+
+    p->errcode = errcode;
+    p->arena = arena;
+    p->start_rule = start_rule;
+    p->parsing_started = 0;
+    p->normalize = NULL;
+    p->error_indicator = 0;
+
+    p->starting_lineno = 0;
+    p->starting_col_offset = 0;
+    p->flags = flags;
+    p->feature_version = feature_version;
+    p->known_err_token = NULL;
+    p->level = 0;
+    p->call_invalid_rules = 0;
+
+    return p;
+}
+
+static void
+reset_parser_state(Parser *p)
+{
+    for (int i = 0; i < p->fill; i++) {
+        p->tokens[i]->memo = NULL;
+    }
+    p->mark = 0;
+    p->call_invalid_rules = 1;
+}
+
+void *
+_PyPegen_run_parser(Parser *p)
+{
+    void *res = _PyPegen_parse(p);
+    if (res == NULL) {
+        reset_parser_state(p);
+        _PyPegen_parse(p);
+        if (PyErr_Occurred()) {
+            return NULL;
+        }
+        if (p->fill == 0) {
+            RAISE_SYNTAX_ERROR("error at start before reading any input");
+        }
+        else if (p->tok->done == E_EOF) {
+            RAISE_SYNTAX_ERROR("unexpected EOF while parsing");
+        }
+        else {
+            if (p->tokens[p->fill-1]->type == INDENT) {
+                RAISE_INDENTATION_ERROR("unexpected indent");
+            }
+            else if (p->tokens[p->fill-1]->type == DEDENT) {
+                RAISE_INDENTATION_ERROR("unexpected unindent");
+            }
+            else {
+                RAISE_SYNTAX_ERROR("invalid syntax");
+            }
+        }
+        return NULL;
+    }
+
+    if (p->start_rule == Py_single_input && bad_single_statement(p)) {
+        p->tok->done = E_BADSINGLE; // This is not necessary for now, but might be in the future
+        return RAISE_SYNTAX_ERROR("multiple statements found while compiling a single statement");
+    }
+
+#if defined(Py_DEBUG) && defined(Py_BUILD_CORE)
+    if (p->start_rule == Py_single_input ||
+        p->start_rule == Py_file_input ||
+        p->start_rule == Py_eval_input)
+    {
+        assert(PyAST_Validate(res));
+    }
+#endif
+    return res;
+}
+
+mod_ty
+_PyPegen_run_parser_from_file_pointer(FILE *fp, int start_rule, PyObject *filename_ob,
+                             const char *enc, const char *ps1, const char *ps2,
+                             PyCompilerFlags *flags, int *errcode, PyArena *arena)
+{
+    struct tok_state *tok = PyTokenizer_FromFile(fp, enc, ps1, ps2);
+    if (tok == NULL) {
+        if (PyErr_Occurred()) {
+            raise_tokenizer_init_error(filename_ob);
+            return NULL;
+        }
+        return NULL;
+    }
+    // This transfers the ownership to the tokenizer
+    tok->filename = filename_ob;
+    Py_INCREF(filename_ob);
+
+    // From here on we need to clean up even if there's an error
+    mod_ty result = NULL;
+
+    int parser_flags = compute_parser_flags(flags);
+    Parser *p = _PyPegen_Parser_New(tok, start_rule, parser_flags, PY_MINOR_VERSION,
+                                    errcode, arena);
+    if (p == NULL) {
+        goto error;
+    }
+
+    result = _PyPegen_run_parser(p);
+    _PyPegen_Parser_Free(p);
+
+error:
+    PyTokenizer_Free(tok);
+    return result;
+}
+
+mod_ty
+_PyPegen_run_parser_from_file(const char *filename, int start_rule,
+                     PyObject *filename_ob, PyCompilerFlags *flags, PyArena *arena)
+{
+    FILE *fp = fopen(filename, "rb");
+    if (fp == NULL) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
+        return NULL;
+    }
+
+    mod_ty result = _PyPegen_run_parser_from_file_pointer(fp, start_rule, filename_ob,
+                                                 NULL, NULL, NULL, flags, NULL, arena);
+
+    fclose(fp);
+    return result;
+}
+
+mod_ty
+_PyPegen_run_parser_from_string(const char *str, int start_rule, PyObject *filename_ob,
+                       PyCompilerFlags *flags, PyArena *arena)
+{
+    int exec_input = start_rule == Py_file_input;
+
+    struct tok_state *tok;
+    if (flags != NULL && flags->cf_flags & PyCF_IGNORE_COOKIE) {
+        tok = PyTokenizer_FromUTF8(str, exec_input);
+    } else {
+        tok = PyTokenizer_FromString(str, exec_input);
+    }
+    if (tok == NULL) {
+        if (PyErr_Occurred()) {
+            raise_tokenizer_init_error(filename_ob);
+        }
+        return NULL;
+    }
+    // This transfers the ownership to the tokenizer
+    tok->filename = filename_ob;
+    Py_INCREF(filename_ob);
+
+    // We need to clear up from here on
+    mod_ty result = NULL;
+
+    int parser_flags = compute_parser_flags(flags);
+    int feature_version = flags && (flags->cf_flags & PyCF_ONLY_AST) ?
+        flags->cf_feature_version : PY_MINOR_VERSION;
+    Parser *p = _PyPegen_Parser_New(tok, start_rule, parser_flags, feature_version,
+                                    NULL, arena);
+    if (p == NULL) {
+        goto error;
+    }
+
+    result = _PyPegen_run_parser(p);
+    _PyPegen_Parser_Free(p);
+
+error:
+    PyTokenizer_Free(tok);
+    return result;
+}
+
+void *
+_PyPegen_interactive_exit(Parser *p)
+{
+    if (p->errcode) {
+        *(p->errcode) = E_EOF;
+    }
+    return NULL;
+}
+
+/* Creates a single-element asdl_seq* that contains a */
+asdl_seq *
+_PyPegen_singleton_seq(Parser *p, void *a)
+{
+    assert(a != NULL);
+    asdl_seq *seq = _Py_asdl_seq_new(1, p->arena);
+    if (!seq) {
+        return NULL;
+    }
+    asdl_seq_SET(seq, 0, a);
+    return seq;
+}
+
+/* Creates a copy of seq and prepends a to it */
+asdl_seq *
+_PyPegen_seq_insert_in_front(Parser *p, void *a, asdl_seq *seq)
+{
+    assert(a != NULL);
+    if (!seq) {
+        return _PyPegen_singleton_seq(p, a);
+    }
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    asdl_seq_SET(new_seq, 0, a);
+    for (Py_ssize_t i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
+        asdl_seq_SET(new_seq, i, asdl_seq_GET(seq, i - 1));
+    }
+    return new_seq;
+}
+
+/* Creates a copy of seq and appends a to it */
+asdl_seq *
+_PyPegen_seq_append_to_end(Parser *p, asdl_seq *seq, void *a)
+{
+    assert(a != NULL);
+    if (!seq) {
+        return _PyPegen_singleton_seq(p, a);
+    }
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(new_seq); i + 1 < l; i++) {
+        asdl_seq_SET(new_seq, i, asdl_seq_GET(seq, i));
+    }
+    asdl_seq_SET(new_seq, asdl_seq_LEN(new_seq) - 1, a);
+    return new_seq;
+}
+
+static Py_ssize_t
+_get_flattened_seq_size(asdl_seq *seqs)
+{
+    Py_ssize_t size = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+        asdl_seq *inner_seq = asdl_seq_GET(seqs, i);
+        size += asdl_seq_LEN(inner_seq);
+    }
+    return size;
+}
+
+/* Flattens an asdl_seq* of asdl_seq*s */
+asdl_seq *
+_PyPegen_seq_flatten(Parser *p, asdl_seq *seqs)
+{
+    Py_ssize_t flattened_seq_size = _get_flattened_seq_size(seqs);
+    assert(flattened_seq_size > 0);
+
+    asdl_seq *flattened_seq = _Py_asdl_seq_new(flattened_seq_size, p->arena);
+    if (!flattened_seq) {
+        return NULL;
+    }
+
+    int flattened_seq_idx = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seqs); i < l; i++) {
+        asdl_seq *inner_seq = asdl_seq_GET(seqs, i);
+        for (Py_ssize_t j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
+            asdl_seq_SET(flattened_seq, flattened_seq_idx++, asdl_seq_GET(inner_seq, j));
+        }
+    }
+    assert(flattened_seq_idx == flattened_seq_size);
+
+    return flattened_seq;
+}
+
+/* Creates a new name of the form <first_name>.<second_name> */
+expr_ty
+_PyPegen_join_names_with_dot(Parser *p, expr_ty first_name, expr_ty second_name)
+{
+    assert(first_name != NULL && second_name != NULL);
+    PyObject *first_identifier = first_name->v.Name.id;
+    PyObject *second_identifier = second_name->v.Name.id;
+
+    if (PyUnicode_READY(first_identifier) == -1) {
+        return NULL;
+    }
+    if (PyUnicode_READY(second_identifier) == -1) {
+        return NULL;
+    }
+    const char *first_str = PyUnicode_AsUTF8(first_identifier);
+    if (!first_str) {
+        return NULL;
+    }
+    const char *second_str = PyUnicode_AsUTF8(second_identifier);
+    if (!second_str) {
+        return NULL;
+    }
+    Py_ssize_t len = strlen(first_str) + strlen(second_str) + 1;  // +1 for the dot
+
+    PyObject *str = PyBytes_FromStringAndSize(NULL, len);
+    if (!str) {
+        return NULL;
+    }
+
+    char *s = PyBytes_AS_STRING(str);
+    if (!s) {
+        return NULL;
+    }
+
+    strcpy(s, first_str);
+    s += strlen(first_str);
+    *s++ = '.';
+    strcpy(s, second_str);
+    s += strlen(second_str);
+    *s = '\0';
+
+    PyObject *uni = PyUnicode_DecodeUTF8(PyBytes_AS_STRING(str), PyBytes_GET_SIZE(str), NULL);
+    Py_DECREF(str);
+    if (!uni) {
+        return NULL;
+    }
+    PyUnicode_InternInPlace(&uni);
+    if (PyArena_AddPyObject(p->arena, uni) < 0) {
+        Py_DECREF(uni);
+        return NULL;
+    }
+
+    return _Py_Name(uni, Load, EXTRA_EXPR(first_name, second_name));
+}
+
+/* Counts the total number of dots in seq's tokens */
+int
+_PyPegen_seq_count_dots(asdl_seq *seq)
+{
+    int number_of_dots = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+        Token *current_expr = asdl_seq_GET(seq, i);
+        switch (current_expr->type) {
+            case ELLIPSIS:
+                number_of_dots += 3;
+                break;
+            case DOT:
+                number_of_dots += 1;
+                break;
+            default:
+                Py_UNREACHABLE();
+        }
+    }
+
+    return number_of_dots;
+}
+
+/* Creates an alias with '*' as the identifier name */
+alias_ty
+_PyPegen_alias_for_star(Parser *p)
+{
+    PyObject *str = PyUnicode_InternFromString("*");
+    if (!str) {
+        return NULL;
+    }
+    if (PyArena_AddPyObject(p->arena, str) < 0) {
+        Py_DECREF(str);
+        return NULL;
+    }
+    return alias(str, NULL, p->arena);
+}
+
+/* Creates a new asdl_seq* with the identifiers of all the names in seq */
+asdl_seq *
+_PyPegen_map_names_to_ids(Parser *p, asdl_seq *seq)
+{
+    Py_ssize_t len = asdl_seq_LEN(seq);
+    assert(len > 0);
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        expr_ty e = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, e->v.Name.id);
+    }
+    return new_seq;
+}
+
+/* Constructs a CmpopExprPair */
+CmpopExprPair *
+_PyPegen_cmpop_expr_pair(Parser *p, cmpop_ty cmpop, expr_ty expr)
+{
+    assert(expr != NULL);
+    CmpopExprPair *a = PyArena_Malloc(p->arena, sizeof(CmpopExprPair));
+    if (!a) {
+        return NULL;
+    }
+    a->cmpop = cmpop;
+    a->expr = expr;
+    return a;
+}
+
+asdl_int_seq *
+_PyPegen_get_cmpops(Parser *p, asdl_seq *seq)
+{
+    Py_ssize_t len = asdl_seq_LEN(seq);
+    assert(len > 0);
+
+    asdl_int_seq *new_seq = _Py_asdl_int_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        CmpopExprPair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->cmpop);
+    }
+    return new_seq;
+}
+
+asdl_seq *
+_PyPegen_get_exprs(Parser *p, asdl_seq *seq)
+{
+    Py_ssize_t len = asdl_seq_LEN(seq);
+    assert(len > 0);
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        CmpopExprPair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->expr);
+    }
+    return new_seq;
+}
+
+/* Creates an asdl_seq* where all the elements have been changed to have ctx as context */
+static asdl_seq *
+_set_seq_context(Parser *p, asdl_seq *seq, expr_context_ty ctx)
+{
+    Py_ssize_t len = asdl_seq_LEN(seq);
+    if (len == 0) {
+        return NULL;
+    }
+
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        expr_ty e = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, _PyPegen_set_expr_context(p, e, ctx));
+    }
+    return new_seq;
+}
+
+static expr_ty
+_set_name_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Name(e->v.Name.id, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_tuple_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Tuple(_set_seq_context(p, e->v.Tuple.elts, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_list_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_List(_set_seq_context(p, e->v.List.elts, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_subscript_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Subscript(e->v.Subscript.value, e->v.Subscript.slice, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_attribute_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Attribute(e->v.Attribute.value, e->v.Attribute.attr, ctx, EXTRA_EXPR(e, e));
+}
+
+static expr_ty
+_set_starred_context(Parser *p, expr_ty e, expr_context_ty ctx)
+{
+    return _Py_Starred(_PyPegen_set_expr_context(p, e->v.Starred.value, ctx), ctx, EXTRA_EXPR(e, e));
+}
+
+/* Creates an `expr_ty` equivalent to `expr` but with `ctx` as context */
+expr_ty
+_PyPegen_set_expr_context(Parser *p, expr_ty expr, expr_context_ty ctx)
+{
+    assert(expr != NULL);
+
+    expr_ty new = NULL;
+    switch (expr->kind) {
+        case Name_kind:
+            new = _set_name_context(p, expr, ctx);
+            break;
+        case Tuple_kind:
+            new = _set_tuple_context(p, expr, ctx);
+            break;
+        case List_kind:
+            new = _set_list_context(p, expr, ctx);
+            break;
+        case Subscript_kind:
+            new = _set_subscript_context(p, expr, ctx);
+            break;
+        case Attribute_kind:
+            new = _set_attribute_context(p, expr, ctx);
+            break;
+        case Starred_kind:
+            new = _set_starred_context(p, expr, ctx);
+            break;
+        default:
+            new = expr;
+    }
+    return new;
+}
+
+/* Constructs a KeyValuePair that is used when parsing a dict's key value pairs */
+KeyValuePair *
+_PyPegen_key_value_pair(Parser *p, expr_ty key, expr_ty value)
+{
+    KeyValuePair *a = PyArena_Malloc(p->arena, sizeof(KeyValuePair));
+    if (!a) {
+        return NULL;
+    }
+    a->key = key;
+    a->value = value;
+    return a;
+}
+
+/* Extracts all keys from an asdl_seq* of KeyValuePair*'s */
+asdl_seq *
+_PyPegen_get_keys(Parser *p, asdl_seq *seq)
+{
+    Py_ssize_t len = asdl_seq_LEN(seq);
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        KeyValuePair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->key);
+    }
+    return new_seq;
+}
+
+/* Extracts all values from an asdl_seq* of KeyValuePair*'s */
+asdl_seq *
+_PyPegen_get_values(Parser *p, asdl_seq *seq)
+{
+    Py_ssize_t len = asdl_seq_LEN(seq);
+    asdl_seq *new_seq = _Py_asdl_seq_new(len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        KeyValuePair *pair = asdl_seq_GET(seq, i);
+        asdl_seq_SET(new_seq, i, pair->value);
+    }
+    return new_seq;
+}
+
+/* Constructs a NameDefaultPair */
+NameDefaultPair *
+_PyPegen_name_default_pair(Parser *p, arg_ty arg, expr_ty value, Token *tc)
+{
+    NameDefaultPair *a = PyArena_Malloc(p->arena, sizeof(NameDefaultPair));
+    if (!a) {
+        return NULL;
+    }
+    a->arg = _PyPegen_add_type_comment_to_arg(p, arg, tc);
+    a->value = value;
+    return a;
+}
+
+/* Constructs a SlashWithDefault */
+SlashWithDefault *
+_PyPegen_slash_with_default(Parser *p, asdl_seq *plain_names, asdl_seq *names_with_defaults)
+{
+    SlashWithDefault *a = PyArena_Malloc(p->arena, sizeof(SlashWithDefault));
+    if (!a) {
+        return NULL;
+    }
+    a->plain_names = plain_names;
+    a->names_with_defaults = names_with_defaults;
+    return a;
+}
+
+/* Constructs a StarEtc */
+StarEtc *
+_PyPegen_star_etc(Parser *p, arg_ty vararg, asdl_seq *kwonlyargs, arg_ty kwarg)
+{
+    StarEtc *a = PyArena_Malloc(p->arena, sizeof(StarEtc));
+    if (!a) {
+        return NULL;
+    }
+    a->vararg = vararg;
+    a->kwonlyargs = kwonlyargs;
+    a->kwarg = kwarg;
+    return a;
+}
+
+asdl_seq *
+_PyPegen_join_sequences(Parser *p, asdl_seq *a, asdl_seq *b)
+{
+    Py_ssize_t first_len = asdl_seq_LEN(a);
+    Py_ssize_t second_len = asdl_seq_LEN(b);
+    asdl_seq *new_seq = _Py_asdl_seq_new(first_len + second_len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    int k = 0;
+    for (Py_ssize_t i = 0; i < first_len; i++) {
+        asdl_seq_SET(new_seq, k++, asdl_seq_GET(a, i));
+    }
+    for (Py_ssize_t i = 0; i < second_len; i++) {
+        asdl_seq_SET(new_seq, k++, asdl_seq_GET(b, i));
+    }
+
+    return new_seq;
+}
+
+static asdl_seq *
+_get_names(Parser *p, asdl_seq *names_with_defaults)
+{
+    Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
+    asdl_seq *seq = _Py_asdl_seq_new(len, p->arena);
+    if (!seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i);
+        asdl_seq_SET(seq, i, pair->arg);
+    }
+    return seq;
+}
+
+static asdl_seq *
+_get_defaults(Parser *p, asdl_seq *names_with_defaults)
+{
+    Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
+    asdl_seq *seq = _Py_asdl_seq_new(len, p->arena);
+    if (!seq) {
+        return NULL;
+    }
+    for (Py_ssize_t i = 0; i < len; i++) {
+        NameDefaultPair *pair = asdl_seq_GET(names_with_defaults, i);
+        asdl_seq_SET(seq, i, pair->value);
+    }
+    return seq;
+}
+
+/* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */
+arguments_ty
+_PyPegen_make_arguments(Parser *p, asdl_seq *slash_without_default,
+                        SlashWithDefault *slash_with_default, asdl_seq *plain_names,
+                        asdl_seq *names_with_default, StarEtc *star_etc)
+{
+    asdl_seq *posonlyargs;
+    if (slash_without_default != NULL) {
+        posonlyargs = slash_without_default;
+    }
+    else if (slash_with_default != NULL) {
+        asdl_seq *slash_with_default_names =
+            _get_names(p, slash_with_default->names_with_defaults);
+        if (!slash_with_default_names) {
+            return NULL;
+        }
+        posonlyargs = _PyPegen_join_sequences(p, slash_with_default->plain_names, slash_with_default_names);
+        if (!posonlyargs) {
+            return NULL;
+        }
+    }
+    else {
+        posonlyargs = _Py_asdl_seq_new(0, p->arena);
+        if (!posonlyargs) {
+            return NULL;
+        }
+    }
+
+    asdl_seq *posargs;
+    if (plain_names != NULL && names_with_default != NULL) {
+        asdl_seq *names_with_default_names = _get_names(p, names_with_default);
+        if (!names_with_default_names) {
+            return NULL;
+        }
+        posargs = _PyPegen_join_sequences(p, plain_names, names_with_default_names);
+        if (!posargs) {
+            return NULL;
+        }
+    }
+    else if (plain_names == NULL && names_with_default != NULL) {
+        posargs = _get_names(p, names_with_default);
+        if (!posargs) {
+            return NULL;
+        }
+    }
+    else if (plain_names != NULL && names_with_default == NULL) {
+        posargs = plain_names;
+    }
+    else {
+        posargs = _Py_asdl_seq_new(0, p->arena);
+        if (!posargs) {
+            return NULL;
+        }
+    }
+
+    asdl_seq *posdefaults;
+    if (slash_with_default != NULL && names_with_default != NULL) {
+        asdl_seq *slash_with_default_values =
+            _get_defaults(p, slash_with_default->names_with_defaults);
+        if (!slash_with_default_values) {
+            return NULL;
+        }
+        asdl_seq *names_with_default_values = _get_defaults(p, names_with_default);
+        if (!names_with_default_values) {
+            return NULL;
+        }
+        posdefaults = _PyPegen_join_sequences(p, slash_with_default_values, names_with_default_values);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+    else if (slash_with_default == NULL && names_with_default != NULL) {
+        posdefaults = _get_defaults(p, names_with_default);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+    else if (slash_with_default != NULL && names_with_default == NULL) {
+        posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+    else {
+        posdefaults = _Py_asdl_seq_new(0, p->arena);
+        if (!posdefaults) {
+            return NULL;
+        }
+    }
+
+    arg_ty vararg = NULL;
+    if (star_etc != NULL && star_etc->vararg != NULL) {
+        vararg = star_etc->vararg;
+    }
+
+    asdl_seq *kwonlyargs;
+    if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+        kwonlyargs = _get_names(p, star_etc->kwonlyargs);
+        if (!kwonlyargs) {
+            return NULL;
+        }
+    }
+    else {
+        kwonlyargs = _Py_asdl_seq_new(0, p->arena);
+        if (!kwonlyargs) {
+            return NULL;
+        }
+    }
+
+    asdl_seq *kwdefaults;
+    if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
+        kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
+        if (!kwdefaults) {
+            return NULL;
+        }
+    }
+    else {
+        kwdefaults = _Py_asdl_seq_new(0, p->arena);
+        if (!kwdefaults) {
+            return NULL;
+        }
+    }
+
+    arg_ty kwarg = NULL;
+    if (star_etc != NULL && star_etc->kwarg != NULL) {
+        kwarg = star_etc->kwarg;
+    }
+
+    return _Py_arguments(posonlyargs, posargs, vararg, kwonlyargs, kwdefaults, kwarg,
+                         posdefaults, p->arena);
+}
+
+/* Constructs an empty arguments_ty object, that gets used when a function accepts no
+ * arguments. */
+arguments_ty
+_PyPegen_empty_arguments(Parser *p)
+{
+    asdl_seq *posonlyargs = _Py_asdl_seq_new(0, p->arena);
+    if (!posonlyargs) {
+        return NULL;
+    }
+    asdl_seq *posargs = _Py_asdl_seq_new(0, p->arena);
+    if (!posargs) {
+        return NULL;
+    }
+    asdl_seq *posdefaults = _Py_asdl_seq_new(0, p->arena);
+    if (!posdefaults) {
+        return NULL;
+    }
+    asdl_seq *kwonlyargs = _Py_asdl_seq_new(0, p->arena);
+    if (!kwonlyargs) {
+        return NULL;
+    }
+    asdl_seq *kwdefaults = _Py_asdl_seq_new(0, p->arena);
+    if (!kwdefaults) {
+        return NULL;
+    }
+
+    return _Py_arguments(posonlyargs, posargs, NULL, kwonlyargs, kwdefaults, NULL, kwdefaults,
+                         p->arena);
+}
+
+/* Encapsulates the value of an operator_ty into an AugOperator struct */
+AugOperator *
+_PyPegen_augoperator(Parser *p, operator_ty kind)
+{
+    AugOperator *a = PyArena_Malloc(p->arena, sizeof(AugOperator));
+    if (!a) {
+        return NULL;
+    }
+    a->kind = kind;
+    return a;
+}
+
+/* Construct a FunctionDef equivalent to function_def, but with decorators */
+stmt_ty
+_PyPegen_function_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty function_def)
+{
+    assert(function_def != NULL);
+    if (function_def->kind == AsyncFunctionDef_kind) {
+        return _Py_AsyncFunctionDef(
+            function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+            function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns,
+            function_def->v.FunctionDef.type_comment, function_def->lineno,
+            function_def->col_offset, function_def->end_lineno, function_def->end_col_offset,
+            p->arena);
+    }
+
+    return _Py_FunctionDef(function_def->v.FunctionDef.name, function_def->v.FunctionDef.args,
+                           function_def->v.FunctionDef.body, decorators,
+                           function_def->v.FunctionDef.returns,
+                           function_def->v.FunctionDef.type_comment, function_def->lineno,
+                           function_def->col_offset, function_def->end_lineno,
+                           function_def->end_col_offset, p->arena);
+}
+
+/* Construct a ClassDef equivalent to class_def, but with decorators */
+stmt_ty
+_PyPegen_class_def_decorators(Parser *p, asdl_seq *decorators, stmt_ty class_def)
+{
+    assert(class_def != NULL);
+    return _Py_ClassDef(class_def->v.ClassDef.name, class_def->v.ClassDef.bases,
+                        class_def->v.ClassDef.keywords, class_def->v.ClassDef.body, decorators,
+                        class_def->lineno, class_def->col_offset, class_def->end_lineno,
+                        class_def->end_col_offset, p->arena);
+}
+
+/* Construct a KeywordOrStarred */
+KeywordOrStarred *
+_PyPegen_keyword_or_starred(Parser *p, void *element, int is_keyword)
+{
+    KeywordOrStarred *a = PyArena_Malloc(p->arena, sizeof(KeywordOrStarred));
+    if (!a) {
+        return NULL;
+    }
+    a->element = element;
+    a->is_keyword = is_keyword;
+    return a;
+}
+
+/* Get the number of starred expressions in an asdl_seq* of KeywordOrStarred*s */
+static int
+_seq_number_of_starred_exprs(asdl_seq *seq)
+{
+    int n = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(seq); i < l; i++) {
+        KeywordOrStarred *k = asdl_seq_GET(seq, i);
+        if (!k->is_keyword) {
+            n++;
+        }
+    }
+    return n;
+}
+
+/* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */
+asdl_seq *
+_PyPegen_seq_extract_starred_exprs(Parser *p, asdl_seq *kwargs)
+{
+    int new_len = _seq_number_of_starred_exprs(kwargs);
+    if (new_len == 0) {
+        return NULL;
+    }
+    asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    int idx = 0;
+    for (Py_ssize_t i = 0, len = asdl_seq_LEN(kwargs); i < len; i++) {
+        KeywordOrStarred *k = asdl_seq_GET(kwargs, i);
+        if (!k->is_keyword) {
+            asdl_seq_SET(new_seq, idx++, k->element);
+        }
+    }
+    return new_seq;
+}
+
+/* Return a new asdl_seq* with only the keywords in kwargs */
+asdl_seq *
+_PyPegen_seq_delete_starred_exprs(Parser *p, asdl_seq *kwargs)
+{
+    Py_ssize_t len = asdl_seq_LEN(kwargs);
+    Py_ssize_t new_len = len - _seq_number_of_starred_exprs(kwargs);
+    if (new_len == 0) {
+        return NULL;
+    }
+    asdl_seq *new_seq = _Py_asdl_seq_new(new_len, p->arena);
+    if (!new_seq) {
+        return NULL;
+    }
+
+    int idx = 0;
+    for (Py_ssize_t i = 0; i < len; i++) {
+        KeywordOrStarred *k = asdl_seq_GET(kwargs, i);
+        if (k->is_keyword) {
+            asdl_seq_SET(new_seq, idx++, k->element);
+        }
+    }
+    return new_seq;
+}
+
+expr_ty
+_PyPegen_concatenate_strings(Parser *p, asdl_seq *strings)
+{
+    Py_ssize_t len = asdl_seq_LEN(strings);
+    assert(len > 0);
+
+    Token *first = asdl_seq_GET(strings, 0);
+    Token *last = asdl_seq_GET(strings, len - 1);
+
+    int bytesmode = 0;
+    PyObject *bytes_str = NULL;
+
+    FstringParser state;
+    _PyPegen_FstringParser_Init(&state);
+
+    for (Py_ssize_t i = 0; i < len; i++) {
+        Token *t = asdl_seq_GET(strings, i);
+
+        int this_bytesmode;
+        int this_rawmode;
+        PyObject *s;
+        const char *fstr;
+        Py_ssize_t fstrlen = -1;
+
+        if (_PyPegen_parsestr(p, &this_bytesmode, &this_rawmode, &s, &fstr, &fstrlen, t) != 0) {
+            goto error;
+        }
+
+        /* Check that we are not mixing bytes with unicode. */
+        if (i != 0 && bytesmode != this_bytesmode) {
+            RAISE_SYNTAX_ERROR("cannot mix bytes and nonbytes literals");
+            Py_XDECREF(s);
+            goto error;
+        }
+        bytesmode = this_bytesmode;
+
+        if (fstr != NULL) {
+            assert(s == NULL && !bytesmode);
+
+            int result = _PyPegen_FstringParser_ConcatFstring(p, &state, &fstr, fstr + fstrlen,
+                                                     this_rawmode, 0, first, t, last);
+            if (result < 0) {
+                goto error;
+            }
+        }
+        else {
+            /* String or byte string. */
+            assert(s != NULL && fstr == NULL);
+            assert(bytesmode ? PyBytes_CheckExact(s) : PyUnicode_CheckExact(s));
+
+            if (bytesmode) {
+                if (i == 0) {
+                    bytes_str = s;
+                }
+                else {
+                    PyBytes_ConcatAndDel(&bytes_str, s);
+                    if (!bytes_str) {
+                        goto error;
+                    }
+                }
+            }
+            else {
+                /* This is a regular string. Concatenate it. */
+                if (_PyPegen_FstringParser_ConcatAndDel(&state, s) < 0) {
+                    goto error;
+                }
+            }
+        }
+    }
+
+    if (bytesmode) {
+        if (PyArena_AddPyObject(p->arena, bytes_str) < 0) {
+            goto error;
+        }
+        return Constant(bytes_str, NULL, first->lineno, first->col_offset, last->end_lineno,
+                        last->end_col_offset, p->arena);
+    }
+
+    return _PyPegen_FstringParser_Finish(p, &state, first, last);
+
+error:
+    Py_XDECREF(bytes_str);
+    _PyPegen_FstringParser_Dealloc(&state);
+    if (PyErr_Occurred()) {
+        raise_decode_error(p);
+    }
+    return NULL;
+}
+
+mod_ty
+_PyPegen_make_module(Parser *p, asdl_seq *a) {
+    asdl_seq *type_ignores = NULL;
+    Py_ssize_t num = p->type_ignore_comments.num_items;
+    if (num > 0) {
+        // Turn the raw (comment, lineno) pairs into TypeIgnore objects in the arena
+        type_ignores = _Py_asdl_seq_new(num, p->arena);
+        if (type_ignores == NULL) {
+            return NULL;
+        }
+        for (int i = 0; i < num; i++) {
+            PyObject *tag = _PyPegen_new_type_comment(p, p->type_ignore_comments.items[i].comment);
+            if (tag == NULL) {
+                return NULL;
+            }
+            type_ignore_ty ti = TypeIgnore(p->type_ignore_comments.items[i].lineno, tag, p->arena);
+            if (ti == NULL) {
+                return NULL;
+            }
+            asdl_seq_SET(type_ignores, i, ti);
+        }
+    }
+    return Module(a, type_ignores, p->arena);
+}
+
+// Error reporting helpers
+
+expr_ty
+_PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type)
+{
+    if (e == NULL) {
+        return NULL;
+    }
+
+#define VISIT_CONTAINER(CONTAINER, TYPE) do { \
+        Py_ssize_t len = asdl_seq_LEN(CONTAINER->v.TYPE.elts);\
+        for (Py_ssize_t i = 0; i < len; i++) {\
+            expr_ty other = asdl_seq_GET(CONTAINER->v.TYPE.elts, i);\
+            expr_ty child = _PyPegen_get_invalid_target(other, targets_type);\
+            if (child != NULL) {\
+                return child;\
+            }\
+        }\
+    } while (0)
+
+    // We only need to visit List and Tuple nodes recursively as those
+    // are the only ones that can contain valid names in targets when
+    // they are parsed as expressions. Any other kind of expression
+    // that is a container (like Sets or Dicts) is directly invalid and
+    // we don't need to visit it recursively.
+
+    switch (e->kind) {
+        case List_kind:
+            VISIT_CONTAINER(e, List);
+            return NULL;
+        case Tuple_kind:
+            VISIT_CONTAINER(e, Tuple);
+            return NULL;
+        case Starred_kind:
+            if (targets_type == DEL_TARGETS) {
+                return e;
+            }
+            return _PyPegen_get_invalid_target(e->v.Starred.value, targets_type);
+        case Compare_kind:
+            // This is needed, because the `a in b` in `for a in b` gets parsed
+            // as a comparison, and so we need to search the left side of the comparison
+            // for invalid targets.
+            if (targets_type == FOR_TARGETS) {
+                cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.ops, 0);
+                if (cmpop == In) {
+                    return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type);
+                }
+                return NULL;
+            }
+            return e;
+        case Name_kind:
+        case Subscript_kind:
+        case Attribute_kind:
+            return NULL;
+        default:
+            return e;
+    }
+}
+
+void *_PyPegen_arguments_parsing_error(Parser *p, expr_ty e) {
+    int kwarg_unpacking = 0;
+    for (Py_ssize_t i = 0, l = asdl_seq_LEN(e->v.Call.keywords); i < l; i++) {
+        keyword_ty keyword = asdl_seq_GET(e->v.Call.keywords, i);
+        if (!keyword->arg) {
+            kwarg_unpacking = 1;
+        }
+    }
+
+    const char *msg = NULL;
+    if (kwarg_unpacking) {
+        msg = "positional argument follows keyword argument unpacking";
+    } else {
+        msg = "positional argument follows keyword argument";
+    }
+
+    return RAISE_SYNTAX_ERROR(msg);
+}
+
+void *
+_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args)
+{
+    /* The rule that calls this function is 'args for_if_clauses'.
+       For the input f(L, x for x in y), L and x are in args and
+       the for is parsed as a for_if_clause. We have to check if
+       len <= 1, so that input like dict((a, b) for a, b in x)
+       gets successfully parsed and then we pass the last
+       argument (x in the above example) as the location of the
+       error */
+    Py_ssize_t len = asdl_seq_LEN(args->v.Call.args);
+    if (len <= 1) {
+        return NULL;
+    }
+
+    return RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
+        (expr_ty) asdl_seq_GET(args->v.Call.args, len - 1),
+        "Generator expression must be parenthesized"
+    );
+}
+
+
+expr_ty _PyPegen_collect_call_seqs(Parser *p, asdl_seq *a, asdl_seq *b,
+                     int lineno, int col_offset, int end_lineno,
+                     int end_col_offset, PyArena *arena) {
+    Py_ssize_t args_len = asdl_seq_LEN(a);
+    Py_ssize_t total_len = args_len;
+
+    if (b == NULL) {
+        return _Py_Call(_PyPegen_dummy_name(p), a, NULL, lineno, col_offset,
+                        end_lineno, end_col_offset, arena);
+
+    }
+
+    asdl_seq *starreds = _PyPegen_seq_extract_starred_exprs(p, b);
+    asdl_seq *keywords = _PyPegen_seq_delete_starred_exprs(p, b);
+
+    if (starreds) {
+        total_len += asdl_seq_LEN(starreds);
+    }
+
+    asdl_seq *args = _Py_asdl_seq_new(total_len, arena);
+
+    Py_ssize_t i = 0;
+    for (i = 0; i < args_len; i++) {
+        asdl_seq_SET(args, i, asdl_seq_GET(a, i));
+    }
+    for (; i < total_len; i++) {
+        asdl_seq_SET(args, i, asdl_seq_GET(starreds, i - args_len));
+    }
+
+    return _Py_Call(_PyPegen_dummy_name(p), args, keywords, lineno,
+                    col_offset, end_lineno, end_col_offset, arena);
+
+
+}
diff --git a/contrib/tools/python3/src/Parser/pegen/pegen.h b/contrib/tools/python3/src/Parser/pegen/pegen.h
index 49cc35ec1f..224c5cbea6 100644
--- a/contrib/tools/python3/src/Parser/pegen/pegen.h
+++ b/contrib/tools/python3/src/Parser/pegen/pegen.h
@@ -1,307 +1,307 @@
-#ifndef PEGEN_H 
-#define PEGEN_H 
- 
-#define PY_SSIZE_T_CLEAN 
-#include <Python.h> 
-#include <token.h> 
-#include <Python-ast.h> 
-#include <pyarena.h> 
- 
-#if 0 
-#define PyPARSE_YIELD_IS_KEYWORD        0x0001 
-#endif 
- 
-#define PyPARSE_DONT_IMPLY_DEDENT       0x0002 
- 
-#if 0 
-#define PyPARSE_WITH_IS_KEYWORD         0x0003 
-#define PyPARSE_PRINT_IS_FUNCTION       0x0004 
-#define PyPARSE_UNICODE_LITERALS        0x0008 
-#endif 
- 
-#define PyPARSE_IGNORE_COOKIE 0x0010 
-#define PyPARSE_BARRY_AS_BDFL 0x0020 
-#define PyPARSE_TYPE_COMMENTS 0x0040 
-#define PyPARSE_ASYNC_HACKS   0x0080 
- 
-typedef struct _memo { 
-    int type; 
-    void *node; 
-    int mark; 
-    struct _memo *next; 
-} Memo; 
- 
-typedef struct { 
-    int type; 
-    PyObject *bytes; 
-    int lineno, col_offset, end_lineno, end_col_offset; 
-    Memo *memo; 
-} Token; 
- 
-typedef struct { 
-    char *str; 
-    int type; 
-} KeywordToken; 
- 
- 
-typedef struct { 
-    struct { 
-        int lineno; 
-        char *comment;  // The " <tag>" in "# type: ignore <tag>" 
-    } *items; 
-    size_t size; 
-    size_t num_items; 
-} growable_comment_array; 
- 
-typedef struct { 
-    struct tok_state *tok; 
-    Token **tokens; 
-    int mark; 
-    int fill, size; 
-    PyArena *arena; 
-    KeywordToken **keywords; 
-    int n_keyword_lists; 
-    int start_rule; 
-    int *errcode; 
-    int parsing_started; 
-    PyObject* normalize; 
-    int starting_lineno; 
-    int starting_col_offset; 
-    int error_indicator; 
-    int flags; 
-    int feature_version; 
-    growable_comment_array type_ignore_comments; 
-    Token *known_err_token; 
-    int level; 
-    int call_invalid_rules; 
-} Parser; 
- 
-typedef struct { 
-    cmpop_ty cmpop; 
-    expr_ty expr; 
-} CmpopExprPair; 
- 
-typedef struct { 
-    expr_ty key; 
-    expr_ty value; 
-} KeyValuePair; 
- 
-typedef struct { 
-    arg_ty arg; 
-    expr_ty value; 
-} NameDefaultPair; 
- 
-typedef struct { 
-    asdl_seq *plain_names; 
-    asdl_seq *names_with_defaults; // asdl_seq* of NameDefaultsPair's 
-} SlashWithDefault; 
- 
-typedef struct { 
-    arg_ty vararg; 
-    asdl_seq *kwonlyargs; // asdl_seq* of NameDefaultsPair's 
-    arg_ty kwarg; 
-} StarEtc; 
- 
-typedef struct { 
-    operator_ty kind; 
-} AugOperator; 
- 
-typedef struct { 
-    void *element; 
-    int is_keyword; 
-} KeywordOrStarred; 
- 
-void _PyPegen_clear_memo_statistics(void); 
-PyObject *_PyPegen_get_memo_statistics(void); 
- 
-int _PyPegen_insert_memo(Parser *p, int mark, int type, void *node); 
-int _PyPegen_update_memo(Parser *p, int mark, int type, void *node); 
-int _PyPegen_is_memoized(Parser *p, int type, void *pres); 
- 
-int _PyPegen_lookahead_with_name(int, expr_ty (func)(Parser *), Parser *); 
-int _PyPegen_lookahead_with_string(int , expr_ty (func)(Parser *, const char*), Parser *, const char*); 
-int _PyPegen_lookahead_with_int(int, Token *(func)(Parser *, int), Parser *, int); 
-int _PyPegen_lookahead(int, void *(func)(Parser *), Parser *); 
- 
-Token *_PyPegen_expect_token(Parser *p, int type); 
-expr_ty _PyPegen_expect_soft_keyword(Parser *p, const char *keyword); 
-Token *_PyPegen_get_last_nonnwhitespace_token(Parser *); 
-int _PyPegen_fill_token(Parser *p); 
-expr_ty _PyPegen_name_token(Parser *p); 
-expr_ty _PyPegen_number_token(Parser *p); 
-void *_PyPegen_string_token(Parser *p); 
-const char *_PyPegen_get_expr_name(expr_ty); 
-void *_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...); 
-void *_PyPegen_raise_error_known_location(Parser *p, PyObject *errtype, 
-                                          Py_ssize_t lineno, Py_ssize_t col_offset, 
-                                          const char *errmsg, va_list va); 
-void *_PyPegen_dummy_name(Parser *p, ...); 
- 
-Py_LOCAL_INLINE(void *) 
-RAISE_ERROR_KNOWN_LOCATION(Parser *p, PyObject *errtype, 
-                           Py_ssize_t lineno, Py_ssize_t col_offset, 
-                           const char *errmsg, ...) 
-{ 
-    va_list va; 
-    va_start(va, errmsg); 
-    _PyPegen_raise_error_known_location(p, errtype, lineno, col_offset + 1, 
-                                        errmsg, va); 
-    va_end(va); 
-    return NULL; 
-} 
- 
- 
-#define UNUSED(expr) do { (void)(expr); } while (0) 
-#define EXTRA_EXPR(head, tail) head->lineno, head->col_offset, tail->end_lineno, tail->end_col_offset, p->arena 
-#define EXTRA _start_lineno, _start_col_offset, _end_lineno, _end_col_offset, p->arena 
-#define RAISE_SYNTAX_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_SyntaxError, msg, ##__VA_ARGS__) 
-#define RAISE_INDENTATION_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_IndentationError, msg, ##__VA_ARGS__) 
-#define RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, msg, ...) \ 
-    RAISE_ERROR_KNOWN_LOCATION(p, PyExc_SyntaxError, (a)->lineno, (a)->col_offset, msg, ##__VA_ARGS__) 
- 
-Py_LOCAL_INLINE(void *) 
-CHECK_CALL(Parser *p, void *result) 
-{ 
-    if (result == NULL) { 
-        assert(PyErr_Occurred()); 
-        p->error_indicator = 1; 
-    } 
-    return result; 
-} 
- 
-/* This is needed for helper functions that are allowed to 
-   return NULL without an error. Example: _PyPegen_seq_extract_starred_exprs */ 
-Py_LOCAL_INLINE(void *) 
-CHECK_CALL_NULL_ALLOWED(Parser *p, void *result) 
-{ 
-    if (result == NULL && PyErr_Occurred()) { 
-        p->error_indicator = 1; 
-    } 
-    return result; 
-} 
- 
-#define CHECK(result) CHECK_CALL(p, result) 
-#define CHECK_NULL_ALLOWED(result) CHECK_CALL_NULL_ALLOWED(p, result) 
- 
-PyObject *_PyPegen_new_type_comment(Parser *, char *); 
- 
-Py_LOCAL_INLINE(PyObject *) 
-NEW_TYPE_COMMENT(Parser *p, Token *tc) 
-{ 
-    if (tc == NULL) { 
-        return NULL; 
-    } 
-    char *bytes = PyBytes_AsString(tc->bytes); 
-    if (bytes == NULL) { 
-        goto error; 
-    } 
-    PyObject *tco = _PyPegen_new_type_comment(p, bytes); 
-    if (tco == NULL) { 
-        goto error; 
-    } 
-    return tco; 
- error: 
-    p->error_indicator = 1;  // Inline CHECK_CALL 
-    return NULL; 
-} 
- 
-Py_LOCAL_INLINE(void *) 
-INVALID_VERSION_CHECK(Parser *p, int version, char *msg, void *node) 
-{ 
-    if (node == NULL) { 
-        p->error_indicator = 1;  // Inline CHECK_CALL 
-        return NULL; 
-    } 
-    if (p->feature_version < version) { 
-        p->error_indicator = 1; 
-        return RAISE_SYNTAX_ERROR("%s only supported in Python 3.%i and greater", 
-                                  msg, version); 
-    } 
-    return node; 
-} 
- 
-#define CHECK_VERSION(version, msg, node) INVALID_VERSION_CHECK(p, version, msg, node) 
- 
-arg_ty _PyPegen_add_type_comment_to_arg(Parser *, arg_ty, Token *); 
-PyObject *_PyPegen_new_identifier(Parser *, char *); 
-Parser *_PyPegen_Parser_New(struct tok_state *, int, int, int, int *, PyArena *); 
-void _PyPegen_Parser_Free(Parser *); 
-mod_ty _PyPegen_run_parser_from_file_pointer(FILE *, int, PyObject *, const char *, 
-                                    const char *, const char *, PyCompilerFlags *, int *, PyArena *); 
-void *_PyPegen_run_parser(Parser *); 
-mod_ty _PyPegen_run_parser_from_file(const char *, int, PyObject *, PyCompilerFlags *, PyArena *); 
-mod_ty _PyPegen_run_parser_from_string(const char *, int, PyObject *, PyCompilerFlags *, PyArena *); 
-void *_PyPegen_interactive_exit(Parser *); 
-asdl_seq *_PyPegen_singleton_seq(Parser *, void *); 
-asdl_seq *_PyPegen_seq_insert_in_front(Parser *, void *, asdl_seq *); 
-asdl_seq *_PyPegen_seq_append_to_end(Parser *, asdl_seq *, void *); 
-asdl_seq *_PyPegen_seq_flatten(Parser *, asdl_seq *); 
-expr_ty _PyPegen_join_names_with_dot(Parser *, expr_ty, expr_ty); 
-int _PyPegen_seq_count_dots(asdl_seq *); 
-alias_ty _PyPegen_alias_for_star(Parser *); 
-asdl_seq *_PyPegen_map_names_to_ids(Parser *, asdl_seq *); 
-CmpopExprPair *_PyPegen_cmpop_expr_pair(Parser *, cmpop_ty, expr_ty); 
-asdl_int_seq *_PyPegen_get_cmpops(Parser *p, asdl_seq *); 
-asdl_seq *_PyPegen_get_exprs(Parser *, asdl_seq *); 
-expr_ty _PyPegen_set_expr_context(Parser *, expr_ty, expr_context_ty); 
-KeyValuePair *_PyPegen_key_value_pair(Parser *, expr_ty, expr_ty); 
-asdl_seq *_PyPegen_get_keys(Parser *, asdl_seq *); 
-asdl_seq *_PyPegen_get_values(Parser *, asdl_seq *); 
-NameDefaultPair *_PyPegen_name_default_pair(Parser *, arg_ty, expr_ty, Token *); 
-SlashWithDefault *_PyPegen_slash_with_default(Parser *, asdl_seq *, asdl_seq *); 
-StarEtc *_PyPegen_star_etc(Parser *, arg_ty, asdl_seq *, arg_ty); 
-arguments_ty _PyPegen_make_arguments(Parser *, asdl_seq *, SlashWithDefault *, 
-                            asdl_seq *, asdl_seq *, StarEtc *); 
-arguments_ty _PyPegen_empty_arguments(Parser *); 
-AugOperator *_PyPegen_augoperator(Parser*, operator_ty type); 
-stmt_ty _PyPegen_function_def_decorators(Parser *, asdl_seq *, stmt_ty); 
-stmt_ty _PyPegen_class_def_decorators(Parser *, asdl_seq *, stmt_ty); 
-KeywordOrStarred *_PyPegen_keyword_or_starred(Parser *, void *, int); 
-asdl_seq *_PyPegen_seq_extract_starred_exprs(Parser *, asdl_seq *); 
-asdl_seq *_PyPegen_seq_delete_starred_exprs(Parser *, asdl_seq *); 
-expr_ty _PyPegen_collect_call_seqs(Parser *, asdl_seq *, asdl_seq *, 
-                     int lineno, int col_offset, int end_lineno, 
-                     int end_col_offset, PyArena *arena); 
-expr_ty _PyPegen_concatenate_strings(Parser *p, asdl_seq *); 
-asdl_seq *_PyPegen_join_sequences(Parser *, asdl_seq *, asdl_seq *); 
-int _PyPegen_check_barry_as_flufl(Parser *, Token *); 
-mod_ty _PyPegen_make_module(Parser *, asdl_seq *); 
- 
-// Error reporting helpers 
-typedef enum { 
-    STAR_TARGETS, 
-    DEL_TARGETS, 
-    FOR_TARGETS 
-} TARGETS_TYPE; 
-expr_ty _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type); 
-#define RAISE_SYNTAX_ERROR_INVALID_TARGET(type, e) _RAISE_SYNTAX_ERROR_INVALID_TARGET(p, type, e) 
- 
-Py_LOCAL_INLINE(void *) 
-_RAISE_SYNTAX_ERROR_INVALID_TARGET(Parser *p, TARGETS_TYPE type, void *e) 
-{ 
-    expr_ty invalid_target = CHECK_NULL_ALLOWED(_PyPegen_get_invalid_target(e, type)); 
-    if (invalid_target != NULL) { 
-        const char *msg; 
-        if (type == STAR_TARGETS || type == FOR_TARGETS) { 
-            msg = "cannot assign to %s"; 
-        } 
-        else { 
-            msg = "cannot delete %s"; 
-        } 
-        return RAISE_SYNTAX_ERROR_KNOWN_LOCATION( 
-            invalid_target, 
-            msg, 
-            _PyPegen_get_expr_name(invalid_target) 
-        ); 
-    } 
-    return RAISE_SYNTAX_ERROR("invalid syntax"); 
-} 
- 
-void *_PyPegen_arguments_parsing_error(Parser *, expr_ty); 
-void *_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args); 
- 
- 
-// Generated function in parse.c - function definition in python.gram 
-void *_PyPegen_parse(Parser *); 
- 
-#endif 
+#ifndef PEGEN_H
+#define PEGEN_H
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <token.h>
+#include <Python-ast.h>
+#include <pyarena.h>
+
+#if 0
+#define PyPARSE_YIELD_IS_KEYWORD        0x0001
+#endif
+
+#define PyPARSE_DONT_IMPLY_DEDENT       0x0002
+
+#if 0
+#define PyPARSE_WITH_IS_KEYWORD         0x0003
+#define PyPARSE_PRINT_IS_FUNCTION       0x0004
+#define PyPARSE_UNICODE_LITERALS        0x0008
+#endif
+
+#define PyPARSE_IGNORE_COOKIE 0x0010
+#define PyPARSE_BARRY_AS_BDFL 0x0020
+#define PyPARSE_TYPE_COMMENTS 0x0040
+#define PyPARSE_ASYNC_HACKS   0x0080
+
+typedef struct _memo {
+    int type;
+    void *node;
+    int mark;
+    struct _memo *next;
+} Memo;
+
+typedef struct {
+    int type;
+    PyObject *bytes;
+    int lineno, col_offset, end_lineno, end_col_offset;
+    Memo *memo;
+} Token;
+
+typedef struct {
+    char *str;
+    int type;
+} KeywordToken;
+
+
+typedef struct {
+    struct {
+        int lineno;
+        char *comment;  // The " <tag>" in "# type: ignore <tag>"
+    } *items;
+    size_t size;
+    size_t num_items;
+} growable_comment_array;
+
+typedef struct {
+    struct tok_state *tok;
+    Token **tokens;
+    int mark;
+    int fill, size;
+    PyArena *arena;
+    KeywordToken **keywords;
+    int n_keyword_lists;
+    int start_rule;
+    int *errcode;
+    int parsing_started;
+    PyObject* normalize;
+    int starting_lineno;
+    int starting_col_offset;
+    int error_indicator;
+    int flags;
+    int feature_version;
+    growable_comment_array type_ignore_comments;
+    Token *known_err_token;
+    int level;
+    int call_invalid_rules;
+} Parser;
+
+typedef struct {
+    cmpop_ty cmpop;
+    expr_ty expr;
+} CmpopExprPair;
+
+typedef struct {
+    expr_ty key;
+    expr_ty value;
+} KeyValuePair;
+
+typedef struct {
+    arg_ty arg;
+    expr_ty value;
+} NameDefaultPair;
+
+typedef struct {
+    asdl_seq *plain_names;
+    asdl_seq *names_with_defaults; // asdl_seq* of NameDefaultsPair's
+} SlashWithDefault;
+
+typedef struct {
+    arg_ty vararg;
+    asdl_seq *kwonlyargs; // asdl_seq* of NameDefaultsPair's
+    arg_ty kwarg;
+} StarEtc;
+
+typedef struct {
+    operator_ty kind;
+} AugOperator;
+
+typedef struct {
+    void *element;
+    int is_keyword;
+} KeywordOrStarred;
+
+void _PyPegen_clear_memo_statistics(void);
+PyObject *_PyPegen_get_memo_statistics(void);
+
+int _PyPegen_insert_memo(Parser *p, int mark, int type, void *node);
+int _PyPegen_update_memo(Parser *p, int mark, int type, void *node);
+int _PyPegen_is_memoized(Parser *p, int type, void *pres);
+
+int _PyPegen_lookahead_with_name(int, expr_ty (func)(Parser *), Parser *);
+int _PyPegen_lookahead_with_string(int , expr_ty (func)(Parser *, const char*), Parser *, const char*);
+int _PyPegen_lookahead_with_int(int, Token *(func)(Parser *, int), Parser *, int);
+int _PyPegen_lookahead(int, void *(func)(Parser *), Parser *);
+
+Token *_PyPegen_expect_token(Parser *p, int type);
+expr_ty _PyPegen_expect_soft_keyword(Parser *p, const char *keyword);
+Token *_PyPegen_get_last_nonnwhitespace_token(Parser *);
+int _PyPegen_fill_token(Parser *p);
+expr_ty _PyPegen_name_token(Parser *p);
+expr_ty _PyPegen_number_token(Parser *p);
+void *_PyPegen_string_token(Parser *p);
+const char *_PyPegen_get_expr_name(expr_ty);
+void *_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...);
+void *_PyPegen_raise_error_known_location(Parser *p, PyObject *errtype,
+                                          Py_ssize_t lineno, Py_ssize_t col_offset,
+                                          const char *errmsg, va_list va);
+void *_PyPegen_dummy_name(Parser *p, ...);
+
+Py_LOCAL_INLINE(void *)
+RAISE_ERROR_KNOWN_LOCATION(Parser *p, PyObject *errtype,
+                           Py_ssize_t lineno, Py_ssize_t col_offset,
+                           const char *errmsg, ...)
+{
+    va_list va;
+    va_start(va, errmsg);
+    _PyPegen_raise_error_known_location(p, errtype, lineno, col_offset + 1,
+                                        errmsg, va);
+    va_end(va);
+    return NULL;
+}
+
+
+#define UNUSED(expr) do { (void)(expr); } while (0)
+#define EXTRA_EXPR(head, tail) head->lineno, head->col_offset, tail->end_lineno, tail->end_col_offset, p->arena
+#define EXTRA _start_lineno, _start_col_offset, _end_lineno, _end_col_offset, p->arena
+#define RAISE_SYNTAX_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_SyntaxError, msg, ##__VA_ARGS__)
+#define RAISE_INDENTATION_ERROR(msg, ...) _PyPegen_raise_error(p, PyExc_IndentationError, msg, ##__VA_ARGS__)
+#define RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, msg, ...) \
+    RAISE_ERROR_KNOWN_LOCATION(p, PyExc_SyntaxError, (a)->lineno, (a)->col_offset, msg, ##__VA_ARGS__)
+
+Py_LOCAL_INLINE(void *)
+CHECK_CALL(Parser *p, void *result)
+{
+    if (result == NULL) {
+        assert(PyErr_Occurred());
+        p->error_indicator = 1;
+    }
+    return result;
+}
+
+/* This is needed for helper functions that are allowed to
+   return NULL without an error. Example: _PyPegen_seq_extract_starred_exprs */
+Py_LOCAL_INLINE(void *)
+CHECK_CALL_NULL_ALLOWED(Parser *p, void *result)
+{
+    if (result == NULL && PyErr_Occurred()) {
+        p->error_indicator = 1;
+    }
+    return result;
+}
+
+#define CHECK(result) CHECK_CALL(p, result)
+#define CHECK_NULL_ALLOWED(result) CHECK_CALL_NULL_ALLOWED(p, result)
+
+PyObject *_PyPegen_new_type_comment(Parser *, char *);
+
+Py_LOCAL_INLINE(PyObject *)
+NEW_TYPE_COMMENT(Parser *p, Token *tc)
+{
+    if (tc == NULL) {
+        return NULL;
+    }
+    char *bytes = PyBytes_AsString(tc->bytes);
+    if (bytes == NULL) {
+        goto error;
+    }
+    PyObject *tco = _PyPegen_new_type_comment(p, bytes);
+    if (tco == NULL) {
+        goto error;
+    }
+    return tco;
+ error:
+    p->error_indicator = 1;  // Inline CHECK_CALL
+    return NULL;
+}
+
+Py_LOCAL_INLINE(void *)
+INVALID_VERSION_CHECK(Parser *p, int version, char *msg, void *node)
+{
+    if (node == NULL) {
+        p->error_indicator = 1;  // Inline CHECK_CALL
+        return NULL;
+    }
+    if (p->feature_version < version) {
+        p->error_indicator = 1;
+        return RAISE_SYNTAX_ERROR("%s only supported in Python 3.%i and greater",
+                                  msg, version);
+    }
+    return node;
+}
+
+#define CHECK_VERSION(version, msg, node) INVALID_VERSION_CHECK(p, version, msg, node)
+
+arg_ty _PyPegen_add_type_comment_to_arg(Parser *, arg_ty, Token *);
+PyObject *_PyPegen_new_identifier(Parser *, char *);
+Parser *_PyPegen_Parser_New(struct tok_state *, int, int, int, int *, PyArena *);
+void _PyPegen_Parser_Free(Parser *);
+mod_ty _PyPegen_run_parser_from_file_pointer(FILE *, int, PyObject *, const char *,
+                                    const char *, const char *, PyCompilerFlags *, int *, PyArena *);
+void *_PyPegen_run_parser(Parser *);
+mod_ty _PyPegen_run_parser_from_file(const char *, int, PyObject *, PyCompilerFlags *, PyArena *);
+mod_ty _PyPegen_run_parser_from_string(const char *, int, PyObject *, PyCompilerFlags *, PyArena *);
+void *_PyPegen_interactive_exit(Parser *);
+asdl_seq *_PyPegen_singleton_seq(Parser *, void *);
+asdl_seq *_PyPegen_seq_insert_in_front(Parser *, void *, asdl_seq *);
+asdl_seq *_PyPegen_seq_append_to_end(Parser *, asdl_seq *, void *);
+asdl_seq *_PyPegen_seq_flatten(Parser *, asdl_seq *);
+expr_ty _PyPegen_join_names_with_dot(Parser *, expr_ty, expr_ty);
+int _PyPegen_seq_count_dots(asdl_seq *);
+alias_ty _PyPegen_alias_for_star(Parser *);
+asdl_seq *_PyPegen_map_names_to_ids(Parser *, asdl_seq *);
+CmpopExprPair *_PyPegen_cmpop_expr_pair(Parser *, cmpop_ty, expr_ty);
+asdl_int_seq *_PyPegen_get_cmpops(Parser *p, asdl_seq *);
+asdl_seq *_PyPegen_get_exprs(Parser *, asdl_seq *);
+expr_ty _PyPegen_set_expr_context(Parser *, expr_ty, expr_context_ty);
+KeyValuePair *_PyPegen_key_value_pair(Parser *, expr_ty, expr_ty);
+asdl_seq *_PyPegen_get_keys(Parser *, asdl_seq *);
+asdl_seq *_PyPegen_get_values(Parser *, asdl_seq *);
+NameDefaultPair *_PyPegen_name_default_pair(Parser *, arg_ty, expr_ty, Token *);
+SlashWithDefault *_PyPegen_slash_with_default(Parser *, asdl_seq *, asdl_seq *);
+StarEtc *_PyPegen_star_etc(Parser *, arg_ty, asdl_seq *, arg_ty);
+arguments_ty _PyPegen_make_arguments(Parser *, asdl_seq *, SlashWithDefault *,
+                            asdl_seq *, asdl_seq *, StarEtc *);
+arguments_ty _PyPegen_empty_arguments(Parser *);
+AugOperator *_PyPegen_augoperator(Parser*, operator_ty type);
+stmt_ty _PyPegen_function_def_decorators(Parser *, asdl_seq *, stmt_ty);
+stmt_ty _PyPegen_class_def_decorators(Parser *, asdl_seq *, stmt_ty);
+KeywordOrStarred *_PyPegen_keyword_or_starred(Parser *, void *, int);
+asdl_seq *_PyPegen_seq_extract_starred_exprs(Parser *, asdl_seq *);
+asdl_seq *_PyPegen_seq_delete_starred_exprs(Parser *, asdl_seq *);
+expr_ty _PyPegen_collect_call_seqs(Parser *, asdl_seq *, asdl_seq *,
+                     int lineno, int col_offset, int end_lineno,
+                     int end_col_offset, PyArena *arena);
+expr_ty _PyPegen_concatenate_strings(Parser *p, asdl_seq *);
+asdl_seq *_PyPegen_join_sequences(Parser *, asdl_seq *, asdl_seq *);
+int _PyPegen_check_barry_as_flufl(Parser *, Token *);
+mod_ty _PyPegen_make_module(Parser *, asdl_seq *);
+
+// Error reporting helpers
+typedef enum {
+    STAR_TARGETS,
+    DEL_TARGETS,
+    FOR_TARGETS
+} TARGETS_TYPE;
+expr_ty _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type);
+#define RAISE_SYNTAX_ERROR_INVALID_TARGET(type, e) _RAISE_SYNTAX_ERROR_INVALID_TARGET(p, type, e)
+
+Py_LOCAL_INLINE(void *)
+_RAISE_SYNTAX_ERROR_INVALID_TARGET(Parser *p, TARGETS_TYPE type, void *e)
+{
+    expr_ty invalid_target = CHECK_NULL_ALLOWED(_PyPegen_get_invalid_target(e, type));
+    if (invalid_target != NULL) {
+        const char *msg;
+        if (type == STAR_TARGETS || type == FOR_TARGETS) {
+            msg = "cannot assign to %s";
+        }
+        else {
+            msg = "cannot delete %s";
+        }
+        return RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
+            invalid_target,
+            msg,
+            _PyPegen_get_expr_name(invalid_target)
+        );
+    }
+    return RAISE_SYNTAX_ERROR("invalid syntax");
+}
+
+void *_PyPegen_arguments_parsing_error(Parser *, expr_ty);
+void *_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args);
+
+
+// Generated function in parse.c - function definition in python.gram
+void *_PyPegen_parse(Parser *);
+
+#endif
diff --git a/contrib/tools/python3/src/Parser/token.c b/contrib/tools/python3/src/Parser/token.c
index a27c0645fa..a489668900 100644
--- a/contrib/tools/python3/src/Parser/token.c
+++ b/contrib/tools/python3/src/Parser/token.c
@@ -1,243 +1,243 @@
-/* Auto-generated by Tools/scripts/generate_token.py */ 
- 
-#include "Python.h" 
-#include "token.h" 
- 
-/* Token names */ 
- 
-const char * const _PyParser_TokenNames[] = { 
-    "ENDMARKER", 
-    "NAME", 
-    "NUMBER", 
-    "STRING", 
-    "NEWLINE", 
-    "INDENT", 
-    "DEDENT", 
-    "LPAR", 
-    "RPAR", 
-    "LSQB", 
-    "RSQB", 
-    "COLON", 
-    "COMMA", 
-    "SEMI", 
-    "PLUS", 
-    "MINUS", 
-    "STAR", 
-    "SLASH", 
-    "VBAR", 
-    "AMPER", 
-    "LESS", 
-    "GREATER", 
-    "EQUAL", 
-    "DOT", 
-    "PERCENT", 
-    "LBRACE", 
-    "RBRACE", 
-    "EQEQUAL", 
-    "NOTEQUAL", 
-    "LESSEQUAL", 
-    "GREATEREQUAL", 
-    "TILDE", 
-    "CIRCUMFLEX", 
-    "LEFTSHIFT", 
-    "RIGHTSHIFT", 
-    "DOUBLESTAR", 
-    "PLUSEQUAL", 
-    "MINEQUAL", 
-    "STAREQUAL", 
-    "SLASHEQUAL", 
-    "PERCENTEQUAL", 
-    "AMPEREQUAL", 
-    "VBAREQUAL", 
-    "CIRCUMFLEXEQUAL", 
-    "LEFTSHIFTEQUAL", 
-    "RIGHTSHIFTEQUAL", 
-    "DOUBLESTAREQUAL", 
-    "DOUBLESLASH", 
-    "DOUBLESLASHEQUAL", 
-    "AT", 
-    "ATEQUAL", 
-    "RARROW", 
-    "ELLIPSIS", 
-    "COLONEQUAL", 
-    "OP", 
-    "AWAIT", 
-    "ASYNC", 
-    "TYPE_IGNORE", 
-    "TYPE_COMMENT", 
-    "<ERRORTOKEN>", 
-    "<COMMENT>", 
-    "<NL>", 
-    "<ENCODING>", 
-    "<N_TOKENS>", 
-}; 
- 
-/* Return the token corresponding to a single character */ 
- 
-int 
-PyToken_OneChar(int c1) 
-{ 
-    switch (c1) { 
-    case '%': return PERCENT; 
-    case '&': return AMPER; 
-    case '(': return LPAR; 
-    case ')': return RPAR; 
-    case '*': return STAR; 
-    case '+': return PLUS; 
-    case ',': return COMMA; 
-    case '-': return MINUS; 
-    case '.': return DOT; 
-    case '/': return SLASH; 
-    case ':': return COLON; 
-    case ';': return SEMI; 
-    case '<': return LESS; 
-    case '=': return EQUAL; 
-    case '>': return GREATER; 
-    case '@': return AT; 
-    case '[': return LSQB; 
-    case ']': return RSQB; 
-    case '^': return CIRCUMFLEX; 
-    case '{': return LBRACE; 
-    case '|': return VBAR; 
-    case '}': return RBRACE; 
-    case '~': return TILDE; 
-    } 
-    return OP; 
-} 
- 
-int 
-PyToken_TwoChars(int c1, int c2) 
-{ 
-    switch (c1) { 
-    case '!': 
-        switch (c2) { 
-        case '=': return NOTEQUAL; 
-        } 
-        break; 
-    case '%': 
-        switch (c2) { 
-        case '=': return PERCENTEQUAL; 
-        } 
-        break; 
-    case '&': 
-        switch (c2) { 
-        case '=': return AMPEREQUAL; 
-        } 
-        break; 
-    case '*': 
-        switch (c2) { 
-        case '*': return DOUBLESTAR; 
-        case '=': return STAREQUAL; 
-        } 
-        break; 
-    case '+': 
-        switch (c2) { 
-        case '=': return PLUSEQUAL; 
-        } 
-        break; 
-    case '-': 
-        switch (c2) { 
-        case '=': return MINEQUAL; 
-        case '>': return RARROW; 
-        } 
-        break; 
-    case '/': 
-        switch (c2) { 
-        case '/': return DOUBLESLASH; 
-        case '=': return SLASHEQUAL; 
-        } 
-        break; 
-    case ':': 
-        switch (c2) { 
-        case '=': return COLONEQUAL; 
-        } 
-        break; 
-    case '<': 
-        switch (c2) { 
-        case '<': return LEFTSHIFT; 
-        case '=': return LESSEQUAL; 
-        case '>': return NOTEQUAL; 
-        } 
-        break; 
-    case '=': 
-        switch (c2) { 
-        case '=': return EQEQUAL; 
-        } 
-        break; 
-    case '>': 
-        switch (c2) { 
-        case '=': return GREATEREQUAL; 
-        case '>': return RIGHTSHIFT; 
-        } 
-        break; 
-    case '@': 
-        switch (c2) { 
-        case '=': return ATEQUAL; 
-        } 
-        break; 
-    case '^': 
-        switch (c2) { 
-        case '=': return CIRCUMFLEXEQUAL; 
-        } 
-        break; 
-    case '|': 
-        switch (c2) { 
-        case '=': return VBAREQUAL; 
-        } 
-        break; 
-    } 
-    return OP; 
-} 
- 
-int 
-PyToken_ThreeChars(int c1, int c2, int c3) 
-{ 
-    switch (c1) { 
-    case '*': 
-        switch (c2) { 
-        case '*': 
-            switch (c3) { 
-            case '=': return DOUBLESTAREQUAL; 
-            } 
-            break; 
-        } 
-        break; 
-    case '.': 
-        switch (c2) { 
-        case '.': 
-            switch (c3) { 
-            case '.': return ELLIPSIS; 
-            } 
-            break; 
-        } 
-        break; 
-    case '/': 
-        switch (c2) { 
-        case '/': 
-            switch (c3) { 
-            case '=': return DOUBLESLASHEQUAL; 
-            } 
-            break; 
-        } 
-        break; 
-    case '<': 
-        switch (c2) { 
-        case '<': 
-            switch (c3) { 
-            case '=': return LEFTSHIFTEQUAL; 
-            } 
-            break; 
-        } 
-        break; 
-    case '>': 
-        switch (c2) { 
-        case '>': 
-            switch (c3) { 
-            case '=': return RIGHTSHIFTEQUAL; 
-            } 
-            break; 
-        } 
-        break; 
-    } 
-    return OP; 
-} 
+/* Auto-generated by Tools/scripts/generate_token.py */
+
+#include "Python.h"
+#include "token.h"
+
+/* Token names */
+
+const char * const _PyParser_TokenNames[] = {
+    "ENDMARKER",
+    "NAME",
+    "NUMBER",
+    "STRING",
+    "NEWLINE",
+    "INDENT",
+    "DEDENT",
+    "LPAR",
+    "RPAR",
+    "LSQB",
+    "RSQB",
+    "COLON",
+    "COMMA",
+    "SEMI",
+    "PLUS",
+    "MINUS",
+    "STAR",
+    "SLASH",
+    "VBAR",
+    "AMPER",
+    "LESS",
+    "GREATER",
+    "EQUAL",
+    "DOT",
+    "PERCENT",
+    "LBRACE",
+    "RBRACE",
+    "EQEQUAL",
+    "NOTEQUAL",
+    "LESSEQUAL",
+    "GREATEREQUAL",
+    "TILDE",
+    "CIRCUMFLEX",
+    "LEFTSHIFT",
+    "RIGHTSHIFT",
+    "DOUBLESTAR",
+    "PLUSEQUAL",
+    "MINEQUAL",
+    "STAREQUAL",
+    "SLASHEQUAL",
+    "PERCENTEQUAL",
+    "AMPEREQUAL",
+    "VBAREQUAL",
+    "CIRCUMFLEXEQUAL",
+    "LEFTSHIFTEQUAL",
+    "RIGHTSHIFTEQUAL",
+    "DOUBLESTAREQUAL",
+    "DOUBLESLASH",
+    "DOUBLESLASHEQUAL",
+    "AT",
+    "ATEQUAL",
+    "RARROW",
+    "ELLIPSIS",
+    "COLONEQUAL",
+    "OP",
+    "AWAIT",
+    "ASYNC",
+    "TYPE_IGNORE",
+    "TYPE_COMMENT",
+    "<ERRORTOKEN>",
+    "<COMMENT>",
+    "<NL>",
+    "<ENCODING>",
+    "<N_TOKENS>",
+};
+
+/* Return the token corresponding to a single character */
+
+int
+PyToken_OneChar(int c1)
+{
+    switch (c1) {
+    case '%': return PERCENT;
+    case '&': return AMPER;
+    case '(': return LPAR;
+    case ')': return RPAR;
+    case '*': return STAR;
+    case '+': return PLUS;
+    case ',': return COMMA;
+    case '-': return MINUS;
+    case '.': return DOT;
+    case '/': return SLASH;
+    case ':': return COLON;
+    case ';': return SEMI;
+    case '<': return LESS;
+    case '=': return EQUAL;
+    case '>': return GREATER;
+    case '@': return AT;
+    case '[': return LSQB;
+    case ']': return RSQB;
+    case '^': return CIRCUMFLEX;
+    case '{': return LBRACE;
+    case '|': return VBAR;
+    case '}': return RBRACE;
+    case '~': return TILDE;
+    }
+    return OP;
+}
+
+int
+PyToken_TwoChars(int c1, int c2)
+{
+    switch (c1) {
+    case '!':
+        switch (c2) {
+        case '=': return NOTEQUAL;
+        }
+        break;
+    case '%':
+        switch (c2) {
+        case '=': return PERCENTEQUAL;
+        }
+        break;
+    case '&':
+        switch (c2) {
+        case '=': return AMPEREQUAL;
+        }
+        break;
+    case '*':
+        switch (c2) {
+        case '*': return DOUBLESTAR;
+        case '=': return STAREQUAL;
+        }
+        break;
+    case '+':
+        switch (c2) {
+        case '=': return PLUSEQUAL;
+        }
+        break;
+    case '-':
+        switch (c2) {
+        case '=': return MINEQUAL;
+        case '>': return RARROW;
+        }
+        break;
+    case '/':
+        switch (c2) {
+        case '/': return DOUBLESLASH;
+        case '=': return SLASHEQUAL;
+        }
+        break;
+    case ':':
+        switch (c2) {
+        case '=': return COLONEQUAL;
+        }
+        break;
+    case '<':
+        switch (c2) {
+        case '<': return LEFTSHIFT;
+        case '=': return LESSEQUAL;
+        case '>': return NOTEQUAL;
+        }
+        break;
+    case '=':
+        switch (c2) {
+        case '=': return EQEQUAL;
+        }
+        break;
+    case '>':
+        switch (c2) {
+        case '=': return GREATEREQUAL;
+        case '>': return RIGHTSHIFT;
+        }
+        break;
+    case '@':
+        switch (c2) {
+        case '=': return ATEQUAL;
+        }
+        break;
+    case '^':
+        switch (c2) {
+        case '=': return CIRCUMFLEXEQUAL;
+        }
+        break;
+    case '|':
+        switch (c2) {
+        case '=': return VBAREQUAL;
+        }
+        break;
+    }
+    return OP;
+}
+
+int
+PyToken_ThreeChars(int c1, int c2, int c3)
+{
+    switch (c1) {
+    case '*':
+        switch (c2) {
+        case '*':
+            switch (c3) {
+            case '=': return DOUBLESTAREQUAL;
+            }
+            break;
+        }
+        break;
+    case '.':
+        switch (c2) {
+        case '.':
+            switch (c3) {
+            case '.': return ELLIPSIS;
+            }
+            break;
+        }
+        break;
+    case '/':
+        switch (c2) {
+        case '/':
+            switch (c3) {
+            case '=': return DOUBLESLASHEQUAL;
+            }
+            break;
+        }
+        break;
+    case '<':
+        switch (c2) {
+        case '<':
+            switch (c3) {
+            case '=': return LEFTSHIFTEQUAL;
+            }
+            break;
+        }
+        break;
+    case '>':
+        switch (c2) {
+        case '>':
+            switch (c3) {
+            case '=': return RIGHTSHIFTEQUAL;
+            }
+            break;
+        }
+        break;
+    }
+    return OP;
+}
diff --git a/contrib/tools/python3/src/Parser/tokenizer.c b/contrib/tools/python3/src/Parser/tokenizer.c
index 4bda4986f5..41bfdb853c 100644
--- a/contrib/tools/python3/src/Parser/tokenizer.c
+++ b/contrib/tools/python3/src/Parser/tokenizer.c
@@ -1,7 +1,7 @@
 
 /* Tokenizer implementation */
 
-#define PY_SSIZE_T_CLEAN 
+#define PY_SSIZE_T_CLEAN
 #include "Python.h"
 
 #include <ctype.h>
@@ -42,9 +42,9 @@ static int tok_nextc(struct tok_state *tok);
 static void tok_backup(struct tok_state *tok, int c);
 
 
-/* Spaces in this constant are treated as "zero or more spaces or tabs" when 
-   tokenizing. */ 
-static const char* type_comment_prefix = "# type: "; 
+/* Spaces in this constant are treated as "zero or more spaces or tabs" when
+   tokenizing. */
+static const char* type_comment_prefix = "# type: ";
 
 /* Create and initialize a new tok_state structure */
 
@@ -55,9 +55,9 @@ tok_new(void)
                                             sizeof(struct tok_state));
     if (tok == NULL)
         return NULL;
-    tok->buf = tok->cur = tok->inp = NULL; 
-    tok->start = NULL; 
-    tok->end = NULL; 
+    tok->buf = tok->cur = tok->inp = NULL;
+    tok->start = NULL;
+    tok->end = NULL;
     tok->done = E_OK;
     tok->fp = NULL;
     tok->input = NULL;
@@ -80,13 +80,13 @@ tok_new(void)
     tok->filename = NULL;
     tok->decoding_readline = NULL;
     tok->decoding_buffer = NULL;
-    tok->type_comments = 0; 
+    tok->type_comments = 0;
+
+    tok->async_hacks = 0;
+    tok->async_def = 0;
+    tok->async_def_indent = 0;
+    tok->async_def_nl = 0;
 
-    tok->async_hacks = 0; 
-    tok->async_def = 0; 
-    tok->async_def_indent = 0; 
-    tok->async_def_nl = 0; 
- 
     return tok;
 }
 
@@ -109,9 +109,9 @@ error_ret(struct tok_state *tok) /* XXX */
     tok->decoding_erred = 1;
     if (tok->fp != NULL && tok->buf != NULL) /* see PyTokenizer_Free */
         PyMem_FREE(tok->buf);
-    tok->buf = tok->cur = tok->inp = NULL; 
-    tok->start = NULL; 
-    tok->end = NULL; 
+    tok->buf = tok->cur = tok->inp = NULL;
+    tok->start = NULL;
+    tok->end = NULL;
     tok->done = E_DECODE;
     return NULL;                /* as if it were EOF */
 }
@@ -548,7 +548,7 @@ decoding_fgets(char *s, int size, struct tok_state *tok)
                 "Non-UTF-8 code starting with '\\x%.2x' "
                 "in file %U on line %i, "
                 "but no encoding declared; "
-                "see https://python.org/dev/peps/pep-0263/ for details", 
+                "see https://python.org/dev/peps/pep-0263/ for details",
                 badchar, tok->filename, tok->lineno + 1);
         return error_ret(tok);
     }
@@ -649,14 +649,14 @@ translate_newlines(const char *s, int exec_input, struct tok_state *tok) {
     }
     *current = '\0';
     final_length = current - buf + 1;
-    if (final_length < needed_length && final_length) { 
+    if (final_length < needed_length && final_length) {
         /* should never fail */
-        char* result = PyMem_REALLOC(buf, final_length); 
-        if (result == NULL) { 
-            PyMem_FREE(buf); 
-        } 
-        buf = result; 
-    } 
+        char* result = PyMem_REALLOC(buf, final_length);
+        if (result == NULL) {
+            PyMem_FREE(buf);
+        }
+        buf = result;
+    }
     return buf;
 }
 
@@ -664,11 +664,11 @@ translate_newlines(const char *s, int exec_input, struct tok_state *tok) {
    Look for encoding declarations inside STR, and record them
    inside TOK.  */
 
-static char * 
+static char *
 decode_str(const char *input, int single, struct tok_state *tok)
 {
     PyObject* utf8 = NULL;
-    char *str; 
+    char *str;
     const char *s;
     const char *newl[2] = {NULL, NULL};
     int lineno = 0;
@@ -726,18 +726,18 @@ struct tok_state *
 PyTokenizer_FromString(const char *str, int exec_input)
 {
     struct tok_state *tok = tok_new();
-    char *decoded; 
- 
+    char *decoded;
+
     if (tok == NULL)
         return NULL;
-    decoded = decode_str(str, exec_input, tok); 
-    if (decoded == NULL) { 
+    decoded = decode_str(str, exec_input, tok);
+    if (decoded == NULL) {
         PyTokenizer_Free(tok);
         return NULL;
     }
 
-    tok->buf = tok->cur = tok->inp = decoded; 
-    tok->end = decoded; 
+    tok->buf = tok->cur = tok->inp = decoded;
+    tok->end = decoded;
     return tok;
 }
 
@@ -745,18 +745,18 @@ struct tok_state *
 PyTokenizer_FromUTF8(const char *str, int exec_input)
 {
     struct tok_state *tok = tok_new();
-    char *translated; 
+    char *translated;
     if (tok == NULL)
         return NULL;
-    tok->input = translated = translate_newlines(str, exec_input, tok); 
-    if (translated == NULL) { 
+    tok->input = translated = translate_newlines(str, exec_input, tok);
+    if (translated == NULL) {
         PyTokenizer_Free(tok);
         return NULL;
     }
     tok->decoding_state = STATE_RAW;
     tok->read_coding_spec = 1;
     tok->enc = NULL;
-    tok->str = translated; 
+    tok->str = translated;
     tok->encoding = (char *)PyMem_MALLOC(6);
     if (!tok->encoding) {
         PyTokenizer_Free(tok);
@@ -764,8 +764,8 @@ PyTokenizer_FromUTF8(const char *str, int exec_input)
     }
     strcpy(tok->encoding, "utf-8");
 
-    tok->buf = tok->cur = tok->inp = translated; 
-    tok->end = translated; 
+    tok->buf = tok->cur = tok->inp = translated;
+    tok->end = translated;
     return tok;
 }
 
@@ -815,7 +815,7 @@ PyTokenizer_Free(struct tok_state *tok)
     if (tok->fp != NULL && tok->buf != NULL)
         PyMem_FREE(tok->buf);
     if (tok->input)
-        PyMem_FREE(tok->input); 
+        PyMem_FREE(tok->input);
     PyMem_FREE(tok);
 }
 
@@ -890,7 +890,7 @@ tok_nextc(struct tok_state *tok)
                 size_t start = tok->start - tok->buf;
                 size_t oldlen = tok->cur - tok->buf;
                 size_t newlen = oldlen + strlen(newtok);
-                Py_ssize_t cur_multi_line_start = tok->multi_line_start - tok->buf; 
+                Py_ssize_t cur_multi_line_start = tok->multi_line_start - tok->buf;
                 char *buf = tok->buf;
                 buf = (char *)PyMem_REALLOC(buf, newlen+1);
                 tok->lineno++;
@@ -903,7 +903,7 @@ tok_nextc(struct tok_state *tok)
                 }
                 tok->buf = buf;
                 tok->cur = tok->buf + oldlen;
-                tok->multi_line_start = tok->buf + cur_multi_line_start; 
+                tok->multi_line_start = tok->buf + cur_multi_line_start;
                 tok->line_start = tok->cur;
                 strcpy(tok->buf + oldlen, newtok);
                 PyMem_FREE(newtok);
@@ -962,7 +962,7 @@ tok_nextc(struct tok_state *tok)
             while (!done) {
                 Py_ssize_t curstart = tok->start == NULL ? -1 :
                           tok->start - tok->buf;
-                Py_ssize_t cur_multi_line_start = tok->multi_line_start - tok->buf; 
+                Py_ssize_t cur_multi_line_start = tok->multi_line_start - tok->buf;
                 Py_ssize_t curvalid = tok->inp - tok->buf;
                 Py_ssize_t newsize = curvalid + BUFSIZ;
                 char *newbuf = tok->buf;
@@ -975,7 +975,7 @@ tok_nextc(struct tok_state *tok)
                 }
                 tok->buf = newbuf;
                 tok->cur = tok->buf + cur;
-                tok->multi_line_start = tok->buf + cur_multi_line_start; 
+                tok->multi_line_start = tok->buf + cur_multi_line_start;
                 tok->line_start = tok->cur;
                 tok->inp = tok->buf + curvalid;
                 tok->end = tok->buf + newsize;
@@ -991,8 +991,8 @@ tok_nextc(struct tok_state *tok)
                         return EOF;
                     /* Last line does not end in \n,
                        fake one */
-                    if (tok->inp[-1] != '\n') 
-                        strcpy(tok->inp, "\n"); 
+                    if (tok->inp[-1] != '\n')
+                        strcpy(tok->inp, "\n");
                 }
                 tok->inp = strchr(tok->inp, '\0');
                 done = tok->inp[-1] == '\n';
@@ -1027,59 +1027,59 @@ static void
 tok_backup(struct tok_state *tok, int c)
 {
     if (c != EOF) {
-        if (--tok->cur < tok->buf) { 
-            Py_FatalError("tokenizer beginning of buffer"); 
-        } 
-        if (*tok->cur != c) { 
+        if (--tok->cur < tok->buf) {
+            Py_FatalError("tokenizer beginning of buffer");
+        }
+        if (*tok->cur != c) {
             *tok->cur = c;
-        } 
+        }
     }
 }
 
 
-static int 
-syntaxerror(struct tok_state *tok, const char *format, ...) 
+static int
+syntaxerror(struct tok_state *tok, const char *format, ...)
 {
-    PyObject *errmsg, *errtext, *args; 
-    va_list vargs; 
-#ifdef HAVE_STDARG_PROTOTYPES 
-    va_start(vargs, format); 
-#else 
-    va_start(vargs); 
-#endif 
-    errmsg = PyUnicode_FromFormatV(format, vargs); 
-    va_end(vargs); 
-    if (!errmsg) { 
-        goto error; 
-    }
-
-    errtext = PyUnicode_DecodeUTF8(tok->line_start, tok->cur - tok->line_start, 
-                                   "replace"); 
-    if (!errtext) { 
-        goto error; 
-    } 
-    int offset = (int)PyUnicode_GET_LENGTH(errtext); 
-    Py_ssize_t line_len = strcspn(tok->line_start, "\n"); 
-    if (line_len != tok->cur - tok->line_start) { 
-        Py_DECREF(errtext); 
-        errtext = PyUnicode_DecodeUTF8(tok->line_start, line_len, 
-                                       "replace"); 
-    } 
-    if (!errtext) { 
-        goto error; 
-    } 
-
-    args = Py_BuildValue("(O(OiiN))", errmsg, 
-                         tok->filename, tok->lineno, offset, errtext); 
-    if (args) { 
-        PyErr_SetObject(PyExc_SyntaxError, args); 
-        Py_DECREF(args); 
-    }
-
-error: 
-    Py_XDECREF(errmsg); 
-    tok->done = E_ERROR; 
-    return ERRORTOKEN; 
+    PyObject *errmsg, *errtext, *args;
+    va_list vargs;
+#ifdef HAVE_STDARG_PROTOTYPES
+    va_start(vargs, format);
+#else
+    va_start(vargs);
+#endif
+    errmsg = PyUnicode_FromFormatV(format, vargs);
+    va_end(vargs);
+    if (!errmsg) {
+        goto error;
+    }
+
+    errtext = PyUnicode_DecodeUTF8(tok->line_start, tok->cur - tok->line_start,
+                                   "replace");
+    if (!errtext) {
+        goto error;
+    }
+    int offset = (int)PyUnicode_GET_LENGTH(errtext);
+    Py_ssize_t line_len = strcspn(tok->line_start, "\n");
+    if (line_len != tok->cur - tok->line_start) {
+        Py_DECREF(errtext);
+        errtext = PyUnicode_DecodeUTF8(tok->line_start, line_len,
+                                       "replace");
+    }
+    if (!errtext) {
+        goto error;
+    }
+
+    args = Py_BuildValue("(O(OiiN))", errmsg,
+                         tok->filename, tok->lineno, offset, errtext);
+    if (args) {
+        PyErr_SetObject(PyExc_SyntaxError, args);
+        Py_DECREF(args);
+    }
+
+error:
+    Py_XDECREF(errmsg);
+    tok->done = E_ERROR;
+    return ERRORTOKEN;
 }
 
 static int
@@ -1100,50 +1100,50 @@ verify_identifier(struct tok_state *tok)
     if (tok->decoding_erred)
         return 0;
     s = PyUnicode_DecodeUTF8(tok->start, tok->cur - tok->start, NULL);
-    if (s == NULL) { 
+    if (s == NULL) {
         if (PyErr_ExceptionMatches(PyExc_UnicodeDecodeError)) {
-            tok->done = E_DECODE; 
-        } 
-        else { 
+            tok->done = E_DECODE;
+        }
+        else {
             tok->done = E_ERROR;
         }
         return 0;
     }
-    Py_ssize_t invalid = _PyUnicode_ScanIdentifier(s); 
-    if (invalid < 0) { 
-        Py_DECREF(s); 
-        tok->done = E_ERROR; 
-        return 0; 
-    } 
-    assert(PyUnicode_GET_LENGTH(s) > 0); 
-    if (invalid < PyUnicode_GET_LENGTH(s)) { 
-        Py_UCS4 ch = PyUnicode_READ_CHAR(s, invalid); 
-        if (invalid + 1 < PyUnicode_GET_LENGTH(s)) { 
-            /* Determine the offset in UTF-8 encoded input */ 
-            Py_SETREF(s, PyUnicode_Substring(s, 0, invalid + 1)); 
-            if (s != NULL) { 
-                Py_SETREF(s, PyUnicode_AsUTF8String(s)); 
-            } 
-            if (s == NULL) { 
-                tok->done = E_ERROR; 
-                return 0; 
-            } 
-            tok->cur = (char *)tok->start + PyBytes_GET_SIZE(s); 
-        } 
-        Py_DECREF(s); 
-        // PyUnicode_FromFormatV() does not support %X 
-        char hex[9]; 
-        (void)PyOS_snprintf(hex, sizeof(hex), "%04X", ch); 
-        if (Py_UNICODE_ISPRINTABLE(ch)) { 
-            syntaxerror(tok, "invalid character '%c' (U+%s)", ch, hex); 
-        } 
-        else { 
-            syntaxerror(tok, "invalid non-printable character U+%s", hex); 
-        } 
-        return 0; 
-    } 
+    Py_ssize_t invalid = _PyUnicode_ScanIdentifier(s);
+    if (invalid < 0) {
+        Py_DECREF(s);
+        tok->done = E_ERROR;
+        return 0;
+    }
+    assert(PyUnicode_GET_LENGTH(s) > 0);
+    if (invalid < PyUnicode_GET_LENGTH(s)) {
+        Py_UCS4 ch = PyUnicode_READ_CHAR(s, invalid);
+        if (invalid + 1 < PyUnicode_GET_LENGTH(s)) {
+            /* Determine the offset in UTF-8 encoded input */
+            Py_SETREF(s, PyUnicode_Substring(s, 0, invalid + 1));
+            if (s != NULL) {
+                Py_SETREF(s, PyUnicode_AsUTF8String(s));
+            }
+            if (s == NULL) {
+                tok->done = E_ERROR;
+                return 0;
+            }
+            tok->cur = (char *)tok->start + PyBytes_GET_SIZE(s);
+        }
+        Py_DECREF(s);
+        // PyUnicode_FromFormatV() does not support %X
+        char hex[9];
+        (void)PyOS_snprintf(hex, sizeof(hex), "%04X", ch);
+        if (Py_UNICODE_ISPRINTABLE(ch)) {
+            syntaxerror(tok, "invalid character '%c' (U+%s)", ch, hex);
+        }
+        else {
+            syntaxerror(tok, "invalid non-printable character U+%s", hex);
+        }
+        return 0;
+    }
     Py_DECREF(s);
-    return 1; 
+    return 1;
 }
 
 static int
@@ -1161,7 +1161,7 @@ tok_decimal_tail(struct tok_state *tok)
         c = tok_nextc(tok);
         if (!isdigit(c)) {
             tok_backup(tok, c);
-            syntaxerror(tok, "invalid decimal literal"); 
+            syntaxerror(tok, "invalid decimal literal");
             return 0;
         }
     }
@@ -1171,7 +1171,7 @@ tok_decimal_tail(struct tok_state *tok)
 /* Get next token, after space stripping etc. */
 
 static int
-tok_get(struct tok_state *tok, const char **p_start, const char **p_end) 
+tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
 {
     int c;
     int blankline, nonascii;
@@ -1203,9 +1203,9 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
             }
         }
         tok_backup(tok, c);
-        if (c == '#' || c == '\n' || c == '\\') { 
+        if (c == '#' || c == '\n' || c == '\\') {
             /* Lines with only whitespace and/or comments
-               and/or a line continuation character 
+               and/or a line continuation character
                shouldn't affect the indentation and are
                not passed to the parser as NEWLINE tokens,
                except *totally* empty lines in interactive
@@ -1213,12 +1213,12 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
             if (col == 0 && c == '\n' && tok->prompt != NULL) {
                 blankline = 0; /* Let it through */
             }
-            else if (tok->prompt != NULL && tok->lineno == 1) { 
-                /* In interactive mode, if the first line contains 
-                   only spaces and/or a comment, let it through. */ 
-                blankline = 0; 
-                col = altcol = 0; 
-            } 
+            else if (tok->prompt != NULL && tok->lineno == 1) {
+                /* In interactive mode, if the first line contains
+                   only spaces and/or a comment, let it through. */
+                blankline = 0;
+                col = altcol = 0;
+            }
             else {
                 blankline = 1; /* Ignore completely */
             }
@@ -1279,31 +1279,31 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
         }
     }
 
-    /* Peek ahead at the next character */ 
-    c = tok_nextc(tok); 
-    tok_backup(tok, c); 
-    /* Check if we are closing an async function */ 
-    if (tok->async_def 
-        && !blankline 
-        /* Due to some implementation artifacts of type comments, 
-         * a TYPE_COMMENT at the start of a function won't set an 
-         * indentation level and it will produce a NEWLINE after it. 
-         * To avoid spuriously ending an async function due to this, 
-         * wait until we have some non-newline char in front of us. */ 
-        && c != '\n' 
-        && tok->level == 0 
-        /* There was a NEWLINE after ASYNC DEF, 
-           so we're past the signature. */ 
-        && tok->async_def_nl 
-        /* Current indentation level is less than where 
-           the async function was defined */ 
-        && tok->async_def_indent >= tok->indent) 
-    { 
-        tok->async_def = 0; 
-        tok->async_def_indent = 0; 
-        tok->async_def_nl = 0; 
-    } 
- 
+    /* Peek ahead at the next character */
+    c = tok_nextc(tok);
+    tok_backup(tok, c);
+    /* Check if we are closing an async function */
+    if (tok->async_def
+        && !blankline
+        /* Due to some implementation artifacts of type comments,
+         * a TYPE_COMMENT at the start of a function won't set an
+         * indentation level and it will produce a NEWLINE after it.
+         * To avoid spuriously ending an async function due to this,
+         * wait until we have some non-newline char in front of us. */
+        && c != '\n'
+        && tok->level == 0
+        /* There was a NEWLINE after ASYNC DEF,
+           so we're past the signature. */
+        && tok->async_def_nl
+        /* Current indentation level is less than where
+           the async function was defined */
+        && tok->async_def_indent >= tok->indent)
+    {
+        tok->async_def = 0;
+        tok->async_def_indent = 0;
+        tok->async_def_nl = 0;
+    }
+
  again:
     tok->start = NULL;
     /* Skip spaces */
@@ -1314,63 +1314,63 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
     /* Set start of current token */
     tok->start = tok->cur - 1;
 
-    /* Skip comment, unless it's a type comment */ 
+    /* Skip comment, unless it's a type comment */
     if (c == '#') {
-        const char *prefix, *p, *type_start; 
- 
+        const char *prefix, *p, *type_start;
+
         while (c != EOF && c != '\n') {
             c = tok_nextc(tok);
         }
- 
-        if (tok->type_comments) { 
-            p = tok->start; 
-            prefix = type_comment_prefix; 
-            while (*prefix && p < tok->cur) { 
-                if (*prefix == ' ') { 
-                    while (*p == ' ' || *p == '\t') { 
-                        p++; 
-                    } 
-                } else if (*prefix == *p) { 
-                    p++; 
-                } else { 
-                    break; 
-                } 
- 
-                prefix++; 
-            } 
- 
-            /* This is a type comment if we matched all of type_comment_prefix. */ 
-            if (!*prefix) { 
-                int is_type_ignore = 1; 
-                const char *ignore_end = p + 6; 
-                tok_backup(tok, c);  /* don't eat the newline or EOF */ 
- 
-                type_start = p; 
- 
-                /* A TYPE_IGNORE is "type: ignore" followed by the end of the token 
-                 * or anything ASCII and non-alphanumeric. */ 
-                is_type_ignore = ( 
-                    tok->cur >= ignore_end && memcmp(p, "ignore", 6) == 0 
-                    && !(tok->cur > ignore_end 
-                         && ((unsigned char)ignore_end[0] >= 128 || Py_ISALNUM(ignore_end[0])))); 
- 
-                if (is_type_ignore) { 
-                    *p_start = ignore_end; 
-                    *p_end = tok->cur; 
- 
-                    /* If this type ignore is the only thing on the line, consume the newline also. */ 
-                    if (blankline) { 
-                        tok_nextc(tok); 
-                        tok->atbol = 1; 
-                    } 
-                    return TYPE_IGNORE; 
-                } else { 
-                    *p_start = type_start;  /* after type_comment_prefix */ 
-                    *p_end = tok->cur; 
-                    return TYPE_COMMENT; 
-                } 
-            } 
-        } 
+
+        if (tok->type_comments) {
+            p = tok->start;
+            prefix = type_comment_prefix;
+            while (*prefix && p < tok->cur) {
+                if (*prefix == ' ') {
+                    while (*p == ' ' || *p == '\t') {
+                        p++;
+                    }
+                } else if (*prefix == *p) {
+                    p++;
+                } else {
+                    break;
+                }
+
+                prefix++;
+            }
+
+            /* This is a type comment if we matched all of type_comment_prefix. */
+            if (!*prefix) {
+                int is_type_ignore = 1;
+                const char *ignore_end = p + 6;
+                tok_backup(tok, c);  /* don't eat the newline or EOF */
+
+                type_start = p;
+
+                /* A TYPE_IGNORE is "type: ignore" followed by the end of the token
+                 * or anything ASCII and non-alphanumeric. */
+                is_type_ignore = (
+                    tok->cur >= ignore_end && memcmp(p, "ignore", 6) == 0
+                    && !(tok->cur > ignore_end
+                         && ((unsigned char)ignore_end[0] >= 128 || Py_ISALNUM(ignore_end[0]))));
+
+                if (is_type_ignore) {
+                    *p_start = ignore_end;
+                    *p_end = tok->cur;
+
+                    /* If this type ignore is the only thing on the line, consume the newline also. */
+                    if (blankline) {
+                        tok_nextc(tok);
+                        tok->atbol = 1;
+                    }
+                    return TYPE_IGNORE;
+                } else {
+                    *p_start = type_start;  /* after type_comment_prefix */
+                    *p_end = tok->cur;
+                    return TYPE_COMMENT;
+                }
+            }
+        }
     }
 
     /* Check for EOF and errors now */
@@ -1417,55 +1417,55 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
         if (nonascii && !verify_identifier(tok)) {
             return ERRORTOKEN;
         }
- 
+
         *p_start = tok->start;
         *p_end = tok->cur;
 
-        /* async/await parsing block. */ 
-        if (tok->cur - tok->start == 5 && tok->start[0] == 'a') { 
-            /* May be an 'async' or 'await' token.  For Python 3.7 or 
-               later we recognize them unconditionally.  For Python 
-               3.5 or 3.6 we recognize 'async' in front of 'def', and 
-               either one inside of 'async def'.  (Technically we 
-               shouldn't recognize these at all for 3.4 or earlier, 
-               but there's no *valid* Python 3.4 code that would be 
-               rejected, and async functions will be rejected in a 
-               later phase.) */ 
-            if (!tok->async_hacks || tok->async_def) { 
-                /* Always recognize the keywords. */ 
-                if (memcmp(tok->start, "async", 5) == 0) { 
-                    return ASYNC; 
-                } 
-                if (memcmp(tok->start, "await", 5) == 0) { 
-                    return AWAIT; 
-                } 
-            } 
-            else if (memcmp(tok->start, "async", 5) == 0) { 
-                /* The current token is 'async'. 
-                   Look ahead one token to see if that is 'def'. */ 
- 
-                struct tok_state ahead_tok; 
-                const char *ahead_tok_start = NULL; 
-                const char *ahead_tok_end = NULL; 
-                int ahead_tok_kind; 
- 
-                memcpy(&ahead_tok, tok, sizeof(ahead_tok)); 
-                ahead_tok_kind = tok_get(&ahead_tok, &ahead_tok_start, 
-                                         &ahead_tok_end); 
- 
-                if (ahead_tok_kind == NAME 
-                    && ahead_tok.cur - ahead_tok.start == 3 
-                    && memcmp(ahead_tok.start, "def", 3) == 0) 
-                { 
-                    /* The next token is going to be 'def', so instead of 
-                       returning a plain NAME token, return ASYNC. */ 
-                    tok->async_def_indent = tok->indent; 
-                    tok->async_def = 1; 
-                    return ASYNC; 
-                } 
-            } 
-        } 
- 
+        /* async/await parsing block. */
+        if (tok->cur - tok->start == 5 && tok->start[0] == 'a') {
+            /* May be an 'async' or 'await' token.  For Python 3.7 or
+               later we recognize them unconditionally.  For Python
+               3.5 or 3.6 we recognize 'async' in front of 'def', and
+               either one inside of 'async def'.  (Technically we
+               shouldn't recognize these at all for 3.4 or earlier,
+               but there's no *valid* Python 3.4 code that would be
+               rejected, and async functions will be rejected in a
+               later phase.) */
+            if (!tok->async_hacks || tok->async_def) {
+                /* Always recognize the keywords. */
+                if (memcmp(tok->start, "async", 5) == 0) {
+                    return ASYNC;
+                }
+                if (memcmp(tok->start, "await", 5) == 0) {
+                    return AWAIT;
+                }
+            }
+            else if (memcmp(tok->start, "async", 5) == 0) {
+                /* The current token is 'async'.
+                   Look ahead one token to see if that is 'def'. */
+
+                struct tok_state ahead_tok;
+                const char *ahead_tok_start = NULL;
+                const char *ahead_tok_end = NULL;
+                int ahead_tok_kind;
+
+                memcpy(&ahead_tok, tok, sizeof(ahead_tok));
+                ahead_tok_kind = tok_get(&ahead_tok, &ahead_tok_start,
+                                         &ahead_tok_end);
+
+                if (ahead_tok_kind == NAME
+                    && ahead_tok.cur - ahead_tok.start == 3
+                    && memcmp(ahead_tok.start, "def", 3) == 0)
+                {
+                    /* The next token is going to be 'def', so instead of
+                       returning a plain NAME token, return ASYNC. */
+                    tok->async_def_indent = tok->indent;
+                    tok->async_def = 1;
+                    return ASYNC;
+                }
+            }
+        }
+
         return NAME;
     }
 
@@ -1478,11 +1478,11 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
         *p_start = tok->start;
         *p_end = tok->cur - 1; /* Leave '\n' out of the string */
         tok->cont_line = 0;
-        if (tok->async_def) { 
-            /* We're somewhere inside an 'async def' function, and 
-               we've encountered a NEWLINE after its signature. */ 
-            tok->async_def_nl = 1; 
-        } 
+        if (tok->async_def) {
+            /* We're somewhere inside an 'async def' function, and
+               we've encountered a NEWLINE after its signature. */
+            tok->async_def_nl = 1;
+        }
         return NEWLINE;
     }
 
@@ -1525,7 +1525,7 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
                     }
                     if (!isxdigit(c)) {
                         tok_backup(tok, c);
-                        return syntaxerror(tok, "invalid hexadecimal literal"); 
+                        return syntaxerror(tok, "invalid hexadecimal literal");
                     }
                     do {
                         c = tok_nextc(tok);
@@ -1541,22 +1541,22 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
                     }
                     if (c < '0' || c >= '8') {
                         tok_backup(tok, c);
-                        if (isdigit(c)) { 
-                            return syntaxerror(tok, 
-                                    "invalid digit '%c' in octal literal", c); 
-                        } 
-                        else { 
-                            return syntaxerror(tok, "invalid octal literal"); 
-                        } 
+                        if (isdigit(c)) {
+                            return syntaxerror(tok,
+                                    "invalid digit '%c' in octal literal", c);
+                        }
+                        else {
+                            return syntaxerror(tok, "invalid octal literal");
+                        }
                     }
                     do {
                         c = tok_nextc(tok);
                     } while ('0' <= c && c < '8');
                 } while (c == '_');
-                if (isdigit(c)) { 
-                    return syntaxerror(tok, 
-                            "invalid digit '%c' in octal literal", c); 
-                } 
+                if (isdigit(c)) {
+                    return syntaxerror(tok,
+                            "invalid digit '%c' in octal literal", c);
+                }
             }
             else if (c == 'b' || c == 'B') {
                 /* Binary */
@@ -1567,22 +1567,22 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
                     }
                     if (c != '0' && c != '1') {
                         tok_backup(tok, c);
-                        if (isdigit(c)) { 
-                            return syntaxerror(tok, 
-                                    "invalid digit '%c' in binary literal", c); 
-                        } 
-                        else { 
-                            return syntaxerror(tok, "invalid binary literal"); 
-                        } 
+                        if (isdigit(c)) {
+                            return syntaxerror(tok,
+                                    "invalid digit '%c' in binary literal", c);
+                        }
+                        else {
+                            return syntaxerror(tok, "invalid binary literal");
+                        }
                     }
                     do {
                         c = tok_nextc(tok);
                     } while (c == '0' || c == '1');
                 } while (c == '_');
-                if (isdigit(c)) { 
-                    return syntaxerror(tok, 
-                            "invalid digit '%c' in binary literal", c); 
-                } 
+                if (isdigit(c)) {
+                    return syntaxerror(tok,
+                            "invalid digit '%c' in binary literal", c);
+                }
             }
             else {
                 int nonzero = 0;
@@ -1593,7 +1593,7 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
                         c = tok_nextc(tok);
                         if (!isdigit(c)) {
                             tok_backup(tok, c);
-                            return syntaxerror(tok, "invalid decimal literal"); 
+                            return syntaxerror(tok, "invalid decimal literal");
                         }
                     }
                     if (c != '0') {
@@ -1621,10 +1621,10 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
                 else if (nonzero) {
                     /* Old-style octal: now disallowed. */
                     tok_backup(tok, c);
-                    return syntaxerror(tok, 
-                                       "leading zeros in decimal integer " 
-                                       "literals are not permitted; " 
-                                       "use an 0o prefix for octal integers"); 
+                    return syntaxerror(tok,
+                                       "leading zeros in decimal integer "
+                                       "literals are not permitted; "
+                                       "use an 0o prefix for octal integers");
                 }
             }
         }
@@ -1657,7 +1657,7 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
                         c = tok_nextc(tok);
                         if (!isdigit(c)) {
                             tok_backup(tok, c);
-                            return syntaxerror(tok, "invalid decimal literal"); 
+                            return syntaxerror(tok, "invalid decimal literal");
                         }
                     } else if (!isdigit(c)) {
                         tok_backup(tok, c);
@@ -1691,13 +1691,13 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
         int quote_size = 1;             /* 1 or 3 */
         int end_quote_size = 0;
 
-        /* Nodes of type STRING, especially multi line strings 
-           must be handled differently in order to get both 
-           the starting line number and the column offset right. 
-           (cf. issue 16806) */ 
-        tok->first_lineno = tok->lineno; 
-        tok->multi_line_start = tok->line_start; 
- 
+        /* Nodes of type STRING, especially multi line strings
+           must be handled differently in order to get both
+           the starting line number and the column offset right.
+           (cf. issue 16806) */
+        tok->first_lineno = tok->lineno;
+        tok->multi_line_start = tok->line_start;
+
         /* Find the quote size and start of string */
         c = tok_nextc(tok);
         if (c == quote) {
@@ -1754,14 +1754,14 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
             tok->done = E_LINECONT;
             return ERRORTOKEN;
         }
-        c = tok_nextc(tok); 
-        if (c == EOF) { 
-            tok->done = E_EOF; 
-            tok->cur = tok->inp; 
-            return ERRORTOKEN; 
-        } else { 
-            tok_backup(tok, c); 
-        } 
+        c = tok_nextc(tok);
+        if (c == EOF) {
+            tok->done = E_EOF;
+            tok->cur = tok->inp;
+            return ERRORTOKEN;
+        } else {
+            tok_backup(tok, c);
+        }
         tok->cont_line = 1;
         goto again; /* Read next line */
     }
@@ -1791,38 +1791,38 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
     case '(':
     case '[':
     case '{':
-        if (tok->level >= MAXLEVEL) { 
-            return syntaxerror(tok, "too many nested parentheses"); 
-        } 
-        tok->parenstack[tok->level] = c; 
-        tok->parenlinenostack[tok->level] = tok->lineno; 
+        if (tok->level >= MAXLEVEL) {
+            return syntaxerror(tok, "too many nested parentheses");
+        }
+        tok->parenstack[tok->level] = c;
+        tok->parenlinenostack[tok->level] = tok->lineno;
         tok->level++;
         break;
     case ')':
     case ']':
     case '}':
-        if (!tok->level) { 
-            return syntaxerror(tok, "unmatched '%c'", c); 
-        } 
+        if (!tok->level) {
+            return syntaxerror(tok, "unmatched '%c'", c);
+        }
         tok->level--;
-        int opening = tok->parenstack[tok->level]; 
-        if (!((opening == '(' && c == ')') || 
-              (opening == '[' && c == ']') || 
-              (opening == '{' && c == '}'))) 
-        { 
-            if (tok->parenlinenostack[tok->level] != tok->lineno) { 
-                return syntaxerror(tok, 
-                        "closing parenthesis '%c' does not match " 
-                        "opening parenthesis '%c' on line %d", 
-                        c, opening, tok->parenlinenostack[tok->level]); 
-            } 
-            else { 
-                return syntaxerror(tok, 
-                        "closing parenthesis '%c' does not match " 
-                        "opening parenthesis '%c'", 
-                        c, opening); 
-            } 
-        } 
+        int opening = tok->parenstack[tok->level];
+        if (!((opening == '(' && c == ')') ||
+              (opening == '[' && c == ']') ||
+              (opening == '{' && c == '}')))
+        {
+            if (tok->parenlinenostack[tok->level] != tok->lineno) {
+                return syntaxerror(tok,
+                        "closing parenthesis '%c' does not match "
+                        "opening parenthesis '%c' on line %d",
+                        c, opening, tok->parenlinenostack[tok->level]);
+            }
+            else {
+                return syntaxerror(tok,
+                        "closing parenthesis '%c' does not match "
+                        "opening parenthesis '%c'",
+                        c, opening);
+            }
+        }
         break;
     }
 
@@ -1833,7 +1833,7 @@ tok_get(struct tok_state *tok, const char **p_start, const char **p_end)
 }
 
 int
-PyTokenizer_Get(struct tok_state *tok, const char **p_start, const char **p_end) 
+PyTokenizer_Get(struct tok_state *tok, const char **p_start, const char **p_end)
 {
     int result = tok_get(tok, p_start, p_end);
     if (tok->decoding_erred) {
@@ -1858,9 +1858,9 @@ PyTokenizer_FindEncodingFilename(int fd, PyObject *filename)
 {
     struct tok_state *tok;
     FILE *fp;
-    const char *p_start = NULL; 
-    const char *p_end = NULL; 
-    char *encoding = NULL; 
+    const char *p_start = NULL;
+    const char *p_end = NULL;
+    char *encoding = NULL;
 
     fd = _Py_dup(fd);
     if (fd < 0) {
@@ -1895,7 +1895,7 @@ PyTokenizer_FindEncodingFilename(int fd, PyObject *filename)
     if (tok->encoding) {
         encoding = (char *)PyMem_MALLOC(strlen(tok->encoding) + 1);
         if (encoding)
-            strcpy(encoding, tok->encoding); 
+            strcpy(encoding, tok->encoding);
     }
     PyTokenizer_Free(tok);
     return encoding;
diff --git a/contrib/tools/python3/src/Parser/tokenizer.h b/contrib/tools/python3/src/Parser/tokenizer.h
index a55c7cf93d..5660ea38e9 100644
--- a/contrib/tools/python3/src/Parser/tokenizer.h
+++ b/contrib/tools/python3/src/Parser/tokenizer.h
@@ -11,7 +11,7 @@ extern "C" {
 #include "token.h"      /* For token types */
 
 #define MAXINDENT 100   /* Max indentation level */
-#define MAXLEVEL 200    /* Max parentheses level */ 
+#define MAXLEVEL 200    /* Max parentheses level */
 
 enum decoding_state {
     STATE_INIT,
@@ -26,8 +26,8 @@ struct tok_state {
     char *buf;          /* Input buffer, or NULL; malloc'ed if fp != NULL */
     char *cur;          /* Next character in buffer */
     char *inp;          /* End of data in buffer */
-    const char *end;    /* End of input buffer if buf != NULL */ 
-    const char *start;  /* Start of current token if not NULL */ 
+    const char *end;    /* End of input buffer if buf != NULL */
+    const char *start;  /* Start of current token if not NULL */
     int done;           /* E_OK normally, E_EOF at EOF, otherwise error code */
     /* NB If done != E_OK, cur must be == inp!!! */
     FILE *fp;           /* Rest of input; NULL if tokenizing a string */
@@ -38,13 +38,13 @@ struct tok_state {
     int pendin;         /* Pending indents (if > 0) or dedents (if < 0) */
     const char *prompt, *nextprompt;          /* For interactive prompting */
     int lineno;         /* Current line number */
-    int first_lineno;   /* First line of a single line or multi line string 
-                           expression (cf. issue 16806) */ 
+    int first_lineno;   /* First line of a single line or multi line string
+                           expression (cf. issue 16806) */
     int level;          /* () [] {} Parentheses nesting level */
             /* Used to allow free continuations inside them */
-    char parenstack[MAXLEVEL]; 
-    int parenlinenostack[MAXLEVEL]; 
-    PyObject *filename; 
+    char parenstack[MAXLEVEL];
+    int parenlinenostack[MAXLEVEL];
+    PyObject *filename;
     /* Stuff for checking on different tab sizes */
     int altindstack[MAXINDENT];         /* Stack of alternate indents */
     /* Stuff for PEP 0263 */
@@ -54,23 +54,23 @@ struct tok_state {
     char *encoding;         /* Source encoding. */
     int cont_line;          /* whether we are in a continuation line. */
     const char* line_start;     /* pointer to start of current line */
-    const char* multi_line_start; /* pointer to start of first line of 
-                                     a single line or multi line string 
-                                     expression (cf. issue 16806) */ 
+    const char* multi_line_start; /* pointer to start of first line of
+                                     a single line or multi line string
+                                     expression (cf. issue 16806) */
     PyObject *decoding_readline; /* open(...).readline */
     PyObject *decoding_buffer;
     const char* enc;        /* Encoding for the current str. */
-    char* str; 
-    char* input;       /* Tokenizer's newline translated copy of the string. */ 
- 
-    int type_comments;      /* Whether to look for type comments */ 
- 
-    /* async/await related fields (still needed depending on feature_version) */ 
-    int async_hacks;     /* =1 if async/await aren't always keywords */ 
-    int async_def;        /* =1 if tokens are inside an 'async def' body. */ 
-    int async_def_indent; /* Indentation level of the outermost 'async def'. */ 
-    int async_def_nl;     /* =1 if the outermost 'async def' had at least one 
-                             NEWLINE token after it. */ 
+    char* str;
+    char* input;       /* Tokenizer's newline translated copy of the string. */
+
+    int type_comments;      /* Whether to look for type comments */
+
+    /* async/await related fields (still needed depending on feature_version) */
+    int async_hacks;     /* =1 if async/await aren't always keywords */
+    int async_def;        /* =1 if tokens are inside an 'async def' body. */
+    int async_def_indent; /* Indentation level of the outermost 'async def'. */
+    int async_def_nl;     /* =1 if the outermost 'async def' had at least one
+                             NEWLINE token after it. */
 };
 
 extern struct tok_state *PyTokenizer_FromString(const char *, int);
@@ -78,10 +78,10 @@ extern struct tok_state *PyTokenizer_FromUTF8(const char *, int);
 extern struct tok_state *PyTokenizer_FromFile(FILE *, const char*,
                                               const char *, const char *);
 extern void PyTokenizer_Free(struct tok_state *);
-extern int PyTokenizer_Get(struct tok_state *, const char **, const char **); 
+extern int PyTokenizer_Get(struct tok_state *, const char **, const char **);
+
+#define tok_dump _Py_tok_dump
 
-#define tok_dump _Py_tok_dump 
- 
 #ifdef __cplusplus
 }
 #endif