text: #include <Python.h>
  #include "pycore_ast.h"           // _PyAST_Validate(),
  #include <errcode.h>
  #include "tokenizer.h"
  
  #include "pegen.h"
  #include "string_parser.h"
  
  PyObject *
  _PyPegen_new_type_comment(Parser *p, const 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;
      }
      const 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 _PyAST_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);
  
      const 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;
  }
  
  int
  _PyPegen_check_legacy_stmt(Parser *p, expr_ty name) {
      if (name->kind != Name_kind) {
          return 0;
      }
      const char* candidates[2] = {"print", "exec"};
      for (int i=0; i<2; i++) {
          if (PyUnicode_CompareWithASCIIString(name->v.Name.id, candidates[i]) == 0) {
              return 1;
          }
      }
      return 0;
  }
  
  PyObject *
  _PyPegen_new_identifier(Parser *p, const 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, "");
  }
  
  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 "expression";
          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 literal";
          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 inline void
  raise_unclosed_parentheses_error(Parser *p) {
         int error_lineno = p->tok->parenlinenostack[p->tok->level-1];
         int error_col = p->tok->parencolstack[p->tok->level-1];
         RAISE_ERROR_KNOWN_LOCATION(p, PyExc_SyntaxError,
                                    error_lineno, error_col, error_lineno, -1,
                                    "'%c' was never closed",
                                    p->tok->parenstack[p->tok->level-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_EOF:
              if (p->tok->level) {
                  raise_unclosed_parentheses_error(p);
              } else {
                  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,
                                 p->tok->lineno, -1, 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, 0, -1, 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;
      Py_ssize_t end_col_offset = -1;
      if (t->col_offset == -1) {
          if (p->tok->cur == p->tok->buf) {
              col_offset = 0;
          } else {
              const char* start = p->tok->buf  ? p->tok->line_start : p->tok->buf;
              col_offset = Py_SAFE_DOWNCAST(p->tok->cur - start, intptr_t, int);
          }
      } else {
          col_offset = t->col_offset + 1;
      }
  
      if (t->end_col_offset != -1) {
          end_col_offset = t->end_col_offset + 1;
      }
  
      va_list va;
      va_start(va, errmsg);
      _PyPegen_raise_error_known_location(p, errtype, t->lineno, col_offset, t->end_lineno, end_col_offset, errmsg, va);
      va_end(va);
  
      return NULL;
  }
  
  static PyObject *
  get_error_line(Parser *p, Py_ssize_t lineno)
  {
      /* If the file descriptor is interactive, the source lines of the current
       * (multi-line) statement are stored in p->tok->interactive_src_start.
       * If not, we're parsing from a string, which means that the whole source
       * is stored in p->tok->str. */
      assert(p->tok->fp == NULL || p->tok->fp == stdin);
  
      char *cur_line = p->tok->fp_interactive ? p->tok->interactive_src_start : p->tok->str;
      assert(cur_line != NULL);
  
      for (int i = 0; i < lineno - 1; i++) {
          cur_line = strchr(cur_line, '\n') + 1;
      }
  
      char *next_newline;
      if ((next_newline = strchr(cur_line, '\n')) == NULL) { // This is the last line
          next_newline = cur_line + strlen(cur_line);
      }
      return PyUnicode_DecodeUTF8(cur_line, next_newline - cur_line, "replace");
  }
  
  Py_ssize_t
  _PyPegen_byte_offset_to_character_offset(PyObject *line, Py_ssize_t col_offset)
  {
      const char *str = PyUnicode_AsUTF8(line);
      if (!str) {
          return -1;
      }
      Py_ssize_t len = strlen(str);
      if (col_offset > len + 1) {
          col_offset = len + 1;
      }
      assert(col_offset >= 0);
      PyObject *text = PyUnicode_DecodeUTF8(str, col_offset, "replace");
      if (!text) {
          return -1;
      }
      Py_ssize_t size = PyUnicode_GET_LENGTH(text);
      Py_DECREF(text);
      return size;
  }
  
  void *
  _PyPegen_raise_error_known_location(Parser *p, PyObject *errtype,
                                      Py_ssize_t lineno, Py_ssize_t col_offset,
                                      Py_ssize_t end_lineno, Py_ssize_t end_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 (end_lineno == CURRENT_POS) {
          end_lineno = p->tok->lineno;
      }
      if (end_col_offset == CURRENT_POS) {
          end_col_offset = p->tok->cur - p->tok->line_start;
      }
  
      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_Malloc(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->tok->fp_interactive) {
          error_line = get_error_line(p, lineno);
      }
      else if (p->start_rule == Py_file_input) {
          error_line = _PyErr_ProgramDecodedTextObject(p->tok->filename,
                                                       (int) lineno, p->tok->encoding);
      }
  
      if (!error_line) {
          /* PyErr_ProgramTextObject was not called or returned NULL. If it was not called,
             then we need to find the error line from some other source, because
             p->start_rule != Py_file_input. If it returned NULL, then it either unexpectedly
             failed or we're parsing from a string or the REPL. There's a third edge case where
             we're actually parsing from a file, which has an E_EOF SyntaxError and in that case
             `PyErr_ProgramTextObject` fails because lineno points to last_file_line + 1, which
             does not physically exist */
          assert(p->tok->fp == NULL || p->tok->fp == stdin || p->tok->done == E_EOF);
  
          if (p->tok->lineno <= lineno && p->tok->inp > p->tok->buf) {
              Py_ssize_t size = p->tok->inp - p->tok->buf;
              error_line = PyUnicode_DecodeUTF8(p->tok->buf, size, "replace");
          }
          else if (p->tok->fp == NULL || p->tok->fp == stdin) {
              error_line = get_error_line(p, lineno);
          }
          else {
              error_line = PyUnicode_FromStringAndSize("", 0);
          }
          if (!error_line) {
              goto error;
          }
      }
  
      if (p->start_rule == Py_fstring_input) {
          col_offset -= p->starting_col_offset;
          end_col_offset -= p->starting_col_offset;
      }
  
      Py_ssize_t col_number = col_offset;
      Py_ssize_t end_col_number = end_col_offset;
  
      if (p->tok->encoding != NULL) {
          col_number = _PyPegen_byte_offset_to_character_offset(error_line, col_offset);
          if (col_number < 0) {
              goto error;
          }
          if (end_col_number > 0) {
              Py_ssize_t end_col_offset = _PyPegen_byte_offset_to_character_offset(error_line, end_col_number);
              if (end_col_offset < 0) {
                  goto error;
              } else {
                  end_col_number = end_col_offset;
              }
          }
      }
      tmp = Py_BuildValue("(OiiNii)", p->tok->filename, lineno, col_number, error_line, end_lineno, end_col_number);
      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_Free((void *)errmsg);
      }
      return NULL;
  
  error:
      Py_XDECREF(errstr);
      Py_XDECREF(error_line);
      if (p->start_rule == Py_fstring_input) {
          PyMem_Free((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 = _PyAST_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);
  }
  
  static int
  initialize_token(Parser *p, Token *token, const char *start, const char *end, int token_type) {
      assert(token != NULL);
  
      token->type = (token_type == NAME) ? _get_keyword_or_name_type(p, start, (int)(end - start)) : token_type;
      token->bytes = PyBytes_FromStringAndSize(start, end - start);
      if (token->bytes == NULL) {
          return -1;
      }
  
      if (_PyArena_AddPyObject(p->arena, token->bytes) < 0) {
          Py_DECREF(token->bytes);
          return -1;
      }
  
      const char *line_start = token_type == STRING ? p->tok->multi_line_start : p->tok->line_start;
      int lineno = token_type == STRING ? p->tok->first_lineno : p->tok->lineno;
      int end_lineno = p->tok->lineno;
  
      int col_offset = (start != NULL && start >= line_start) ? (int)(start - line_start) : -1;
      int end_col_offset = (end != NULL && end >= p->tok->line_start) ? (int)(end - p->tok->line_start) : -1;
  
      token->lineno = p->starting_lineno + lineno;
      token->col_offset = p->tok->lineno == 1 ? p->starting_col_offset + col_offset : col_offset;
      token->end_lineno = p->starting_lineno + end_lineno;
      token->end_col_offset = p->tok->lineno == 1 ? p->starting_col_offset + end_col_offset : end_col_offset;
  
      p->fill += 1;
  
      if (token_type == ERRORTOKEN && p->tok->done == E_DECODE) {
          return raise_decode_error(p);
      }
  
      return (token_type == ERRORTOKEN ? tokenizer_error(p) : 0);
  }
  
  static int
  _resize_tokens_array(Parser *p) {
      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_Calloc(1, sizeof(Token));
          if (p->tokens[i] == NULL) {
              p->size = i; // Needed, in order to cleanup correctly after parser fails
              PyErr_NoMemory();
              return -1;
          }
      }
      p->size = newsize;
      return 0;
  }
  
  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 we have reached the end and we are in single input mode we need to insert a newline and reset the parsing
      if (p->start_rule == Py_single_input && type == ENDMARKER && 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;
      }
  
      // Check if we are at the limit of the token array capacity and resize if needed
      if ((p->fill == p->size) && (_resize_tokens_array(p) != 0)) {
          return -1;
      }
  
      Token *t = p->tokens[p->fill];
      return initialize_token(p, t, start, end, type);
  }
  
  
  #if defined(Py_DEBUG)
  // 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;
  }
  #endif
  
  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 defined(PY_DEBUG)
              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;
              }
  #endif
              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;
  }
  
  void*
  _PyPegen_expect_forced_result(Parser *p, void* result, const char* expected) {
  
      if (p->error_indicator == 1) {
          return NULL;
      }
      if (result == NULL) {
          RAISE_SYNTAX_ERROR("expected (%s)", expected);
          return NULL;
      }
      return result;
  }
  
  Token *
  _PyPegen_expect_forced_token(Parser *p, int type, const char* expected) {
  
      if (p->error_indicator == 1) {
          return NULL;
      }
  
      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) {
          RAISE_SYNTAX_ERROR_KNOWN_LOCATION(t, "expected '%s'", expected);
          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;
      }
      const 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;
  }
  
  static expr_ty
  _PyPegen_name_from_token(Parser *p, Token* t)
  {
      if (t == NULL) {
          return NULL;
      }
      const 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 _PyAST_Name(id, Load, t->lineno, t->col_offset, t->end_lineno,
                         t->end_col_offset, p->arena);
  }
  
  
  expr_ty
  _PyPegen_name_token(Parser *p)
  {
      Token *t = _PyPegen_expect_token(p, NAME);
      return _PyPegen_name_from_token(p, t);
  }
  
  void *
  _PyPegen_string_token(Parser *p)
  {
      return _PyPegen_expect_token(p, STRING);
  }
  
  
  expr_ty _PyPegen_soft_keyword_token(Parser *p) {
      Token *t = _PyPegen_expect_token(p, NAME);
      if (t == NULL) {
          return NULL;
      }
      char *the_token;
      Py_ssize_t size;
      PyBytes_AsStringAndSize(t->bytes, &the_token, &size);
      for (char **keyword = p->soft_keywords; *keyword != NULL; keyword++) {
          if (strncmp(*keyword, the_token, size) == 0) {
              return _PyPegen_name_from_token(p, t);
          }
      }
      return NULL;
  }
  
  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;
      }
  
      const 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 _PyAST_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->soft_keywords = NULL;
      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;
      p->in_raw_rule = 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;
      // Don't try to get extra tokens in interactive mode when trying to
      // raise specialized errors in the second pass.
      p->tok->interactive_underflow = IUNDERFLOW_STOP;
  }
  
  static int
  _PyPegen_check_tokenizer_errors(Parser *p) {
      // Tokenize the whole input to see if there are any tokenization
      // errors such as mistmatching parentheses. These will get priority
      // over generic syntax errors only if the line number of the error is
      // before the one that we had for the generic error.
  
      // We don't want to tokenize to the end for interactive input
      if (p->tok->prompt != NULL) {
          return 0;
      }
  
      PyObject *type, *value, *traceback;
      PyErr_Fetch(&type, &value, &traceback);
  
      Token *current_token = p->known_err_token != NULL ? p->known_err_token : p->tokens[p->fill - 1];
      Py_ssize_t current_err_line = current_token->lineno;
  
      int ret = 0;
  
      for (;;) {
          const char *start;
          const char *end;
          switch (_PyTokenizer_Get(p->tok, &start, &end)) {
              case ERRORTOKEN:
                  if (p->tok->level != 0) {
                      int error_lineno = p->tok->parenlinenostack[p->tok->level-1];
                      if (current_err_line > error_lineno) {
                          raise_unclosed_parentheses_error(p);
                          ret = -1;
                          goto exit;
                      }
                  }
                  break;
              case ENDMARKER:
                  break;
              default:
                  continue;
          }
          break;
      }
  
  
  exit:
      if (PyErr_Occurred()) {
          Py_XDECREF(value);
          Py_XDECREF(type);
          Py_XDECREF(traceback);
      } else {
          PyErr_Restore(type, value, traceback);
      }
      return ret;
  }
  
  void *
  _PyPegen_run_parser(Parser *p)
  {
      void *res = _PyPegen_parse(p);
      if (res == NULL) {
          if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_SyntaxError)) {
              return NULL;
          }
          Token *last_token = p->tokens[p->fill - 1];
          reset_parser_state(p);
          _PyPegen_parse(p);
          if (PyErr_Occurred()) {
              // Prioritize tokenizer errors to custom syntax errors raised
              // on the second phase only if the errors come from the parser.
              if (p->tok->done == E_DONE && PyErr_ExceptionMatches(PyExc_SyntaxError)) {
                  _PyPegen_check_tokenizer_errors(p);
              }
              return NULL;
          }
          if (p->fill == 0) {
              RAISE_SYNTAX_ERROR("error at start before reading any input");
          }
          else if (p->tok->done == E_EOF) {
              if (p->tok->level) {
                  raise_unclosed_parentheses_error(p);
              } else {
                  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 {
                  // Use the last token we found on the first pass to avoid reporting
                  // incorrect locations for generic syntax errors just because we reached
                  // further away when trying to find specific syntax errors in the second
                  // pass.
                  RAISE_SYNTAX_ERROR_KNOWN_LOCATION(last_token, "invalid syntax");
                  // _PyPegen_check_tokenizer_errors will override the existing
                  // generic SyntaxError we just raised if errors are found.
                  _PyPegen_check_tokenizer_errors(p);
              }
          }
          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");
      }
  
      // test_peg_generator defines _Py_TEST_PEGEN to not call PyAST_Validate()
  #if defined(Py_DEBUG) && !defined(_Py_TEST_PEGEN)
      if (p->start_rule == Py_single_input ||
          p->start_rule == Py_file_input ||
          p->start_rule == Py_eval_input)
      {
          if (!_PyAST_Validate(res)) {
              return NULL;
          }
      }
  #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;
      }
      if (!tok->fp || ps1 != NULL || ps2 != NULL ||
          PyUnicode_CompareWithASCIIString(filename_ob, "<stdin>") == 0) {
          tok->fp_interactive = 1;
      }
      // 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_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;
  }
  
  asdl_stmt_seq*
  _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 = (asdl_seq*)_Py_asdl_generic_seq_new(1, p->arena);
      if (!seq) {
          return NULL;
      }
      asdl_seq_SET_UNTYPED(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 = (asdl_seq*)_Py_asdl_generic_seq_new(asdl_seq_LEN(seq) + 1, p->arena);
      if (!new_seq) {
          return NULL;
      }
  
      asdl_seq_SET_UNTYPED(new_seq, 0, a);
      for (Py_ssize_t i = 1, l = asdl_seq_LEN(new_seq); i < l; i++) {
          asdl_seq_SET_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(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 = (asdl_seq*)_Py_asdl_generic_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_UNTYPED(new_seq, i, asdl_seq_GET_UNTYPED(seq, i));
      }
      asdl_seq_SET_UNTYPED(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_UNTYPED(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 = (asdl_seq*)_Py_asdl_generic_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_UNTYPED(seqs, i);
          for (Py_ssize_t j = 0, li = asdl_seq_LEN(inner_seq); j < li; j++) {
              asdl_seq_SET_UNTYPED(flattened_seq, flattened_seq_idx++, asdl_seq_GET_UNTYPED(inner_seq, j));
          }
      }
      assert(flattened_seq_idx == flattened_seq_size);
  
      return flattened_seq;
  }
  
  void *
  _PyPegen_seq_last_item(asdl_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      return asdl_seq_GET_UNTYPED(seq, len - 1);
  }
  
  void *
  _PyPegen_seq_first_item(asdl_seq *seq)
  {
      return asdl_seq_GET_UNTYPED(seq, 0);
  }
  
  
  /* 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 _PyAST_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_UNTYPED(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, int lineno, int col_offset, int end_lineno,
                          int end_col_offset, PyArena *arena) {
      PyObject *str = PyUnicode_InternFromString("*");
      if (!str) {
          return NULL;
      }
      if (_PyArena_AddPyObject(p->arena, str) < 0) {
          Py_DECREF(str);
          return NULL;
      }
      return _PyAST_alias(str, NULL, lineno, col_offset, end_lineno, end_col_offset, arena);
  }
  
  /* Creates a new asdl_seq* with the identifiers of all the names in seq */
  asdl_identifier_seq *
  _PyPegen_map_names_to_ids(Parser *p, asdl_expr_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      assert(len > 0);
  
      asdl_identifier_seq *new_seq = _Py_asdl_identifier_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_UNTYPED(seq, i);
          asdl_seq_SET(new_seq, i, pair->cmpop);
      }
      return new_seq;
  }
  
  asdl_expr_seq *
  _PyPegen_get_exprs(Parser *p, asdl_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      assert(len > 0);
  
      asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
      if (!new_seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          CmpopExprPair *pair = asdl_seq_GET_UNTYPED(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_expr_seq *
  _set_seq_context(Parser *p, asdl_expr_seq *seq, expr_context_ty ctx)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      if (len == 0) {
          return NULL;
      }
  
      asdl_expr_seq *new_seq = _Py_asdl_expr_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 _PyAST_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 _PyAST_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 _PyAST_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 _PyAST_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 _PyAST_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 _PyAST_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_expr_seq *
  _PyPegen_get_keys(Parser *p, asdl_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
      if (!new_seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
          asdl_seq_SET(new_seq, i, pair->key);
      }
      return new_seq;
  }
  
  /* Extracts all values from an asdl_seq* of KeyValuePair*'s */
  asdl_expr_seq *
  _PyPegen_get_values(Parser *p, asdl_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
      if (!new_seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          KeyValuePair *pair = asdl_seq_GET_UNTYPED(seq, i);
          asdl_seq_SET(new_seq, i, pair->value);
      }
      return new_seq;
  }
  
  /* Constructs a KeyPatternPair that is used when parsing mapping & class patterns */
  KeyPatternPair *
  _PyPegen_key_pattern_pair(Parser *p, expr_ty key, pattern_ty pattern)
  {
      KeyPatternPair *a = _PyArena_Malloc(p->arena, sizeof(KeyPatternPair));
      if (!a) {
          return NULL;
      }
      a->key = key;
      a->pattern = pattern;
      return a;
  }
  
  /* Extracts all keys from an asdl_seq* of KeyPatternPair*'s */
  asdl_expr_seq *
  _PyPegen_get_pattern_keys(Parser *p, asdl_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      asdl_expr_seq *new_seq = _Py_asdl_expr_seq_new(len, p->arena);
      if (!new_seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
          asdl_seq_SET(new_seq, i, pair->key);
      }
      return new_seq;
  }
  
  /* Extracts all patterns from an asdl_seq* of KeyPatternPair*'s */
  asdl_pattern_seq *
  _PyPegen_get_patterns(Parser *p, asdl_seq *seq)
  {
      Py_ssize_t len = asdl_seq_LEN(seq);
      asdl_pattern_seq *new_seq = _Py_asdl_pattern_seq_new(len, p->arena);
      if (!new_seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          KeyPatternPair *pair = asdl_seq_GET_UNTYPED(seq, i);
          asdl_seq_SET(new_seq, i, pair->pattern);
      }
      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_arg_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 = (asdl_seq*)_Py_asdl_generic_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_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(a, i));
      }
      for (Py_ssize_t i = 0; i < second_len; i++) {
          asdl_seq_SET_UNTYPED(new_seq, k++, asdl_seq_GET_UNTYPED(b, i));
      }
  
      return new_seq;
  }
  
  static asdl_arg_seq*
  _get_names(Parser *p, asdl_seq *names_with_defaults)
  {
      Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
      asdl_arg_seq *seq = _Py_asdl_arg_seq_new(len, p->arena);
      if (!seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
          asdl_seq_SET(seq, i, pair->arg);
      }
      return seq;
  }
  
  static asdl_expr_seq *
  _get_defaults(Parser *p, asdl_seq *names_with_defaults)
  {
      Py_ssize_t len = asdl_seq_LEN(names_with_defaults);
      asdl_expr_seq *seq = _Py_asdl_expr_seq_new(len, p->arena);
      if (!seq) {
          return NULL;
      }
      for (Py_ssize_t i = 0; i < len; i++) {
          NameDefaultPair *pair = asdl_seq_GET_UNTYPED(names_with_defaults, i);
          asdl_seq_SET(seq, i, pair->value);
      }
      return seq;
  }
  
  static int
  _make_posonlyargs(Parser *p,
                    asdl_arg_seq *slash_without_default,
                    SlashWithDefault *slash_with_default,
                    asdl_arg_seq **posonlyargs) {
      if (slash_without_default != NULL) {
          *posonlyargs = slash_without_default;
      }
      else if (slash_with_default != NULL) {
          asdl_arg_seq *slash_with_default_names =
                  _get_names(p, slash_with_default->names_with_defaults);
          if (!slash_with_default_names) {
              return -1;
          }
          *posonlyargs = (asdl_arg_seq*)_PyPegen_join_sequences(
                  p,
                  (asdl_seq*)slash_with_default->plain_names,
                  (asdl_seq*)slash_with_default_names);
      }
      else {
          *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
      }
      return *posonlyargs == NULL ? -1 : 0;
  }
  
  static int
  _make_posargs(Parser *p,
                asdl_arg_seq *plain_names,
                asdl_seq *names_with_default,
                asdl_arg_seq **posargs) {
      if (plain_names != NULL && names_with_default != NULL) {
          asdl_arg_seq *names_with_default_names = _get_names(p, names_with_default);
          if (!names_with_default_names) {
              return -1;
          }
          *posargs = (asdl_arg_seq*)_PyPegen_join_sequences(
                  p,(asdl_seq*)plain_names, (asdl_seq*)names_with_default_names);
      }
      else if (plain_names == NULL && names_with_default != NULL) {
          *posargs = _get_names(p, names_with_default);
      }
      else if (plain_names != NULL && names_with_default == NULL) {
          *posargs = plain_names;
      }
      else {
          *posargs = _Py_asdl_arg_seq_new(0, p->arena);
      }
      return *posargs == NULL ? -1 : 0;
  }
  
  static int
  _make_posdefaults(Parser *p,
                    SlashWithDefault *slash_with_default,
                    asdl_seq *names_with_default,
                    asdl_expr_seq **posdefaults) {
      if (slash_with_default != NULL && names_with_default != NULL) {
          asdl_expr_seq *slash_with_default_values =
                  _get_defaults(p, slash_with_default->names_with_defaults);
          if (!slash_with_default_values) {
              return -1;
          }
          asdl_expr_seq *names_with_default_values = _get_defaults(p, names_with_default);
          if (!names_with_default_values) {
              return -1;
          }
          *posdefaults = (asdl_expr_seq*)_PyPegen_join_sequences(
                  p,
                  (asdl_seq*)slash_with_default_values,
                  (asdl_seq*)names_with_default_values);
      }
      else if (slash_with_default == NULL && names_with_default != NULL) {
          *posdefaults = _get_defaults(p, names_with_default);
      }
      else if (slash_with_default != NULL && names_with_default == NULL) {
          *posdefaults = _get_defaults(p, slash_with_default->names_with_defaults);
      }
      else {
          *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
      }
      return *posdefaults == NULL ? -1 : 0;
  }
  
  static int
  _make_kwargs(Parser *p, StarEtc *star_etc,
               asdl_arg_seq **kwonlyargs,
               asdl_expr_seq **kwdefaults) {
      if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
          *kwonlyargs = _get_names(p, star_etc->kwonlyargs);
      }
      else {
          *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
      }
  
      if (*kwonlyargs == NULL) {
          return -1;
      }
  
      if (star_etc != NULL && star_etc->kwonlyargs != NULL) {
          *kwdefaults = _get_defaults(p, star_etc->kwonlyargs);
      }
      else {
          *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
      }
  
      if (*kwdefaults == NULL) {
          return -1;
      }
  
      return 0;
  }
  
  /* Constructs an arguments_ty object out of all the parsed constructs in the parameters rule */
  arguments_ty
  _PyPegen_make_arguments(Parser *p, asdl_arg_seq *slash_without_default,
                          SlashWithDefault *slash_with_default, asdl_arg_seq *plain_names,
                          asdl_seq *names_with_default, StarEtc *star_etc)
  {
      asdl_arg_seq *posonlyargs;
      if (_make_posonlyargs(p, slash_without_default, slash_with_default, &posonlyargs) == -1) {
          return NULL;
      }
  
      asdl_arg_seq *posargs;
      if (_make_posargs(p, plain_names, names_with_default, &posargs) == -1) {
          return NULL;
      }
  
      asdl_expr_seq *posdefaults;
      if (_make_posdefaults(p,slash_with_default, names_with_default, &posdefaults) == -1) {
          return NULL;
      }
  
      arg_ty vararg = NULL;
      if (star_etc != NULL && star_etc->vararg != NULL) {
          vararg = star_etc->vararg;
      }
  
      asdl_arg_seq *kwonlyargs;
      asdl_expr_seq *kwdefaults;
      if (_make_kwargs(p, star_etc, &kwonlyargs, &kwdefaults) == -1) {
          return NULL;
      }
  
      arg_ty kwarg = NULL;
      if (star_etc != NULL && star_etc->kwarg != NULL) {
          kwarg = star_etc->kwarg;
      }
  
      return _PyAST_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_arg_seq *posonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
      if (!posonlyargs) {
          return NULL;
      }
      asdl_arg_seq *posargs = _Py_asdl_arg_seq_new(0, p->arena);
      if (!posargs) {
          return NULL;
      }
      asdl_expr_seq *posdefaults = _Py_asdl_expr_seq_new(0, p->arena);
      if (!posdefaults) {
          return NULL;
      }
      asdl_arg_seq *kwonlyargs = _Py_asdl_arg_seq_new(0, p->arena);
      if (!kwonlyargs) {
          return NULL;
      }
      asdl_expr_seq *kwdefaults = _Py_asdl_expr_seq_new(0, p->arena);
      if (!kwdefaults) {
          return NULL;
      }
  
      return _PyAST_arguments(posonlyargs, posargs, NULL, kwonlyargs,
                              kwdefaults, NULL, posdefaults, 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_expr_seq *decorators, stmt_ty function_def)
  {
      assert(function_def != NULL);
      if (function_def->kind == AsyncFunctionDef_kind) {
          return _PyAST_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 _PyAST_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_expr_seq *decorators, stmt_ty class_def)
  {
      assert(class_def != NULL);
      return _PyAST_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_UNTYPED(seq, i);
          if (!k->is_keyword) {
              n++;
          }
      }
      return n;
  }
  
  /* Extract the starred expressions of an asdl_seq* of KeywordOrStarred*s */
  asdl_expr_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_expr_seq *new_seq = _Py_asdl_expr_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_UNTYPED(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_keyword_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_keyword_seq *new_seq = _Py_asdl_keyword_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_UNTYPED(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_UNTYPED(strings, 0);
      Token *last = asdl_seq_GET_UNTYPED(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_UNTYPED(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 _PyAST_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;
  }
  
  expr_ty
  _PyPegen_ensure_imaginary(Parser *p, expr_ty exp)
  {
      if (exp->kind != Constant_kind || !PyComplex_CheckExact(exp->v.Constant.value)) {
          RAISE_SYNTAX_ERROR_KNOWN_LOCATION(exp, "imaginary number required in complex literal");
          return NULL;
      }
      return exp;
  }
  
  expr_ty
  _PyPegen_ensure_real(Parser *p, expr_ty exp)
  {
      if (exp->kind != Constant_kind || PyComplex_CheckExact(exp->v.Constant.value)) {
          RAISE_SYNTAX_ERROR_KNOWN_LOCATION(exp, "real number required in complex literal");
          return NULL;
      }
      return exp;
  }
  
  mod_ty
  _PyPegen_make_module(Parser *p, asdl_stmt_seq *a) {
      asdl_type_ignore_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_type_ignore_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 = _PyAST_TypeIgnore(p->type_ignore_comments.items[i].lineno,
                                                    tag, p->arena);
              if (ti == NULL) {
                  return NULL;
              }
              asdl_seq_SET(type_ignores, i, ti);
          }
      }
      return _PyAST_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);
  }
  
  
  static inline expr_ty
  _PyPegen_get_last_comprehension_item(comprehension_ty comprehension) {
      if (comprehension->ifs == NULL || asdl_seq_LEN(comprehension->ifs) == 0) {
          return comprehension->iter;
      }
      return PyPegen_last_item(comprehension->ifs, expr_ty);
  }
  
  void *
  _PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args, asdl_comprehension_seq *comprehensions)
  {
      /* 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;
      }
  
      comprehension_ty last_comprehension = PyPegen_last_item(comprehensions, comprehension_ty);
  
      return RAISE_SYNTAX_ERROR_KNOWN_RANGE(
          (expr_ty) asdl_seq_GET(args->v.Call.args, len - 1),
          _PyPegen_get_last_comprehension_item(last_comprehension),
          "Generator expression must be parenthesized"
      );
  }
  
  
  expr_ty _PyPegen_collect_call_seqs(Parser *p, asdl_expr_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 _PyAST_Call(_PyPegen_dummy_name(p), a, NULL, lineno, col_offset,
                          end_lineno, end_col_offset, arena);
  
      }
  
      asdl_expr_seq *starreds = _PyPegen_seq_extract_starred_exprs(p, b);
      asdl_keyword_seq *keywords = _PyPegen_seq_delete_starred_exprs(p, b);
  
      if (starreds) {
          total_len += asdl_seq_LEN(starreds);
      }
  
      asdl_expr_seq *args = _Py_asdl_expr_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 _PyAST_Call(_PyPegen_dummy_name(p), args, keywords, lineno,
                         col_offset, end_lineno, end_col_offset, arena);
  }
  