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

1 files changed, 5025 insertions, 5025 deletions

diff --git a/contrib/tools/python3/src/Python/Python-ast.c b/contrib/tools/python3/src/Python/Python-ast.c
index 8b1c594a87..49c3805522 100644
--- a/contrib/tools/python3/src/Python/Python-ast.c
+++ b/contrib/tools/python3/src/Python/Python-ast.c
@@ -4,829 +4,829 @@
 
 #include "Python.h"
 #include "Python-ast.h"
-#include "structmember.h"         // PyMemberDef
-
-typedef struct {
-    int initialized;
-    PyObject *AST_type;
-    PyObject *Add_singleton;
-    PyObject *Add_type;
-    PyObject *And_singleton;
-    PyObject *And_type;
-    PyObject *AnnAssign_type;
-    PyObject *Assert_type;
-    PyObject *Assign_type;
-    PyObject *AsyncFor_type;
-    PyObject *AsyncFunctionDef_type;
-    PyObject *AsyncWith_type;
-    PyObject *Attribute_type;
-    PyObject *AugAssign_type;
-    PyObject *Await_type;
-    PyObject *BinOp_type;
-    PyObject *BitAnd_singleton;
-    PyObject *BitAnd_type;
-    PyObject *BitOr_singleton;
-    PyObject *BitOr_type;
-    PyObject *BitXor_singleton;
-    PyObject *BitXor_type;
-    PyObject *BoolOp_type;
-    PyObject *Break_type;
-    PyObject *Call_type;
-    PyObject *ClassDef_type;
-    PyObject *Compare_type;
-    PyObject *Constant_type;
-    PyObject *Continue_type;
-    PyObject *Del_singleton;
-    PyObject *Del_type;
-    PyObject *Delete_type;
-    PyObject *DictComp_type;
-    PyObject *Dict_type;
-    PyObject *Div_singleton;
-    PyObject *Div_type;
-    PyObject *Eq_singleton;
-    PyObject *Eq_type;
-    PyObject *ExceptHandler_type;
-    PyObject *Expr_type;
-    PyObject *Expression_type;
-    PyObject *FloorDiv_singleton;
-    PyObject *FloorDiv_type;
-    PyObject *For_type;
-    PyObject *FormattedValue_type;
-    PyObject *FunctionDef_type;
-    PyObject *FunctionType_type;
-    PyObject *GeneratorExp_type;
-    PyObject *Global_type;
-    PyObject *GtE_singleton;
-    PyObject *GtE_type;
-    PyObject *Gt_singleton;
-    PyObject *Gt_type;
-    PyObject *IfExp_type;
-    PyObject *If_type;
-    PyObject *ImportFrom_type;
-    PyObject *Import_type;
-    PyObject *In_singleton;
-    PyObject *In_type;
-    PyObject *Interactive_type;
-    PyObject *Invert_singleton;
-    PyObject *Invert_type;
-    PyObject *IsNot_singleton;
-    PyObject *IsNot_type;
-    PyObject *Is_singleton;
-    PyObject *Is_type;
-    PyObject *JoinedStr_type;
-    PyObject *LShift_singleton;
-    PyObject *LShift_type;
-    PyObject *Lambda_type;
-    PyObject *ListComp_type;
-    PyObject *List_type;
-    PyObject *Load_singleton;
-    PyObject *Load_type;
-    PyObject *LtE_singleton;
-    PyObject *LtE_type;
-    PyObject *Lt_singleton;
-    PyObject *Lt_type;
-    PyObject *MatMult_singleton;
-    PyObject *MatMult_type;
-    PyObject *Mod_singleton;
-    PyObject *Mod_type;
-    PyObject *Module_type;
-    PyObject *Mult_singleton;
-    PyObject *Mult_type;
-    PyObject *Name_type;
-    PyObject *NamedExpr_type;
-    PyObject *Nonlocal_type;
-    PyObject *NotEq_singleton;
-    PyObject *NotEq_type;
-    PyObject *NotIn_singleton;
-    PyObject *NotIn_type;
-    PyObject *Not_singleton;
-    PyObject *Not_type;
-    PyObject *Or_singleton;
-    PyObject *Or_type;
-    PyObject *Pass_type;
-    PyObject *Pow_singleton;
-    PyObject *Pow_type;
-    PyObject *RShift_singleton;
-    PyObject *RShift_type;
-    PyObject *Raise_type;
-    PyObject *Return_type;
-    PyObject *SetComp_type;
-    PyObject *Set_type;
-    PyObject *Slice_type;
-    PyObject *Starred_type;
-    PyObject *Store_singleton;
-    PyObject *Store_type;
-    PyObject *Sub_singleton;
-    PyObject *Sub_type;
-    PyObject *Subscript_type;
-    PyObject *Try_type;
-    PyObject *Tuple_type;
-    PyObject *TypeIgnore_type;
-    PyObject *UAdd_singleton;
-    PyObject *UAdd_type;
-    PyObject *USub_singleton;
-    PyObject *USub_type;
-    PyObject *UnaryOp_type;
-    PyObject *While_type;
-    PyObject *With_type;
-    PyObject *YieldFrom_type;
-    PyObject *Yield_type;
-    PyObject *__dict__;
-    PyObject *__doc__;
-    PyObject *__module__;
-    PyObject *_attributes;
-    PyObject *_fields;
-    PyObject *alias_type;
-    PyObject *annotation;
-    PyObject *arg;
-    PyObject *arg_type;
-    PyObject *args;
-    PyObject *argtypes;
-    PyObject *arguments_type;
-    PyObject *asname;
-    PyObject *ast;
-    PyObject *attr;
-    PyObject *bases;
-    PyObject *body;
-    PyObject *boolop_type;
-    PyObject *cause;
-    PyObject *cmpop_type;
-    PyObject *col_offset;
-    PyObject *comparators;
-    PyObject *comprehension_type;
-    PyObject *context_expr;
-    PyObject *conversion;
-    PyObject *ctx;
-    PyObject *decorator_list;
-    PyObject *defaults;
-    PyObject *elt;
-    PyObject *elts;
-    PyObject *end_col_offset;
-    PyObject *end_lineno;
-    PyObject *exc;
-    PyObject *excepthandler_type;
-    PyObject *expr_context_type;
-    PyObject *expr_type;
-    PyObject *finalbody;
-    PyObject *format_spec;
-    PyObject *func;
-    PyObject *generators;
-    PyObject *handlers;
-    PyObject *id;
-    PyObject *ifs;
-    PyObject *is_async;
-    PyObject *items;
-    PyObject *iter;
-    PyObject *key;
-    PyObject *keys;
-    PyObject *keyword_type;
-    PyObject *keywords;
-    PyObject *kind;
-    PyObject *kw_defaults;
-    PyObject *kwarg;
-    PyObject *kwonlyargs;
-    PyObject *left;
-    PyObject *level;
-    PyObject *lineno;
-    PyObject *lower;
-    PyObject *mod_type;
-    PyObject *module;
-    PyObject *msg;
-    PyObject *name;
-    PyObject *names;
-    PyObject *op;
-    PyObject *operand;
-    PyObject *operator_type;
-    PyObject *ops;
-    PyObject *optional_vars;
-    PyObject *orelse;
-    PyObject *posonlyargs;
-    PyObject *returns;
-    PyObject *right;
-    PyObject *simple;
-    PyObject *slice;
-    PyObject *step;
-    PyObject *stmt_type;
-    PyObject *tag;
-    PyObject *target;
-    PyObject *targets;
-    PyObject *test;
-    PyObject *type;
-    PyObject *type_comment;
-    PyObject *type_ignore_type;
-    PyObject *type_ignores;
-    PyObject *unaryop_type;
-    PyObject *upper;
-    PyObject *value;
-    PyObject *values;
-    PyObject *vararg;
-    PyObject *withitem_type;
-} astmodulestate;
-
-
-// Forward declaration
-static int init_types(astmodulestate *state);
-
-// bpo-41194, bpo-41261, bpo-41631: The _ast module uses a global state.
-static astmodulestate global_ast_state = {0};
-
-static astmodulestate*
-get_global_ast_state(void)
-{
-    astmodulestate* state = &global_ast_state;
-    if (!init_types(state)) {
-        return NULL;
-    }
-    return state;
-}
-
-static astmodulestate*
-get_ast_state(PyObject* Py_UNUSED(module))
-{
-    astmodulestate* state = get_global_ast_state();
-    // get_ast_state() must only be called after _ast module is imported,
-    // and astmodule_exec() calls init_types()
-    assert(state != NULL);
-    return state;
-}
-
-void _PyAST_Fini()
-{
-    astmodulestate* state = &global_ast_state;
-    Py_CLEAR(state->AST_type);
-    Py_CLEAR(state->Add_singleton);
-    Py_CLEAR(state->Add_type);
-    Py_CLEAR(state->And_singleton);
-    Py_CLEAR(state->And_type);
-    Py_CLEAR(state->AnnAssign_type);
-    Py_CLEAR(state->Assert_type);
-    Py_CLEAR(state->Assign_type);
-    Py_CLEAR(state->AsyncFor_type);
-    Py_CLEAR(state->AsyncFunctionDef_type);
-    Py_CLEAR(state->AsyncWith_type);
-    Py_CLEAR(state->Attribute_type);
-    Py_CLEAR(state->AugAssign_type);
-    Py_CLEAR(state->Await_type);
-    Py_CLEAR(state->BinOp_type);
-    Py_CLEAR(state->BitAnd_singleton);
-    Py_CLEAR(state->BitAnd_type);
-    Py_CLEAR(state->BitOr_singleton);
-    Py_CLEAR(state->BitOr_type);
-    Py_CLEAR(state->BitXor_singleton);
-    Py_CLEAR(state->BitXor_type);
-    Py_CLEAR(state->BoolOp_type);
-    Py_CLEAR(state->Break_type);
-    Py_CLEAR(state->Call_type);
-    Py_CLEAR(state->ClassDef_type);
-    Py_CLEAR(state->Compare_type);
-    Py_CLEAR(state->Constant_type);
-    Py_CLEAR(state->Continue_type);
-    Py_CLEAR(state->Del_singleton);
-    Py_CLEAR(state->Del_type);
-    Py_CLEAR(state->Delete_type);
-    Py_CLEAR(state->DictComp_type);
-    Py_CLEAR(state->Dict_type);
-    Py_CLEAR(state->Div_singleton);
-    Py_CLEAR(state->Div_type);
-    Py_CLEAR(state->Eq_singleton);
-    Py_CLEAR(state->Eq_type);
-    Py_CLEAR(state->ExceptHandler_type);
-    Py_CLEAR(state->Expr_type);
-    Py_CLEAR(state->Expression_type);
-    Py_CLEAR(state->FloorDiv_singleton);
-    Py_CLEAR(state->FloorDiv_type);
-    Py_CLEAR(state->For_type);
-    Py_CLEAR(state->FormattedValue_type);
-    Py_CLEAR(state->FunctionDef_type);
-    Py_CLEAR(state->FunctionType_type);
-    Py_CLEAR(state->GeneratorExp_type);
-    Py_CLEAR(state->Global_type);
-    Py_CLEAR(state->GtE_singleton);
-    Py_CLEAR(state->GtE_type);
-    Py_CLEAR(state->Gt_singleton);
-    Py_CLEAR(state->Gt_type);
-    Py_CLEAR(state->IfExp_type);
-    Py_CLEAR(state->If_type);
-    Py_CLEAR(state->ImportFrom_type);
-    Py_CLEAR(state->Import_type);
-    Py_CLEAR(state->In_singleton);
-    Py_CLEAR(state->In_type);
-    Py_CLEAR(state->Interactive_type);
-    Py_CLEAR(state->Invert_singleton);
-    Py_CLEAR(state->Invert_type);
-    Py_CLEAR(state->IsNot_singleton);
-    Py_CLEAR(state->IsNot_type);
-    Py_CLEAR(state->Is_singleton);
-    Py_CLEAR(state->Is_type);
-    Py_CLEAR(state->JoinedStr_type);
-    Py_CLEAR(state->LShift_singleton);
-    Py_CLEAR(state->LShift_type);
-    Py_CLEAR(state->Lambda_type);
-    Py_CLEAR(state->ListComp_type);
-    Py_CLEAR(state->List_type);
-    Py_CLEAR(state->Load_singleton);
-    Py_CLEAR(state->Load_type);
-    Py_CLEAR(state->LtE_singleton);
-    Py_CLEAR(state->LtE_type);
-    Py_CLEAR(state->Lt_singleton);
-    Py_CLEAR(state->Lt_type);
-    Py_CLEAR(state->MatMult_singleton);
-    Py_CLEAR(state->MatMult_type);
-    Py_CLEAR(state->Mod_singleton);
-    Py_CLEAR(state->Mod_type);
-    Py_CLEAR(state->Module_type);
-    Py_CLEAR(state->Mult_singleton);
-    Py_CLEAR(state->Mult_type);
-    Py_CLEAR(state->Name_type);
-    Py_CLEAR(state->NamedExpr_type);
-    Py_CLEAR(state->Nonlocal_type);
-    Py_CLEAR(state->NotEq_singleton);
-    Py_CLEAR(state->NotEq_type);
-    Py_CLEAR(state->NotIn_singleton);
-    Py_CLEAR(state->NotIn_type);
-    Py_CLEAR(state->Not_singleton);
-    Py_CLEAR(state->Not_type);
-    Py_CLEAR(state->Or_singleton);
-    Py_CLEAR(state->Or_type);
-    Py_CLEAR(state->Pass_type);
-    Py_CLEAR(state->Pow_singleton);
-    Py_CLEAR(state->Pow_type);
-    Py_CLEAR(state->RShift_singleton);
-    Py_CLEAR(state->RShift_type);
-    Py_CLEAR(state->Raise_type);
-    Py_CLEAR(state->Return_type);
-    Py_CLEAR(state->SetComp_type);
-    Py_CLEAR(state->Set_type);
-    Py_CLEAR(state->Slice_type);
-    Py_CLEAR(state->Starred_type);
-    Py_CLEAR(state->Store_singleton);
-    Py_CLEAR(state->Store_type);
-    Py_CLEAR(state->Sub_singleton);
-    Py_CLEAR(state->Sub_type);
-    Py_CLEAR(state->Subscript_type);
-    Py_CLEAR(state->Try_type);
-    Py_CLEAR(state->Tuple_type);
-    Py_CLEAR(state->TypeIgnore_type);
-    Py_CLEAR(state->UAdd_singleton);
-    Py_CLEAR(state->UAdd_type);
-    Py_CLEAR(state->USub_singleton);
-    Py_CLEAR(state->USub_type);
-    Py_CLEAR(state->UnaryOp_type);
-    Py_CLEAR(state->While_type);
-    Py_CLEAR(state->With_type);
-    Py_CLEAR(state->YieldFrom_type);
-    Py_CLEAR(state->Yield_type);
-    Py_CLEAR(state->__dict__);
-    Py_CLEAR(state->__doc__);
-    Py_CLEAR(state->__module__);
-    Py_CLEAR(state->_attributes);
-    Py_CLEAR(state->_fields);
-    Py_CLEAR(state->alias_type);
-    Py_CLEAR(state->annotation);
-    Py_CLEAR(state->arg);
-    Py_CLEAR(state->arg_type);
-    Py_CLEAR(state->args);
-    Py_CLEAR(state->argtypes);
-    Py_CLEAR(state->arguments_type);
-    Py_CLEAR(state->asname);
-    Py_CLEAR(state->ast);
-    Py_CLEAR(state->attr);
-    Py_CLEAR(state->bases);
-    Py_CLEAR(state->body);
-    Py_CLEAR(state->boolop_type);
-    Py_CLEAR(state->cause);
-    Py_CLEAR(state->cmpop_type);
-    Py_CLEAR(state->col_offset);
-    Py_CLEAR(state->comparators);
-    Py_CLEAR(state->comprehension_type);
-    Py_CLEAR(state->context_expr);
-    Py_CLEAR(state->conversion);
-    Py_CLEAR(state->ctx);
-    Py_CLEAR(state->decorator_list);
-    Py_CLEAR(state->defaults);
-    Py_CLEAR(state->elt);
-    Py_CLEAR(state->elts);
-    Py_CLEAR(state->end_col_offset);
-    Py_CLEAR(state->end_lineno);
-    Py_CLEAR(state->exc);
-    Py_CLEAR(state->excepthandler_type);
-    Py_CLEAR(state->expr_context_type);
-    Py_CLEAR(state->expr_type);
-    Py_CLEAR(state->finalbody);
-    Py_CLEAR(state->format_spec);
-    Py_CLEAR(state->func);
-    Py_CLEAR(state->generators);
-    Py_CLEAR(state->handlers);
-    Py_CLEAR(state->id);
-    Py_CLEAR(state->ifs);
-    Py_CLEAR(state->is_async);
-    Py_CLEAR(state->items);
-    Py_CLEAR(state->iter);
-    Py_CLEAR(state->key);
-    Py_CLEAR(state->keys);
-    Py_CLEAR(state->keyword_type);
-    Py_CLEAR(state->keywords);
-    Py_CLEAR(state->kind);
-    Py_CLEAR(state->kw_defaults);
-    Py_CLEAR(state->kwarg);
-    Py_CLEAR(state->kwonlyargs);
-    Py_CLEAR(state->left);
-    Py_CLEAR(state->level);
-    Py_CLEAR(state->lineno);
-    Py_CLEAR(state->lower);
-    Py_CLEAR(state->mod_type);
-    Py_CLEAR(state->module);
-    Py_CLEAR(state->msg);
-    Py_CLEAR(state->name);
-    Py_CLEAR(state->names);
-    Py_CLEAR(state->op);
-    Py_CLEAR(state->operand);
-    Py_CLEAR(state->operator_type);
-    Py_CLEAR(state->ops);
-    Py_CLEAR(state->optional_vars);
-    Py_CLEAR(state->orelse);
-    Py_CLEAR(state->posonlyargs);
-    Py_CLEAR(state->returns);
-    Py_CLEAR(state->right);
-    Py_CLEAR(state->simple);
-    Py_CLEAR(state->slice);
-    Py_CLEAR(state->step);
-    Py_CLEAR(state->stmt_type);
-    Py_CLEAR(state->tag);
-    Py_CLEAR(state->target);
-    Py_CLEAR(state->targets);
-    Py_CLEAR(state->test);
-    Py_CLEAR(state->type);
-    Py_CLEAR(state->type_comment);
-    Py_CLEAR(state->type_ignore_type);
-    Py_CLEAR(state->type_ignores);
-    Py_CLEAR(state->unaryop_type);
-    Py_CLEAR(state->upper);
-    Py_CLEAR(state->value);
-    Py_CLEAR(state->values);
-    Py_CLEAR(state->vararg);
-    Py_CLEAR(state->withitem_type);
-
-    state->initialized = 0;
-}
-
-static int init_identifiers(astmodulestate *state)
-{
-    if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;
-    if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0;
-    if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0;
-    if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return 0;
-    if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return 0;
-    if ((state->annotation = PyUnicode_InternFromString("annotation")) == NULL) return 0;
-    if ((state->arg = PyUnicode_InternFromString("arg")) == NULL) return 0;
-    if ((state->args = PyUnicode_InternFromString("args")) == NULL) return 0;
-    if ((state->argtypes = PyUnicode_InternFromString("argtypes")) == NULL) return 0;
-    if ((state->asname = PyUnicode_InternFromString("asname")) == NULL) return 0;
-    if ((state->ast = PyUnicode_InternFromString("ast")) == NULL) return 0;
-    if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return 0;
-    if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return 0;
-    if ((state->body = PyUnicode_InternFromString("body")) == NULL) return 0;
-    if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0;
-    if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return 0;
-    if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return 0;
-    if ((state->context_expr = PyUnicode_InternFromString("context_expr")) == NULL) return 0;
-    if ((state->conversion = PyUnicode_InternFromString("conversion")) == NULL) return 0;
-    if ((state->ctx = PyUnicode_InternFromString("ctx")) == NULL) return 0;
-    if ((state->decorator_list = PyUnicode_InternFromString("decorator_list")) == NULL) return 0;
-    if ((state->defaults = PyUnicode_InternFromString("defaults")) == NULL) return 0;
-    if ((state->elt = PyUnicode_InternFromString("elt")) == NULL) return 0;
-    if ((state->elts = PyUnicode_InternFromString("elts")) == NULL) return 0;
-    if ((state->end_col_offset = PyUnicode_InternFromString("end_col_offset")) == NULL) return 0;
-    if ((state->end_lineno = PyUnicode_InternFromString("end_lineno")) == NULL) return 0;
-    if ((state->exc = PyUnicode_InternFromString("exc")) == NULL) return 0;
-    if ((state->finalbody = PyUnicode_InternFromString("finalbody")) == NULL) return 0;
-    if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return 0;
-    if ((state->func = PyUnicode_InternFromString("func")) == NULL) return 0;
-    if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return 0;
-    if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return 0;
-    if ((state->id = PyUnicode_InternFromString("id")) == NULL) return 0;
-    if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return 0;
-    if ((state->is_async = PyUnicode_InternFromString("is_async")) == NULL) return 0;
-    if ((state->items = PyUnicode_InternFromString("items")) == NULL) return 0;
-    if ((state->iter = PyUnicode_InternFromString("iter")) == NULL) return 0;
-    if ((state->key = PyUnicode_InternFromString("key")) == NULL) return 0;
-    if ((state->keys = PyUnicode_InternFromString("keys")) == NULL) return 0;
-    if ((state->keywords = PyUnicode_InternFromString("keywords")) == NULL) return 0;
-    if ((state->kind = PyUnicode_InternFromString("kind")) == NULL) return 0;
-    if ((state->kw_defaults = PyUnicode_InternFromString("kw_defaults")) == NULL) return 0;
-    if ((state->kwarg = PyUnicode_InternFromString("kwarg")) == NULL) return 0;
-    if ((state->kwonlyargs = PyUnicode_InternFromString("kwonlyargs")) == NULL) return 0;
-    if ((state->left = PyUnicode_InternFromString("left")) == NULL) return 0;
-    if ((state->level = PyUnicode_InternFromString("level")) == NULL) return 0;
-    if ((state->lineno = PyUnicode_InternFromString("lineno")) == NULL) return 0;
-    if ((state->lower = PyUnicode_InternFromString("lower")) == NULL) return 0;
-    if ((state->module = PyUnicode_InternFromString("module")) == NULL) return 0;
-    if ((state->msg = PyUnicode_InternFromString("msg")) == NULL) return 0;
-    if ((state->name = PyUnicode_InternFromString("name")) == NULL) return 0;
-    if ((state->names = PyUnicode_InternFromString("names")) == NULL) return 0;
-    if ((state->op = PyUnicode_InternFromString("op")) == NULL) return 0;
-    if ((state->operand = PyUnicode_InternFromString("operand")) == NULL) return 0;
-    if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return 0;
-    if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return 0;
-    if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return 0;
-    if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0;
-    if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return 0;
-    if ((state->right = PyUnicode_InternFromString("right")) == NULL) return 0;
-    if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return 0;
-    if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return 0;
-    if ((state->step = PyUnicode_InternFromString("step")) == NULL) return 0;
-    if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return 0;
-    if ((state->target = PyUnicode_InternFromString("target")) == NULL) return 0;
-    if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return 0;
-    if ((state->test = PyUnicode_InternFromString("test")) == NULL) return 0;
-    if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0;
-    if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0;
-    if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0;
-    if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0;
-    if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0;
-    if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0;
-    if ((state->vararg = PyUnicode_InternFromString("vararg")) == NULL) return 0;
-    return 1;
-};
-
-static PyObject* ast2obj_mod(astmodulestate *state, void*);
-static const char * const Module_fields[]={
+#include "structmember.h"         // PyMemberDef 
+
+typedef struct { 
+    int initialized; 
+    PyObject *AST_type; 
+    PyObject *Add_singleton; 
+    PyObject *Add_type; 
+    PyObject *And_singleton; 
+    PyObject *And_type; 
+    PyObject *AnnAssign_type; 
+    PyObject *Assert_type; 
+    PyObject *Assign_type; 
+    PyObject *AsyncFor_type; 
+    PyObject *AsyncFunctionDef_type; 
+    PyObject *AsyncWith_type; 
+    PyObject *Attribute_type; 
+    PyObject *AugAssign_type; 
+    PyObject *Await_type; 
+    PyObject *BinOp_type; 
+    PyObject *BitAnd_singleton; 
+    PyObject *BitAnd_type; 
+    PyObject *BitOr_singleton; 
+    PyObject *BitOr_type; 
+    PyObject *BitXor_singleton; 
+    PyObject *BitXor_type; 
+    PyObject *BoolOp_type; 
+    PyObject *Break_type; 
+    PyObject *Call_type; 
+    PyObject *ClassDef_type; 
+    PyObject *Compare_type; 
+    PyObject *Constant_type; 
+    PyObject *Continue_type; 
+    PyObject *Del_singleton; 
+    PyObject *Del_type; 
+    PyObject *Delete_type; 
+    PyObject *DictComp_type; 
+    PyObject *Dict_type; 
+    PyObject *Div_singleton; 
+    PyObject *Div_type; 
+    PyObject *Eq_singleton; 
+    PyObject *Eq_type; 
+    PyObject *ExceptHandler_type; 
+    PyObject *Expr_type; 
+    PyObject *Expression_type; 
+    PyObject *FloorDiv_singleton; 
+    PyObject *FloorDiv_type; 
+    PyObject *For_type; 
+    PyObject *FormattedValue_type; 
+    PyObject *FunctionDef_type; 
+    PyObject *FunctionType_type; 
+    PyObject *GeneratorExp_type; 
+    PyObject *Global_type; 
+    PyObject *GtE_singleton; 
+    PyObject *GtE_type; 
+    PyObject *Gt_singleton; 
+    PyObject *Gt_type; 
+    PyObject *IfExp_type; 
+    PyObject *If_type; 
+    PyObject *ImportFrom_type; 
+    PyObject *Import_type; 
+    PyObject *In_singleton; 
+    PyObject *In_type; 
+    PyObject *Interactive_type; 
+    PyObject *Invert_singleton; 
+    PyObject *Invert_type; 
+    PyObject *IsNot_singleton; 
+    PyObject *IsNot_type; 
+    PyObject *Is_singleton; 
+    PyObject *Is_type; 
+    PyObject *JoinedStr_type; 
+    PyObject *LShift_singleton; 
+    PyObject *LShift_type; 
+    PyObject *Lambda_type; 
+    PyObject *ListComp_type; 
+    PyObject *List_type; 
+    PyObject *Load_singleton; 
+    PyObject *Load_type; 
+    PyObject *LtE_singleton; 
+    PyObject *LtE_type; 
+    PyObject *Lt_singleton; 
+    PyObject *Lt_type; 
+    PyObject *MatMult_singleton; 
+    PyObject *MatMult_type; 
+    PyObject *Mod_singleton; 
+    PyObject *Mod_type; 
+    PyObject *Module_type; 
+    PyObject *Mult_singleton; 
+    PyObject *Mult_type; 
+    PyObject *Name_type; 
+    PyObject *NamedExpr_type; 
+    PyObject *Nonlocal_type; 
+    PyObject *NotEq_singleton; 
+    PyObject *NotEq_type; 
+    PyObject *NotIn_singleton; 
+    PyObject *NotIn_type; 
+    PyObject *Not_singleton; 
+    PyObject *Not_type; 
+    PyObject *Or_singleton; 
+    PyObject *Or_type; 
+    PyObject *Pass_type; 
+    PyObject *Pow_singleton; 
+    PyObject *Pow_type; 
+    PyObject *RShift_singleton; 
+    PyObject *RShift_type; 
+    PyObject *Raise_type; 
+    PyObject *Return_type; 
+    PyObject *SetComp_type; 
+    PyObject *Set_type; 
+    PyObject *Slice_type; 
+    PyObject *Starred_type; 
+    PyObject *Store_singleton; 
+    PyObject *Store_type; 
+    PyObject *Sub_singleton; 
+    PyObject *Sub_type; 
+    PyObject *Subscript_type; 
+    PyObject *Try_type; 
+    PyObject *Tuple_type; 
+    PyObject *TypeIgnore_type; 
+    PyObject *UAdd_singleton; 
+    PyObject *UAdd_type; 
+    PyObject *USub_singleton; 
+    PyObject *USub_type; 
+    PyObject *UnaryOp_type; 
+    PyObject *While_type; 
+    PyObject *With_type; 
+    PyObject *YieldFrom_type; 
+    PyObject *Yield_type; 
+    PyObject *__dict__; 
+    PyObject *__doc__; 
+    PyObject *__module__; 
+    PyObject *_attributes; 
+    PyObject *_fields; 
+    PyObject *alias_type; 
+    PyObject *annotation; 
+    PyObject *arg; 
+    PyObject *arg_type; 
+    PyObject *args; 
+    PyObject *argtypes; 
+    PyObject *arguments_type; 
+    PyObject *asname; 
+    PyObject *ast; 
+    PyObject *attr; 
+    PyObject *bases; 
+    PyObject *body; 
+    PyObject *boolop_type; 
+    PyObject *cause; 
+    PyObject *cmpop_type; 
+    PyObject *col_offset; 
+    PyObject *comparators; 
+    PyObject *comprehension_type; 
+    PyObject *context_expr; 
+    PyObject *conversion; 
+    PyObject *ctx; 
+    PyObject *decorator_list; 
+    PyObject *defaults; 
+    PyObject *elt; 
+    PyObject *elts; 
+    PyObject *end_col_offset; 
+    PyObject *end_lineno; 
+    PyObject *exc; 
+    PyObject *excepthandler_type; 
+    PyObject *expr_context_type; 
+    PyObject *expr_type; 
+    PyObject *finalbody; 
+    PyObject *format_spec; 
+    PyObject *func; 
+    PyObject *generators; 
+    PyObject *handlers; 
+    PyObject *id; 
+    PyObject *ifs; 
+    PyObject *is_async; 
+    PyObject *items; 
+    PyObject *iter; 
+    PyObject *key; 
+    PyObject *keys; 
+    PyObject *keyword_type; 
+    PyObject *keywords; 
+    PyObject *kind; 
+    PyObject *kw_defaults; 
+    PyObject *kwarg; 
+    PyObject *kwonlyargs; 
+    PyObject *left; 
+    PyObject *level; 
+    PyObject *lineno; 
+    PyObject *lower; 
+    PyObject *mod_type; 
+    PyObject *module; 
+    PyObject *msg; 
+    PyObject *name; 
+    PyObject *names; 
+    PyObject *op; 
+    PyObject *operand; 
+    PyObject *operator_type; 
+    PyObject *ops; 
+    PyObject *optional_vars; 
+    PyObject *orelse; 
+    PyObject *posonlyargs; 
+    PyObject *returns; 
+    PyObject *right; 
+    PyObject *simple; 
+    PyObject *slice; 
+    PyObject *step; 
+    PyObject *stmt_type; 
+    PyObject *tag; 
+    PyObject *target; 
+    PyObject *targets; 
+    PyObject *test; 
+    PyObject *type; 
+    PyObject *type_comment; 
+    PyObject *type_ignore_type; 
+    PyObject *type_ignores; 
+    PyObject *unaryop_type; 
+    PyObject *upper; 
+    PyObject *value; 
+    PyObject *values; 
+    PyObject *vararg; 
+    PyObject *withitem_type; 
+} astmodulestate; 
+ 
+ 
+// Forward declaration 
+static int init_types(astmodulestate *state); 
+ 
+// bpo-41194, bpo-41261, bpo-41631: The _ast module uses a global state. 
+static astmodulestate global_ast_state = {0}; 
+ 
+static astmodulestate* 
+get_global_ast_state(void) 
+{ 
+    astmodulestate* state = &global_ast_state; 
+    if (!init_types(state)) { 
+        return NULL; 
+    } 
+    return state; 
+} 
+ 
+static astmodulestate* 
+get_ast_state(PyObject* Py_UNUSED(module)) 
+{ 
+    astmodulestate* state = get_global_ast_state(); 
+    // get_ast_state() must only be called after _ast module is imported, 
+    // and astmodule_exec() calls init_types() 
+    assert(state != NULL); 
+    return state; 
+} 
+ 
+void _PyAST_Fini() 
+{ 
+    astmodulestate* state = &global_ast_state; 
+    Py_CLEAR(state->AST_type); 
+    Py_CLEAR(state->Add_singleton); 
+    Py_CLEAR(state->Add_type); 
+    Py_CLEAR(state->And_singleton); 
+    Py_CLEAR(state->And_type); 
+    Py_CLEAR(state->AnnAssign_type); 
+    Py_CLEAR(state->Assert_type); 
+    Py_CLEAR(state->Assign_type); 
+    Py_CLEAR(state->AsyncFor_type); 
+    Py_CLEAR(state->AsyncFunctionDef_type); 
+    Py_CLEAR(state->AsyncWith_type); 
+    Py_CLEAR(state->Attribute_type); 
+    Py_CLEAR(state->AugAssign_type); 
+    Py_CLEAR(state->Await_type); 
+    Py_CLEAR(state->BinOp_type); 
+    Py_CLEAR(state->BitAnd_singleton); 
+    Py_CLEAR(state->BitAnd_type); 
+    Py_CLEAR(state->BitOr_singleton); 
+    Py_CLEAR(state->BitOr_type); 
+    Py_CLEAR(state->BitXor_singleton); 
+    Py_CLEAR(state->BitXor_type); 
+    Py_CLEAR(state->BoolOp_type); 
+    Py_CLEAR(state->Break_type); 
+    Py_CLEAR(state->Call_type); 
+    Py_CLEAR(state->ClassDef_type); 
+    Py_CLEAR(state->Compare_type); 
+    Py_CLEAR(state->Constant_type); 
+    Py_CLEAR(state->Continue_type); 
+    Py_CLEAR(state->Del_singleton); 
+    Py_CLEAR(state->Del_type); 
+    Py_CLEAR(state->Delete_type); 
+    Py_CLEAR(state->DictComp_type); 
+    Py_CLEAR(state->Dict_type); 
+    Py_CLEAR(state->Div_singleton); 
+    Py_CLEAR(state->Div_type); 
+    Py_CLEAR(state->Eq_singleton); 
+    Py_CLEAR(state->Eq_type); 
+    Py_CLEAR(state->ExceptHandler_type); 
+    Py_CLEAR(state->Expr_type); 
+    Py_CLEAR(state->Expression_type); 
+    Py_CLEAR(state->FloorDiv_singleton); 
+    Py_CLEAR(state->FloorDiv_type); 
+    Py_CLEAR(state->For_type); 
+    Py_CLEAR(state->FormattedValue_type); 
+    Py_CLEAR(state->FunctionDef_type); 
+    Py_CLEAR(state->FunctionType_type); 
+    Py_CLEAR(state->GeneratorExp_type); 
+    Py_CLEAR(state->Global_type); 
+    Py_CLEAR(state->GtE_singleton); 
+    Py_CLEAR(state->GtE_type); 
+    Py_CLEAR(state->Gt_singleton); 
+    Py_CLEAR(state->Gt_type); 
+    Py_CLEAR(state->IfExp_type); 
+    Py_CLEAR(state->If_type); 
+    Py_CLEAR(state->ImportFrom_type); 
+    Py_CLEAR(state->Import_type); 
+    Py_CLEAR(state->In_singleton); 
+    Py_CLEAR(state->In_type); 
+    Py_CLEAR(state->Interactive_type); 
+    Py_CLEAR(state->Invert_singleton); 
+    Py_CLEAR(state->Invert_type); 
+    Py_CLEAR(state->IsNot_singleton); 
+    Py_CLEAR(state->IsNot_type); 
+    Py_CLEAR(state->Is_singleton); 
+    Py_CLEAR(state->Is_type); 
+    Py_CLEAR(state->JoinedStr_type); 
+    Py_CLEAR(state->LShift_singleton); 
+    Py_CLEAR(state->LShift_type); 
+    Py_CLEAR(state->Lambda_type); 
+    Py_CLEAR(state->ListComp_type); 
+    Py_CLEAR(state->List_type); 
+    Py_CLEAR(state->Load_singleton); 
+    Py_CLEAR(state->Load_type); 
+    Py_CLEAR(state->LtE_singleton); 
+    Py_CLEAR(state->LtE_type); 
+    Py_CLEAR(state->Lt_singleton); 
+    Py_CLEAR(state->Lt_type); 
+    Py_CLEAR(state->MatMult_singleton); 
+    Py_CLEAR(state->MatMult_type); 
+    Py_CLEAR(state->Mod_singleton); 
+    Py_CLEAR(state->Mod_type); 
+    Py_CLEAR(state->Module_type); 
+    Py_CLEAR(state->Mult_singleton); 
+    Py_CLEAR(state->Mult_type); 
+    Py_CLEAR(state->Name_type); 
+    Py_CLEAR(state->NamedExpr_type); 
+    Py_CLEAR(state->Nonlocal_type); 
+    Py_CLEAR(state->NotEq_singleton); 
+    Py_CLEAR(state->NotEq_type); 
+    Py_CLEAR(state->NotIn_singleton); 
+    Py_CLEAR(state->NotIn_type); 
+    Py_CLEAR(state->Not_singleton); 
+    Py_CLEAR(state->Not_type); 
+    Py_CLEAR(state->Or_singleton); 
+    Py_CLEAR(state->Or_type); 
+    Py_CLEAR(state->Pass_type); 
+    Py_CLEAR(state->Pow_singleton); 
+    Py_CLEAR(state->Pow_type); 
+    Py_CLEAR(state->RShift_singleton); 
+    Py_CLEAR(state->RShift_type); 
+    Py_CLEAR(state->Raise_type); 
+    Py_CLEAR(state->Return_type); 
+    Py_CLEAR(state->SetComp_type); 
+    Py_CLEAR(state->Set_type); 
+    Py_CLEAR(state->Slice_type); 
+    Py_CLEAR(state->Starred_type); 
+    Py_CLEAR(state->Store_singleton); 
+    Py_CLEAR(state->Store_type); 
+    Py_CLEAR(state->Sub_singleton); 
+    Py_CLEAR(state->Sub_type); 
+    Py_CLEAR(state->Subscript_type); 
+    Py_CLEAR(state->Try_type); 
+    Py_CLEAR(state->Tuple_type); 
+    Py_CLEAR(state->TypeIgnore_type); 
+    Py_CLEAR(state->UAdd_singleton); 
+    Py_CLEAR(state->UAdd_type); 
+    Py_CLEAR(state->USub_singleton); 
+    Py_CLEAR(state->USub_type); 
+    Py_CLEAR(state->UnaryOp_type); 
+    Py_CLEAR(state->While_type); 
+    Py_CLEAR(state->With_type); 
+    Py_CLEAR(state->YieldFrom_type); 
+    Py_CLEAR(state->Yield_type); 
+    Py_CLEAR(state->__dict__); 
+    Py_CLEAR(state->__doc__); 
+    Py_CLEAR(state->__module__); 
+    Py_CLEAR(state->_attributes); 
+    Py_CLEAR(state->_fields); 
+    Py_CLEAR(state->alias_type); 
+    Py_CLEAR(state->annotation); 
+    Py_CLEAR(state->arg); 
+    Py_CLEAR(state->arg_type); 
+    Py_CLEAR(state->args); 
+    Py_CLEAR(state->argtypes); 
+    Py_CLEAR(state->arguments_type); 
+    Py_CLEAR(state->asname); 
+    Py_CLEAR(state->ast); 
+    Py_CLEAR(state->attr); 
+    Py_CLEAR(state->bases); 
+    Py_CLEAR(state->body); 
+    Py_CLEAR(state->boolop_type); 
+    Py_CLEAR(state->cause); 
+    Py_CLEAR(state->cmpop_type); 
+    Py_CLEAR(state->col_offset); 
+    Py_CLEAR(state->comparators); 
+    Py_CLEAR(state->comprehension_type); 
+    Py_CLEAR(state->context_expr); 
+    Py_CLEAR(state->conversion); 
+    Py_CLEAR(state->ctx); 
+    Py_CLEAR(state->decorator_list); 
+    Py_CLEAR(state->defaults); 
+    Py_CLEAR(state->elt); 
+    Py_CLEAR(state->elts); 
+    Py_CLEAR(state->end_col_offset); 
+    Py_CLEAR(state->end_lineno); 
+    Py_CLEAR(state->exc); 
+    Py_CLEAR(state->excepthandler_type); 
+    Py_CLEAR(state->expr_context_type); 
+    Py_CLEAR(state->expr_type); 
+    Py_CLEAR(state->finalbody); 
+    Py_CLEAR(state->format_spec); 
+    Py_CLEAR(state->func); 
+    Py_CLEAR(state->generators); 
+    Py_CLEAR(state->handlers); 
+    Py_CLEAR(state->id); 
+    Py_CLEAR(state->ifs); 
+    Py_CLEAR(state->is_async); 
+    Py_CLEAR(state->items); 
+    Py_CLEAR(state->iter); 
+    Py_CLEAR(state->key); 
+    Py_CLEAR(state->keys); 
+    Py_CLEAR(state->keyword_type); 
+    Py_CLEAR(state->keywords); 
+    Py_CLEAR(state->kind); 
+    Py_CLEAR(state->kw_defaults); 
+    Py_CLEAR(state->kwarg); 
+    Py_CLEAR(state->kwonlyargs); 
+    Py_CLEAR(state->left); 
+    Py_CLEAR(state->level); 
+    Py_CLEAR(state->lineno); 
+    Py_CLEAR(state->lower); 
+    Py_CLEAR(state->mod_type); 
+    Py_CLEAR(state->module); 
+    Py_CLEAR(state->msg); 
+    Py_CLEAR(state->name); 
+    Py_CLEAR(state->names); 
+    Py_CLEAR(state->op); 
+    Py_CLEAR(state->operand); 
+    Py_CLEAR(state->operator_type); 
+    Py_CLEAR(state->ops); 
+    Py_CLEAR(state->optional_vars); 
+    Py_CLEAR(state->orelse); 
+    Py_CLEAR(state->posonlyargs); 
+    Py_CLEAR(state->returns); 
+    Py_CLEAR(state->right); 
+    Py_CLEAR(state->simple); 
+    Py_CLEAR(state->slice); 
+    Py_CLEAR(state->step); 
+    Py_CLEAR(state->stmt_type); 
+    Py_CLEAR(state->tag); 
+    Py_CLEAR(state->target); 
+    Py_CLEAR(state->targets); 
+    Py_CLEAR(state->test); 
+    Py_CLEAR(state->type); 
+    Py_CLEAR(state->type_comment); 
+    Py_CLEAR(state->type_ignore_type); 
+    Py_CLEAR(state->type_ignores); 
+    Py_CLEAR(state->unaryop_type); 
+    Py_CLEAR(state->upper); 
+    Py_CLEAR(state->value); 
+    Py_CLEAR(state->values); 
+    Py_CLEAR(state->vararg); 
+    Py_CLEAR(state->withitem_type); 
+ 
+    state->initialized = 0; 
+} 
+ 
+static int init_identifiers(astmodulestate *state) 
+{ 
+    if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0; 
+    if ((state->__doc__ = PyUnicode_InternFromString("__doc__")) == NULL) return 0; 
+    if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0; 
+    if ((state->_attributes = PyUnicode_InternFromString("_attributes")) == NULL) return 0; 
+    if ((state->_fields = PyUnicode_InternFromString("_fields")) == NULL) return 0; 
+    if ((state->annotation = PyUnicode_InternFromString("annotation")) == NULL) return 0; 
+    if ((state->arg = PyUnicode_InternFromString("arg")) == NULL) return 0; 
+    if ((state->args = PyUnicode_InternFromString("args")) == NULL) return 0; 
+    if ((state->argtypes = PyUnicode_InternFromString("argtypes")) == NULL) return 0; 
+    if ((state->asname = PyUnicode_InternFromString("asname")) == NULL) return 0; 
+    if ((state->ast = PyUnicode_InternFromString("ast")) == NULL) return 0; 
+    if ((state->attr = PyUnicode_InternFromString("attr")) == NULL) return 0; 
+    if ((state->bases = PyUnicode_InternFromString("bases")) == NULL) return 0; 
+    if ((state->body = PyUnicode_InternFromString("body")) == NULL) return 0; 
+    if ((state->cause = PyUnicode_InternFromString("cause")) == NULL) return 0; 
+    if ((state->col_offset = PyUnicode_InternFromString("col_offset")) == NULL) return 0; 
+    if ((state->comparators = PyUnicode_InternFromString("comparators")) == NULL) return 0; 
+    if ((state->context_expr = PyUnicode_InternFromString("context_expr")) == NULL) return 0; 
+    if ((state->conversion = PyUnicode_InternFromString("conversion")) == NULL) return 0; 
+    if ((state->ctx = PyUnicode_InternFromString("ctx")) == NULL) return 0; 
+    if ((state->decorator_list = PyUnicode_InternFromString("decorator_list")) == NULL) return 0; 
+    if ((state->defaults = PyUnicode_InternFromString("defaults")) == NULL) return 0; 
+    if ((state->elt = PyUnicode_InternFromString("elt")) == NULL) return 0; 
+    if ((state->elts = PyUnicode_InternFromString("elts")) == NULL) return 0; 
+    if ((state->end_col_offset = PyUnicode_InternFromString("end_col_offset")) == NULL) return 0; 
+    if ((state->end_lineno = PyUnicode_InternFromString("end_lineno")) == NULL) return 0; 
+    if ((state->exc = PyUnicode_InternFromString("exc")) == NULL) return 0; 
+    if ((state->finalbody = PyUnicode_InternFromString("finalbody")) == NULL) return 0; 
+    if ((state->format_spec = PyUnicode_InternFromString("format_spec")) == NULL) return 0; 
+    if ((state->func = PyUnicode_InternFromString("func")) == NULL) return 0; 
+    if ((state->generators = PyUnicode_InternFromString("generators")) == NULL) return 0; 
+    if ((state->handlers = PyUnicode_InternFromString("handlers")) == NULL) return 0; 
+    if ((state->id = PyUnicode_InternFromString("id")) == NULL) return 0; 
+    if ((state->ifs = PyUnicode_InternFromString("ifs")) == NULL) return 0; 
+    if ((state->is_async = PyUnicode_InternFromString("is_async")) == NULL) return 0; 
+    if ((state->items = PyUnicode_InternFromString("items")) == NULL) return 0; 
+    if ((state->iter = PyUnicode_InternFromString("iter")) == NULL) return 0; 
+    if ((state->key = PyUnicode_InternFromString("key")) == NULL) return 0; 
+    if ((state->keys = PyUnicode_InternFromString("keys")) == NULL) return 0; 
+    if ((state->keywords = PyUnicode_InternFromString("keywords")) == NULL) return 0; 
+    if ((state->kind = PyUnicode_InternFromString("kind")) == NULL) return 0; 
+    if ((state->kw_defaults = PyUnicode_InternFromString("kw_defaults")) == NULL) return 0; 
+    if ((state->kwarg = PyUnicode_InternFromString("kwarg")) == NULL) return 0; 
+    if ((state->kwonlyargs = PyUnicode_InternFromString("kwonlyargs")) == NULL) return 0; 
+    if ((state->left = PyUnicode_InternFromString("left")) == NULL) return 0; 
+    if ((state->level = PyUnicode_InternFromString("level")) == NULL) return 0; 
+    if ((state->lineno = PyUnicode_InternFromString("lineno")) == NULL) return 0; 
+    if ((state->lower = PyUnicode_InternFromString("lower")) == NULL) return 0; 
+    if ((state->module = PyUnicode_InternFromString("module")) == NULL) return 0; 
+    if ((state->msg = PyUnicode_InternFromString("msg")) == NULL) return 0; 
+    if ((state->name = PyUnicode_InternFromString("name")) == NULL) return 0; 
+    if ((state->names = PyUnicode_InternFromString("names")) == NULL) return 0; 
+    if ((state->op = PyUnicode_InternFromString("op")) == NULL) return 0; 
+    if ((state->operand = PyUnicode_InternFromString("operand")) == NULL) return 0; 
+    if ((state->ops = PyUnicode_InternFromString("ops")) == NULL) return 0; 
+    if ((state->optional_vars = PyUnicode_InternFromString("optional_vars")) == NULL) return 0; 
+    if ((state->orelse = PyUnicode_InternFromString("orelse")) == NULL) return 0; 
+    if ((state->posonlyargs = PyUnicode_InternFromString("posonlyargs")) == NULL) return 0; 
+    if ((state->returns = PyUnicode_InternFromString("returns")) == NULL) return 0; 
+    if ((state->right = PyUnicode_InternFromString("right")) == NULL) return 0; 
+    if ((state->simple = PyUnicode_InternFromString("simple")) == NULL) return 0; 
+    if ((state->slice = PyUnicode_InternFromString("slice")) == NULL) return 0; 
+    if ((state->step = PyUnicode_InternFromString("step")) == NULL) return 0; 
+    if ((state->tag = PyUnicode_InternFromString("tag")) == NULL) return 0; 
+    if ((state->target = PyUnicode_InternFromString("target")) == NULL) return 0; 
+    if ((state->targets = PyUnicode_InternFromString("targets")) == NULL) return 0; 
+    if ((state->test = PyUnicode_InternFromString("test")) == NULL) return 0; 
+    if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0; 
+    if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0; 
+    if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0; 
+    if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0; 
+    if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0; 
+    if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0; 
+    if ((state->vararg = PyUnicode_InternFromString("vararg")) == NULL) return 0; 
+    return 1; 
+}; 
+ 
+static PyObject* ast2obj_mod(astmodulestate *state, void*); 
+static const char * const Module_fields[]={ 
     "body",
-    "type_ignores",
+    "type_ignores", 
 };
-static const char * const Interactive_fields[]={
+static const char * const Interactive_fields[]={ 
     "body",
 };
-static const char * const Expression_fields[]={
+static const char * const Expression_fields[]={ 
     "body",
 };
-static const char * const FunctionType_fields[]={
-    "argtypes",
-    "returns",
-};
-static const char * const stmt_attributes[] = {
+static const char * const FunctionType_fields[]={ 
+    "argtypes", 
+    "returns", 
+}; 
+static const char * const stmt_attributes[] = { 
     "lineno",
     "col_offset",
-    "end_lineno",
-    "end_col_offset",
+    "end_lineno", 
+    "end_col_offset", 
 };
-static PyObject* ast2obj_stmt(astmodulestate *state, void*);
-static const char * const FunctionDef_fields[]={
+static PyObject* ast2obj_stmt(astmodulestate *state, void*); 
+static const char * const FunctionDef_fields[]={ 
     "name",
     "args",
     "body",
     "decorator_list",
     "returns",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const AsyncFunctionDef_fields[]={
+static const char * const AsyncFunctionDef_fields[]={ 
     "name",
     "args",
     "body",
     "decorator_list",
     "returns",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const ClassDef_fields[]={
+static const char * const ClassDef_fields[]={ 
     "name",
     "bases",
     "keywords",
     "body",
     "decorator_list",
 };
-static const char * const Return_fields[]={
+static const char * const Return_fields[]={ 
     "value",
 };
-static const char * const Delete_fields[]={
+static const char * const Delete_fields[]={ 
     "targets",
 };
-static const char * const Assign_fields[]={
+static const char * const Assign_fields[]={ 
     "targets",
     "value",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const AugAssign_fields[]={
+static const char * const AugAssign_fields[]={ 
     "target",
     "op",
     "value",
 };
-static const char * const AnnAssign_fields[]={
+static const char * const AnnAssign_fields[]={ 
     "target",
     "annotation",
     "value",
     "simple",
 };
-static const char * const For_fields[]={
+static const char * const For_fields[]={ 
     "target",
     "iter",
     "body",
     "orelse",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const AsyncFor_fields[]={
+static const char * const AsyncFor_fields[]={ 
     "target",
     "iter",
     "body",
     "orelse",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const While_fields[]={
+static const char * const While_fields[]={ 
     "test",
     "body",
     "orelse",
 };
-static const char * const If_fields[]={
+static const char * const If_fields[]={ 
     "test",
     "body",
     "orelse",
 };
-static const char * const With_fields[]={
+static const char * const With_fields[]={ 
     "items",
     "body",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const AsyncWith_fields[]={
+static const char * const AsyncWith_fields[]={ 
     "items",
     "body",
-    "type_comment",
+    "type_comment", 
 };
-static const char * const Raise_fields[]={
+static const char * const Raise_fields[]={ 
     "exc",
     "cause",
 };
-static const char * const Try_fields[]={
+static const char * const Try_fields[]={ 
     "body",
     "handlers",
     "orelse",
     "finalbody",
 };
-static const char * const Assert_fields[]={
+static const char * const Assert_fields[]={ 
     "test",
     "msg",
 };
-static const char * const Import_fields[]={
+static const char * const Import_fields[]={ 
     "names",
 };
-static const char * const ImportFrom_fields[]={
+static const char * const ImportFrom_fields[]={ 
     "module",
     "names",
     "level",
 };
-static const char * const Global_fields[]={
+static const char * const Global_fields[]={ 
     "names",
 };
-static const char * const Nonlocal_fields[]={
+static const char * const Nonlocal_fields[]={ 
     "names",
 };
-static const char * const Expr_fields[]={
+static const char * const Expr_fields[]={ 
     "value",
 };
-static const char * const expr_attributes[] = {
+static const char * const expr_attributes[] = { 
     "lineno",
     "col_offset",
-    "end_lineno",
-    "end_col_offset",
+    "end_lineno", 
+    "end_col_offset", 
 };
-static PyObject* ast2obj_expr(astmodulestate *state, void*);
-static const char * const BoolOp_fields[]={
+static PyObject* ast2obj_expr(astmodulestate *state, void*); 
+static const char * const BoolOp_fields[]={ 
     "op",
     "values",
 };
-static const char * const NamedExpr_fields[]={
-    "target",
-    "value",
-};
-static const char * const BinOp_fields[]={
+static const char * const NamedExpr_fields[]={ 
+    "target", 
+    "value", 
+}; 
+static const char * const BinOp_fields[]={ 
     "left",
     "op",
     "right",
 };
-static const char * const UnaryOp_fields[]={
+static const char * const UnaryOp_fields[]={ 
     "op",
     "operand",
 };
-static const char * const Lambda_fields[]={
+static const char * const Lambda_fields[]={ 
     "args",
     "body",
 };
-static const char * const IfExp_fields[]={
+static const char * const IfExp_fields[]={ 
     "test",
     "body",
     "orelse",
 };
-static const char * const Dict_fields[]={
+static const char * const Dict_fields[]={ 
     "keys",
     "values",
 };
-static const char * const Set_fields[]={
+static const char * const Set_fields[]={ 
     "elts",
 };
-static const char * const ListComp_fields[]={
+static const char * const ListComp_fields[]={ 
     "elt",
     "generators",
 };
-static const char * const SetComp_fields[]={
+static const char * const SetComp_fields[]={ 
     "elt",
     "generators",
 };
-static const char * const DictComp_fields[]={
+static const char * const DictComp_fields[]={ 
     "key",
     "value",
     "generators",
 };
-static const char * const GeneratorExp_fields[]={
+static const char * const GeneratorExp_fields[]={ 
     "elt",
     "generators",
 };
-static const char * const Await_fields[]={
+static const char * const Await_fields[]={ 
     "value",
 };
-static const char * const Yield_fields[]={
+static const char * const Yield_fields[]={ 
     "value",
 };
-static const char * const YieldFrom_fields[]={
+static const char * const YieldFrom_fields[]={ 
     "value",
 };
-static const char * const Compare_fields[]={
+static const char * const Compare_fields[]={ 
     "left",
     "ops",
     "comparators",
 };
-static const char * const Call_fields[]={
+static const char * const Call_fields[]={ 
     "func",
     "args",
     "keywords",
 };
-static const char * const FormattedValue_fields[]={
+static const char * const FormattedValue_fields[]={ 
     "value",
     "conversion",
     "format_spec",
 };
-static const char * const JoinedStr_fields[]={
+static const char * const JoinedStr_fields[]={ 
     "values",
 };
-static const char * const Constant_fields[]={
+static const char * const Constant_fields[]={ 
     "value",
-    "kind",
+    "kind", 
 };
-static const char * const Attribute_fields[]={
+static const char * const Attribute_fields[]={ 
     "value",
     "attr",
     "ctx",
 };
-static const char * const Subscript_fields[]={
+static const char * const Subscript_fields[]={ 
     "value",
     "slice",
     "ctx",
 };
-static const char * const Starred_fields[]={
+static const char * const Starred_fields[]={ 
     "value",
     "ctx",
 };
-static const char * const Name_fields[]={
+static const char * const Name_fields[]={ 
     "id",
     "ctx",
 };
-static const char * const List_fields[]={
+static const char * const List_fields[]={ 
     "elts",
     "ctx",
 };
-static const char * const Tuple_fields[]={
+static const char * const Tuple_fields[]={ 
     "elts",
     "ctx",
 };
-static const char * const Slice_fields[]={
+static const char * const Slice_fields[]={ 
     "lower",
     "upper",
     "step",
 };
-static PyObject* ast2obj_expr_context(astmodulestate *state, expr_context_ty);
-static PyObject* ast2obj_boolop(astmodulestate *state, boolop_ty);
-static PyObject* ast2obj_operator(astmodulestate *state, operator_ty);
-static PyObject* ast2obj_unaryop(astmodulestate *state, unaryop_ty);
-static PyObject* ast2obj_cmpop(astmodulestate *state, cmpop_ty);
-static PyObject* ast2obj_comprehension(astmodulestate *state, void*);
-static const char * const comprehension_fields[]={
+static PyObject* ast2obj_expr_context(astmodulestate *state, expr_context_ty); 
+static PyObject* ast2obj_boolop(astmodulestate *state, boolop_ty); 
+static PyObject* ast2obj_operator(astmodulestate *state, operator_ty); 
+static PyObject* ast2obj_unaryop(astmodulestate *state, unaryop_ty); 
+static PyObject* ast2obj_cmpop(astmodulestate *state, cmpop_ty); 
+static PyObject* ast2obj_comprehension(astmodulestate *state, void*); 
+static const char * const comprehension_fields[]={ 
     "target",
     "iter",
     "ifs",
     "is_async",
 };
-static const char * const excepthandler_attributes[] = {
+static const char * const excepthandler_attributes[] = { 
     "lineno",
     "col_offset",
-    "end_lineno",
-    "end_col_offset",
+    "end_lineno", 
+    "end_col_offset", 
 };
-static PyObject* ast2obj_excepthandler(astmodulestate *state, void*);
-static const char * const ExceptHandler_fields[]={
+static PyObject* ast2obj_excepthandler(astmodulestate *state, void*); 
+static const char * const ExceptHandler_fields[]={ 
     "type",
     "name",
     "body",
 };
-static PyObject* ast2obj_arguments(astmodulestate *state, void*);
-static const char * const arguments_fields[]={
-    "posonlyargs",
+static PyObject* ast2obj_arguments(astmodulestate *state, void*); 
+static const char * const arguments_fields[]={ 
+    "posonlyargs", 
     "args",
     "vararg",
     "kwonlyargs",
@@ -834,44 +834,44 @@ static const char * const arguments_fields[]={
     "kwarg",
     "defaults",
 };
-static PyObject* ast2obj_arg(astmodulestate *state, void*);
-static const char * const arg_attributes[] = {
+static PyObject* ast2obj_arg(astmodulestate *state, void*); 
+static const char * const arg_attributes[] = { 
     "lineno",
     "col_offset",
-    "end_lineno",
-    "end_col_offset",
+    "end_lineno", 
+    "end_col_offset", 
 };
-static const char * const arg_fields[]={
+static const char * const arg_fields[]={ 
     "arg",
     "annotation",
-    "type_comment",
-};
-static PyObject* ast2obj_keyword(astmodulestate *state, void*);
-static const char * const keyword_attributes[] = {
-    "lineno",
-    "col_offset",
-    "end_lineno",
-    "end_col_offset",
+    "type_comment", 
 };
-static const char * const keyword_fields[]={
+static PyObject* ast2obj_keyword(astmodulestate *state, void*); 
+static const char * const keyword_attributes[] = { 
+    "lineno", 
+    "col_offset", 
+    "end_lineno", 
+    "end_col_offset", 
+}; 
+static const char * const keyword_fields[]={ 
     "arg",
     "value",
 };
-static PyObject* ast2obj_alias(astmodulestate *state, void*);
-static const char * const alias_fields[]={
+static PyObject* ast2obj_alias(astmodulestate *state, void*); 
+static const char * const alias_fields[]={ 
     "name",
     "asname",
 };
-static PyObject* ast2obj_withitem(astmodulestate *state, void*);
-static const char * const withitem_fields[]={
+static PyObject* ast2obj_withitem(astmodulestate *state, void*); 
+static const char * const withitem_fields[]={ 
     "context_expr",
     "optional_vars",
 };
-static PyObject* ast2obj_type_ignore(astmodulestate *state, void*);
-static const char * const TypeIgnore_fields[]={
-    "lineno",
-    "tag",
-};
+static PyObject* ast2obj_type_ignore(astmodulestate *state, void*); 
+static const char * const TypeIgnore_fields[]={ 
+    "lineno", 
+    "tag", 
+}; 
 
 
 
@@ -884,19 +884,19 @@ static void
 ast_dealloc(AST_object *self)
 {
     /* bpo-31095: UnTrack is needed before calling any callbacks */
-    PyTypeObject *tp = Py_TYPE(self);
+    PyTypeObject *tp = Py_TYPE(self); 
     PyObject_GC_UnTrack(self);
     Py_CLEAR(self->dict);
-    freefunc free_func = PyType_GetSlot(tp, Py_tp_free);
-    assert(free_func != NULL);
-    free_func(self);
-    Py_DECREF(tp);
+    freefunc free_func = PyType_GetSlot(tp, Py_tp_free); 
+    assert(free_func != NULL); 
+    free_func(self); 
+    Py_DECREF(tp); 
 }
 
 static int
 ast_traverse(AST_object *self, visitproc visit, void *arg)
 {
-    Py_VISIT(Py_TYPE(self));
+    Py_VISIT(Py_TYPE(self)); 
     Py_VISIT(self->dict);
     return 0;
 }
@@ -911,29 +911,29 @@ ast_clear(AST_object *self)
 static int
 ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
 {
-    astmodulestate *state = get_global_ast_state();
-    if (state == NULL) {
-        return -1;
-    }
-
+    astmodulestate *state = get_global_ast_state(); 
+    if (state == NULL) { 
+        return -1; 
+    } 
+ 
     Py_ssize_t i, numfields = 0;
     int res = -1;
     PyObject *key, *value, *fields;
-    if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_fields, &fields) < 0) {
+    if (_PyObject_LookupAttr((PyObject*)Py_TYPE(self), state->_fields, &fields) < 0) { 
         goto cleanup;
     }
     if (fields) {
         numfields = PySequence_Size(fields);
-        if (numfields == -1) {
+        if (numfields == -1) { 
             goto cleanup;
-        }
+        } 
     }
 
     res = 0; /* if no error occurs, this stays 0 to the end */
     if (numfields < PyTuple_GET_SIZE(args)) {
         PyErr_Format(PyExc_TypeError, "%.400s constructor takes at most "
                      "%zd positional argument%s",
-                     _PyType_Name(Py_TYPE(self)),
+                     _PyType_Name(Py_TYPE(self)), 
                      numfields, numfields == 1 ? "" : "s");
         res = -1;
         goto cleanup;
@@ -947,35 +947,35 @@ ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
         }
         res = PyObject_SetAttr(self, name, PyTuple_GET_ITEM(args, i));
         Py_DECREF(name);
-        if (res < 0) {
+        if (res < 0) { 
             goto cleanup;
-        }
+        } 
     }
     if (kw) {
         i = 0;  /* needed by PyDict_Next */
         while (PyDict_Next(kw, &i, &key, &value)) {
-            int contains = PySequence_Contains(fields, key);
-            if (contains == -1) {
-                res = -1;
-                goto cleanup;
-            } else if (contains == 1) {
-                Py_ssize_t p = PySequence_Index(fields, key);
-                if (p == -1) {
-                    res = -1;
-                    goto cleanup;
-                }
-                if (p < PyTuple_GET_SIZE(args)) {
-                    PyErr_Format(PyExc_TypeError,
-                        "%.400s got multiple values for argument '%U'",
-                        Py_TYPE(self)->tp_name, key);
-                    res = -1;
-                    goto cleanup;
-                }
-            }
+            int contains = PySequence_Contains(fields, key); 
+            if (contains == -1) { 
+                res = -1; 
+                goto cleanup; 
+            } else if (contains == 1) { 
+                Py_ssize_t p = PySequence_Index(fields, key); 
+                if (p == -1) { 
+                    res = -1; 
+                    goto cleanup; 
+                } 
+                if (p < PyTuple_GET_SIZE(args)) { 
+                    PyErr_Format(PyExc_TypeError, 
+                        "%.400s got multiple values for argument '%U'", 
+                        Py_TYPE(self)->tp_name, key); 
+                    res = -1; 
+                    goto cleanup; 
+                } 
+            } 
             res = PyObject_SetAttr(self, key, value);
-            if (res < 0) {
+            if (res < 0) { 
                 goto cleanup;
-            }
+            } 
         }
     }
   cleanup:
@@ -987,13 +987,13 @@ ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
 static PyObject *
 ast_type_reduce(PyObject *self, PyObject *unused)
 {
-    astmodulestate *state = get_global_ast_state();
-    if (state == NULL) {
-        return NULL;
-    }
-
+    astmodulestate *state = get_global_ast_state(); 
+    if (state == NULL) { 
+        return NULL; 
+    } 
+ 
     PyObject *dict;
-    if (_PyObject_LookupAttr(self, state->__dict__, &dict) < 0) {
+    if (_PyObject_LookupAttr(self, state->__dict__, &dict) < 0) { 
         return NULL;
     }
     if (dict) {
@@ -1002,11 +1002,11 @@ ast_type_reduce(PyObject *self, PyObject *unused)
     return Py_BuildValue("O()", Py_TYPE(self));
 }
 
-static PyMemberDef ast_type_members[] = {
-    {"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY},
-    {NULL}  /* Sentinel */
-};
-
+static PyMemberDef ast_type_members[] = { 
+    {"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY}, 
+    {NULL}  /* Sentinel */ 
+}; 
+ 
 static PyMethodDef ast_type_methods[] = {
     {"__reduce__", ast_type_reduce, METH_NOARGS, NULL},
     {NULL}
@@ -1017,79 +1017,79 @@ static PyGetSetDef ast_type_getsets[] = {
     {NULL}
 };
 
-static PyType_Slot AST_type_slots[] = {
-    {Py_tp_dealloc, ast_dealloc},
-    {Py_tp_getattro, PyObject_GenericGetAttr},
-    {Py_tp_setattro, PyObject_GenericSetAttr},
-    {Py_tp_traverse, ast_traverse},
-    {Py_tp_clear, ast_clear},
-    {Py_tp_members, ast_type_members},
-    {Py_tp_methods, ast_type_methods},
-    {Py_tp_getset, ast_type_getsets},
-    {Py_tp_init, ast_type_init},
-    {Py_tp_alloc, PyType_GenericAlloc},
-    {Py_tp_new, PyType_GenericNew},
-    {Py_tp_free, PyObject_GC_Del},
-    {0, 0},
-};
-
-static PyType_Spec AST_type_spec = {
-    "ast.AST",
+static PyType_Slot AST_type_slots[] = { 
+    {Py_tp_dealloc, ast_dealloc}, 
+    {Py_tp_getattro, PyObject_GenericGetAttr}, 
+    {Py_tp_setattro, PyObject_GenericSetAttr}, 
+    {Py_tp_traverse, ast_traverse}, 
+    {Py_tp_clear, ast_clear}, 
+    {Py_tp_members, ast_type_members}, 
+    {Py_tp_methods, ast_type_methods}, 
+    {Py_tp_getset, ast_type_getsets}, 
+    {Py_tp_init, ast_type_init}, 
+    {Py_tp_alloc, PyType_GenericAlloc}, 
+    {Py_tp_new, PyType_GenericNew}, 
+    {Py_tp_free, PyObject_GC_Del}, 
+    {0, 0}, 
+}; 
+ 
+static PyType_Spec AST_type_spec = { 
+    "ast.AST", 
     sizeof(AST_object),
     0,
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
-    AST_type_slots
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, 
+    AST_type_slots 
 };
 
-static PyObject *
-make_type(astmodulestate *state, const char *type, PyObject* base,
-          const char* const* fields, int num_fields, const char *doc)
+static PyObject * 
+make_type(astmodulestate *state, const char *type, PyObject* base, 
+          const char* const* fields, int num_fields, const char *doc) 
 {
     PyObject *fnames, *result;
     int i;
     fnames = PyTuple_New(num_fields);
     if (!fnames) return NULL;
     for (i = 0; i < num_fields; i++) {
-        PyObject *field = PyUnicode_InternFromString(fields[i]);
+        PyObject *field = PyUnicode_InternFromString(fields[i]); 
         if (!field) {
             Py_DECREF(fnames);
             return NULL;
         }
         PyTuple_SET_ITEM(fnames, i, field);
     }
-    result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOOOs}",
+    result = PyObject_CallFunction((PyObject*)&PyType_Type, "s(O){OOOOOs}", 
                     type, base,
-                    state->_fields, fnames,
-                    state->__module__,
-                    state->ast,
-                    state->__doc__, doc);
+                    state->_fields, fnames, 
+                    state->__module__, 
+                    state->ast, 
+                    state->__doc__, doc); 
     Py_DECREF(fnames);
-    return result;
+    return result; 
 }
 
-static int
-add_attributes(astmodulestate *state, PyObject *type, const char * const *attrs, int num_fields)
+static int 
+add_attributes(astmodulestate *state, PyObject *type, const char * const *attrs, int num_fields) 
 {
     int i, result;
     PyObject *s, *l = PyTuple_New(num_fields);
     if (!l)
         return 0;
     for (i = 0; i < num_fields; i++) {
-        s = PyUnicode_InternFromString(attrs[i]);
+        s = PyUnicode_InternFromString(attrs[i]); 
         if (!s) {
             Py_DECREF(l);
             return 0;
         }
         PyTuple_SET_ITEM(l, i, s);
     }
-    result = PyObject_SetAttr(type, state->_attributes, l) >= 0;
+    result = PyObject_SetAttr(type, state->_attributes, l) >= 0; 
     Py_DECREF(l);
     return result;
 }
 
 /* Conversion AST -> Python */
 
-static PyObject* ast2obj_list(astmodulestate *state, asdl_seq *seq, PyObject* (*func)(astmodulestate *state, void*))
+static PyObject* ast2obj_list(astmodulestate *state, asdl_seq *seq, PyObject* (*func)(astmodulestate *state, void*)) 
 {
     Py_ssize_t i, n = asdl_seq_LEN(seq);
     PyObject *result = PyList_New(n);
@@ -1097,7 +1097,7 @@ static PyObject* ast2obj_list(astmodulestate *state, asdl_seq *seq, PyObject* (*
     if (!result)
         return NULL;
     for (i = 0; i < n; i++) {
-        value = func(state, asdl_seq_GET(seq, i));
+        value = func(state, asdl_seq_GET(seq, i)); 
         if (!value) {
             Py_DECREF(result);
             return NULL;
@@ -1107,7 +1107,7 @@ static PyObject* ast2obj_list(astmodulestate *state, asdl_seq *seq, PyObject* (*
     return result;
 }
 
-static PyObject* ast2obj_object(astmodulestate *Py_UNUSED(state), void *o)
+static PyObject* ast2obj_object(astmodulestate *Py_UNUSED(state), void *o) 
 {
     if (!o)
         o = Py_None;
@@ -1118,14 +1118,14 @@ static PyObject* ast2obj_object(astmodulestate *Py_UNUSED(state), void *o)
 #define ast2obj_identifier ast2obj_object
 #define ast2obj_string ast2obj_object
 
-static PyObject* ast2obj_int(astmodulestate *Py_UNUSED(state), long b)
+static PyObject* ast2obj_int(astmodulestate *Py_UNUSED(state), long b) 
 {
     return PyLong_FromLong(b);
 }
 
 /* Conversion Python -> AST */
 
-static int obj2ast_object(astmodulestate *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena)
+static int obj2ast_object(astmodulestate *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena) 
 {
     if (obj == Py_None)
         obj = NULL;
@@ -1140,36 +1140,36 @@ static int obj2ast_object(astmodulestate *Py_UNUSED(state), PyObject* obj, PyObj
     return 0;
 }
 
-static int obj2ast_constant(astmodulestate *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena)
+static int obj2ast_constant(astmodulestate *Py_UNUSED(state), PyObject* obj, PyObject** out, PyArena* arena) 
 {
-    if (PyArena_AddPyObject(arena, obj) < 0) {
-        *out = NULL;
-        return -1;
+    if (PyArena_AddPyObject(arena, obj) < 0) { 
+        *out = NULL; 
+        return -1; 
     }
-    Py_INCREF(obj);
+    Py_INCREF(obj); 
     *out = obj;
     return 0;
 }
 
-static int obj2ast_identifier(astmodulestate *state, PyObject* obj, PyObject** out, PyArena* arena)
+static int obj2ast_identifier(astmodulestate *state, PyObject* obj, PyObject** out, PyArena* arena) 
 {
     if (!PyUnicode_CheckExact(obj) && obj != Py_None) {
         PyErr_SetString(PyExc_TypeError, "AST identifier must be of type str");
         return 1;
     }
-    return obj2ast_object(state, obj, out, arena);
+    return obj2ast_object(state, obj, out, arena); 
 }
 
-static int obj2ast_string(astmodulestate *state, PyObject* obj, PyObject** out, PyArena* arena)
+static int obj2ast_string(astmodulestate *state, PyObject* obj, PyObject** out, PyArena* arena) 
 {
     if (!PyUnicode_CheckExact(obj) && !PyBytes_CheckExact(obj)) {
         PyErr_SetString(PyExc_TypeError, "AST string must be of type str");
         return 1;
     }
-    return obj2ast_object(state, obj, out, arena);
+    return obj2ast_object(state, obj, out, arena); 
 }
 
-static int obj2ast_int(astmodulestate* Py_UNUSED(state), PyObject* obj, int* out, PyArena* arena)
+static int obj2ast_int(astmodulestate* Py_UNUSED(state), PyObject* obj, int* out, PyArena* arena) 
 {
     int i;
     if (!PyLong_Check(obj)) {
@@ -1184,13 +1184,13 @@ static int obj2ast_int(astmodulestate* Py_UNUSED(state), PyObject* obj, int* out
     return 0;
 }
 
-static int add_ast_fields(astmodulestate *state)
+static int add_ast_fields(astmodulestate *state) 
 {
-    PyObject *empty_tuple;
+    PyObject *empty_tuple; 
     empty_tuple = PyTuple_New(0);
     if (!empty_tuple ||
-        PyObject_SetAttrString(state->AST_type, "_fields", empty_tuple) < 0 ||
-        PyObject_SetAttrString(state->AST_type, "_attributes", empty_tuple) < 0) {
+        PyObject_SetAttrString(state->AST_type, "_fields", empty_tuple) < 0 || 
+        PyObject_SetAttrString(state->AST_type, "_attributes", empty_tuple) < 0) { 
         Py_XDECREF(empty_tuple);
         return -1;
     }
@@ -1199,720 +1199,720 @@ static int add_ast_fields(astmodulestate *state)
 }
 
 
-static int init_types(astmodulestate *state)
+static int init_types(astmodulestate *state) 
 {
-    if (state->initialized) return 1;
-    if (init_identifiers(state) < 0) return 0;
-    state->AST_type = PyType_FromSpec(&AST_type_spec);
-    if (!state->AST_type) return 0;
-    if (add_ast_fields(state) < 0) return 0;
-    state->mod_type = make_type(state, "mod", state->AST_type, NULL, 0,
-        "mod = Module(stmt* body, type_ignore* type_ignores)\n"
-        "    | Interactive(stmt* body)\n"
-        "    | Expression(expr body)\n"
-        "    | FunctionType(expr* argtypes, expr returns)");
-    if (!state->mod_type) return 0;
-    if (!add_attributes(state, state->mod_type, NULL, 0)) return 0;
-    state->Module_type = make_type(state, "Module", state->mod_type,
-                                   Module_fields, 2,
-        "Module(stmt* body, type_ignore* type_ignores)");
-    if (!state->Module_type) return 0;
-    state->Interactive_type = make_type(state, "Interactive", state->mod_type,
-                                        Interactive_fields, 1,
-        "Interactive(stmt* body)");
-    if (!state->Interactive_type) return 0;
-    state->Expression_type = make_type(state, "Expression", state->mod_type,
-                                       Expression_fields, 1,
-        "Expression(expr body)");
-    if (!state->Expression_type) return 0;
-    state->FunctionType_type = make_type(state, "FunctionType",
-                                         state->mod_type, FunctionType_fields,
-                                         2,
-        "FunctionType(expr* argtypes, expr returns)");
-    if (!state->FunctionType_type) return 0;
-    state->stmt_type = make_type(state, "stmt", state->AST_type, NULL, 0,
-        "stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
-        "     | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
-        "     | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n"
-        "     | Return(expr? value)\n"
-        "     | Delete(expr* targets)\n"
-        "     | Assign(expr* targets, expr value, string? type_comment)\n"
-        "     | AugAssign(expr target, operator op, expr value)\n"
-        "     | AnnAssign(expr target, expr annotation, expr? value, int simple)\n"
-        "     | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
-        "     | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
-        "     | While(expr test, stmt* body, stmt* orelse)\n"
-        "     | If(expr test, stmt* body, stmt* orelse)\n"
-        "     | With(withitem* items, stmt* body, string? type_comment)\n"
-        "     | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"
-        "     | Raise(expr? exc, expr? cause)\n"
-        "     | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"
-        "     | Assert(expr test, expr? msg)\n"
-        "     | Import(alias* names)\n"
-        "     | ImportFrom(identifier? module, alias* names, int? level)\n"
-        "     | Global(identifier* names)\n"
-        "     | Nonlocal(identifier* names)\n"
-        "     | Expr(expr value)\n"
-        "     | Pass\n"
-        "     | Break\n"
-        "     | Continue");
-    if (!state->stmt_type) return 0;
-    if (!add_attributes(state, state->stmt_type, stmt_attributes, 4)) return 0;
-    if (PyObject_SetAttr(state->stmt_type, state->end_lineno, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->stmt_type, state->end_col_offset, Py_None) ==
-        -1)
-        return 0;
-    state->FunctionDef_type = make_type(state, "FunctionDef", state->stmt_type,
-                                        FunctionDef_fields, 6,
-        "FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
-    if (!state->FunctionDef_type) return 0;
-    if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) ==
-        -1)
-        return 0;
-    if (PyObject_SetAttr(state->FunctionDef_type, state->type_comment, Py_None)
-        == -1)
-        return 0;
-    state->AsyncFunctionDef_type = make_type(state, "AsyncFunctionDef",
-                                             state->stmt_type,
-                                             AsyncFunctionDef_fields, 6,
-        "AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
-    if (!state->AsyncFunctionDef_type) return 0;
-    if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None)
-        == -1)
-        return 0;
-    if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->type_comment,
-        Py_None) == -1)
-        return 0;
-    state->ClassDef_type = make_type(state, "ClassDef", state->stmt_type,
-                                     ClassDef_fields, 5,
-        "ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)");
-    if (!state->ClassDef_type) return 0;
-    state->Return_type = make_type(state, "Return", state->stmt_type,
-                                   Return_fields, 1,
-        "Return(expr? value)");
-    if (!state->Return_type) return 0;
-    if (PyObject_SetAttr(state->Return_type, state->value, Py_None) == -1)
-        return 0;
-    state->Delete_type = make_type(state, "Delete", state->stmt_type,
-                                   Delete_fields, 1,
-        "Delete(expr* targets)");
-    if (!state->Delete_type) return 0;
-    state->Assign_type = make_type(state, "Assign", state->stmt_type,
-                                   Assign_fields, 3,
-        "Assign(expr* targets, expr value, string? type_comment)");
-    if (!state->Assign_type) return 0;
-    if (PyObject_SetAttr(state->Assign_type, state->type_comment, Py_None) ==
-        -1)
-        return 0;
-    state->AugAssign_type = make_type(state, "AugAssign", state->stmt_type,
-                                      AugAssign_fields, 3,
-        "AugAssign(expr target, operator op, expr value)");
-    if (!state->AugAssign_type) return 0;
-    state->AnnAssign_type = make_type(state, "AnnAssign", state->stmt_type,
-                                      AnnAssign_fields, 4,
-        "AnnAssign(expr target, expr annotation, expr? value, int simple)");
-    if (!state->AnnAssign_type) return 0;
-    if (PyObject_SetAttr(state->AnnAssign_type, state->value, Py_None) == -1)
-        return 0;
-    state->For_type = make_type(state, "For", state->stmt_type, For_fields, 5,
-        "For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
-    if (!state->For_type) return 0;
-    if (PyObject_SetAttr(state->For_type, state->type_comment, Py_None) == -1)
-        return 0;
-    state->AsyncFor_type = make_type(state, "AsyncFor", state->stmt_type,
-                                     AsyncFor_fields, 5,
-        "AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)");
-    if (!state->AsyncFor_type) return 0;
-    if (PyObject_SetAttr(state->AsyncFor_type, state->type_comment, Py_None) ==
-        -1)
-        return 0;
-    state->While_type = make_type(state, "While", state->stmt_type,
-                                  While_fields, 3,
-        "While(expr test, stmt* body, stmt* orelse)");
-    if (!state->While_type) return 0;
-    state->If_type = make_type(state, "If", state->stmt_type, If_fields, 3,
-        "If(expr test, stmt* body, stmt* orelse)");
-    if (!state->If_type) return 0;
-    state->With_type = make_type(state, "With", state->stmt_type, With_fields,
-                                 3,
-        "With(withitem* items, stmt* body, string? type_comment)");
-    if (!state->With_type) return 0;
-    if (PyObject_SetAttr(state->With_type, state->type_comment, Py_None) == -1)
-        return 0;
-    state->AsyncWith_type = make_type(state, "AsyncWith", state->stmt_type,
-                                      AsyncWith_fields, 3,
-        "AsyncWith(withitem* items, stmt* body, string? type_comment)");
-    if (!state->AsyncWith_type) return 0;
-    if (PyObject_SetAttr(state->AsyncWith_type, state->type_comment, Py_None)
-        == -1)
-        return 0;
-    state->Raise_type = make_type(state, "Raise", state->stmt_type,
-                                  Raise_fields, 2,
-        "Raise(expr? exc, expr? cause)");
-    if (!state->Raise_type) return 0;
-    if (PyObject_SetAttr(state->Raise_type, state->exc, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->Raise_type, state->cause, Py_None) == -1)
-        return 0;
-    state->Try_type = make_type(state, "Try", state->stmt_type, Try_fields, 4,
-        "Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)");
-    if (!state->Try_type) return 0;
-    state->Assert_type = make_type(state, "Assert", state->stmt_type,
-                                   Assert_fields, 2,
-        "Assert(expr test, expr? msg)");
-    if (!state->Assert_type) return 0;
-    if (PyObject_SetAttr(state->Assert_type, state->msg, Py_None) == -1)
-        return 0;
-    state->Import_type = make_type(state, "Import", state->stmt_type,
-                                   Import_fields, 1,
-        "Import(alias* names)");
-    if (!state->Import_type) return 0;
-    state->ImportFrom_type = make_type(state, "ImportFrom", state->stmt_type,
-                                       ImportFrom_fields, 3,
-        "ImportFrom(identifier? module, alias* names, int? level)");
-    if (!state->ImportFrom_type) return 0;
-    if (PyObject_SetAttr(state->ImportFrom_type, state->module, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->ImportFrom_type, state->level, Py_None) == -1)
-        return 0;
-    state->Global_type = make_type(state, "Global", state->stmt_type,
-                                   Global_fields, 1,
-        "Global(identifier* names)");
-    if (!state->Global_type) return 0;
-    state->Nonlocal_type = make_type(state, "Nonlocal", state->stmt_type,
-                                     Nonlocal_fields, 1,
-        "Nonlocal(identifier* names)");
-    if (!state->Nonlocal_type) return 0;
-    state->Expr_type = make_type(state, "Expr", state->stmt_type, Expr_fields,
-                                 1,
-        "Expr(expr value)");
-    if (!state->Expr_type) return 0;
-    state->Pass_type = make_type(state, "Pass", state->stmt_type, NULL, 0,
-        "Pass");
-    if (!state->Pass_type) return 0;
-    state->Break_type = make_type(state, "Break", state->stmt_type, NULL, 0,
-        "Break");
-    if (!state->Break_type) return 0;
-    state->Continue_type = make_type(state, "Continue", state->stmt_type, NULL,
-                                     0,
-        "Continue");
-    if (!state->Continue_type) return 0;
-    state->expr_type = make_type(state, "expr", state->AST_type, NULL, 0,
-        "expr = BoolOp(boolop op, expr* values)\n"
-        "     | NamedExpr(expr target, expr value)\n"
-        "     | BinOp(expr left, operator op, expr right)\n"
-        "     | UnaryOp(unaryop op, expr operand)\n"
-        "     | Lambda(arguments args, expr body)\n"
-        "     | IfExp(expr test, expr body, expr orelse)\n"
-        "     | Dict(expr* keys, expr* values)\n"
-        "     | Set(expr* elts)\n"
-        "     | ListComp(expr elt, comprehension* generators)\n"
-        "     | SetComp(expr elt, comprehension* generators)\n"
-        "     | DictComp(expr key, expr value, comprehension* generators)\n"
-        "     | GeneratorExp(expr elt, comprehension* generators)\n"
-        "     | Await(expr value)\n"
-        "     | Yield(expr? value)\n"
-        "     | YieldFrom(expr value)\n"
-        "     | Compare(expr left, cmpop* ops, expr* comparators)\n"
-        "     | Call(expr func, expr* args, keyword* keywords)\n"
-        "     | FormattedValue(expr value, int? conversion, expr? format_spec)\n"
-        "     | JoinedStr(expr* values)\n"
-        "     | Constant(constant value, string? kind)\n"
-        "     | Attribute(expr value, identifier attr, expr_context ctx)\n"
-        "     | Subscript(expr value, expr slice, expr_context ctx)\n"
-        "     | Starred(expr value, expr_context ctx)\n"
-        "     | Name(identifier id, expr_context ctx)\n"
-        "     | List(expr* elts, expr_context ctx)\n"
-        "     | Tuple(expr* elts, expr_context ctx)\n"
-        "     | Slice(expr? lower, expr? upper, expr? step)");
-    if (!state->expr_type) return 0;
-    if (!add_attributes(state, state->expr_type, expr_attributes, 4)) return 0;
-    if (PyObject_SetAttr(state->expr_type, state->end_lineno, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->expr_type, state->end_col_offset, Py_None) ==
-        -1)
-        return 0;
-    state->BoolOp_type = make_type(state, "BoolOp", state->expr_type,
-                                   BoolOp_fields, 2,
-        "BoolOp(boolop op, expr* values)");
-    if (!state->BoolOp_type) return 0;
-    state->NamedExpr_type = make_type(state, "NamedExpr", state->expr_type,
-                                      NamedExpr_fields, 2,
-        "NamedExpr(expr target, expr value)");
-    if (!state->NamedExpr_type) return 0;
-    state->BinOp_type = make_type(state, "BinOp", state->expr_type,
-                                  BinOp_fields, 3,
-        "BinOp(expr left, operator op, expr right)");
-    if (!state->BinOp_type) return 0;
-    state->UnaryOp_type = make_type(state, "UnaryOp", state->expr_type,
-                                    UnaryOp_fields, 2,
-        "UnaryOp(unaryop op, expr operand)");
-    if (!state->UnaryOp_type) return 0;
-    state->Lambda_type = make_type(state, "Lambda", state->expr_type,
-                                   Lambda_fields, 2,
-        "Lambda(arguments args, expr body)");
-    if (!state->Lambda_type) return 0;
-    state->IfExp_type = make_type(state, "IfExp", state->expr_type,
-                                  IfExp_fields, 3,
-        "IfExp(expr test, expr body, expr orelse)");
-    if (!state->IfExp_type) return 0;
-    state->Dict_type = make_type(state, "Dict", state->expr_type, Dict_fields,
-                                 2,
-        "Dict(expr* keys, expr* values)");
-    if (!state->Dict_type) return 0;
-    state->Set_type = make_type(state, "Set", state->expr_type, Set_fields, 1,
-        "Set(expr* elts)");
-    if (!state->Set_type) return 0;
-    state->ListComp_type = make_type(state, "ListComp", state->expr_type,
-                                     ListComp_fields, 2,
-        "ListComp(expr elt, comprehension* generators)");
-    if (!state->ListComp_type) return 0;
-    state->SetComp_type = make_type(state, "SetComp", state->expr_type,
-                                    SetComp_fields, 2,
-        "SetComp(expr elt, comprehension* generators)");
-    if (!state->SetComp_type) return 0;
-    state->DictComp_type = make_type(state, "DictComp", state->expr_type,
-                                     DictComp_fields, 3,
-        "DictComp(expr key, expr value, comprehension* generators)");
-    if (!state->DictComp_type) return 0;
-    state->GeneratorExp_type = make_type(state, "GeneratorExp",
-                                         state->expr_type, GeneratorExp_fields,
-                                         2,
-        "GeneratorExp(expr elt, comprehension* generators)");
-    if (!state->GeneratorExp_type) return 0;
-    state->Await_type = make_type(state, "Await", state->expr_type,
-                                  Await_fields, 1,
-        "Await(expr value)");
-    if (!state->Await_type) return 0;
-    state->Yield_type = make_type(state, "Yield", state->expr_type,
-                                  Yield_fields, 1,
-        "Yield(expr? value)");
-    if (!state->Yield_type) return 0;
-    if (PyObject_SetAttr(state->Yield_type, state->value, Py_None) == -1)
-        return 0;
-    state->YieldFrom_type = make_type(state, "YieldFrom", state->expr_type,
-                                      YieldFrom_fields, 1,
-        "YieldFrom(expr value)");
-    if (!state->YieldFrom_type) return 0;
-    state->Compare_type = make_type(state, "Compare", state->expr_type,
-                                    Compare_fields, 3,
-        "Compare(expr left, cmpop* ops, expr* comparators)");
-    if (!state->Compare_type) return 0;
-    state->Call_type = make_type(state, "Call", state->expr_type, Call_fields,
-                                 3,
-        "Call(expr func, expr* args, keyword* keywords)");
-    if (!state->Call_type) return 0;
-    state->FormattedValue_type = make_type(state, "FormattedValue",
-                                           state->expr_type,
-                                           FormattedValue_fields, 3,
-        "FormattedValue(expr value, int? conversion, expr? format_spec)");
-    if (!state->FormattedValue_type) return 0;
-    if (PyObject_SetAttr(state->FormattedValue_type, state->conversion,
-        Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->FormattedValue_type, state->format_spec,
-        Py_None) == -1)
-        return 0;
-    state->JoinedStr_type = make_type(state, "JoinedStr", state->expr_type,
-                                      JoinedStr_fields, 1,
-        "JoinedStr(expr* values)");
-    if (!state->JoinedStr_type) return 0;
-    state->Constant_type = make_type(state, "Constant", state->expr_type,
-                                     Constant_fields, 2,
-        "Constant(constant value, string? kind)");
-    if (!state->Constant_type) return 0;
-    if (PyObject_SetAttr(state->Constant_type, state->kind, Py_None) == -1)
-        return 0;
-    state->Attribute_type = make_type(state, "Attribute", state->expr_type,
-                                      Attribute_fields, 3,
-        "Attribute(expr value, identifier attr, expr_context ctx)");
-    if (!state->Attribute_type) return 0;
-    state->Subscript_type = make_type(state, "Subscript", state->expr_type,
-                                      Subscript_fields, 3,
-        "Subscript(expr value, expr slice, expr_context ctx)");
-    if (!state->Subscript_type) return 0;
-    state->Starred_type = make_type(state, "Starred", state->expr_type,
-                                    Starred_fields, 2,
-        "Starred(expr value, expr_context ctx)");
-    if (!state->Starred_type) return 0;
-    state->Name_type = make_type(state, "Name", state->expr_type, Name_fields,
-                                 2,
-        "Name(identifier id, expr_context ctx)");
-    if (!state->Name_type) return 0;
-    state->List_type = make_type(state, "List", state->expr_type, List_fields,
-                                 2,
-        "List(expr* elts, expr_context ctx)");
-    if (!state->List_type) return 0;
-    state->Tuple_type = make_type(state, "Tuple", state->expr_type,
-                                  Tuple_fields, 2,
-        "Tuple(expr* elts, expr_context ctx)");
-    if (!state->Tuple_type) return 0;
-    state->Slice_type = make_type(state, "Slice", state->expr_type,
-                                  Slice_fields, 3,
-        "Slice(expr? lower, expr? upper, expr? step)");
-    if (!state->Slice_type) return 0;
-    if (PyObject_SetAttr(state->Slice_type, state->lower, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->Slice_type, state->upper, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->Slice_type, state->step, Py_None) == -1)
-        return 0;
-    state->expr_context_type = make_type(state, "expr_context",
-                                         state->AST_type, NULL, 0,
-        "expr_context = Load | Store | Del");
-    if (!state->expr_context_type) return 0;
-    if (!add_attributes(state, state->expr_context_type, NULL, 0)) return 0;
-    state->Load_type = make_type(state, "Load", state->expr_context_type, NULL,
-                                 0,
-        "Load");
-    if (!state->Load_type) return 0;
-    state->Load_singleton = PyType_GenericNew((PyTypeObject *)state->Load_type,
-                                              NULL, NULL);
-    if (!state->Load_singleton) return 0;
-    state->Store_type = make_type(state, "Store", state->expr_context_type,
-                                  NULL, 0,
-        "Store");
-    if (!state->Store_type) return 0;
-    state->Store_singleton = PyType_GenericNew((PyTypeObject
-                                               *)state->Store_type, NULL, NULL);
-    if (!state->Store_singleton) return 0;
-    state->Del_type = make_type(state, "Del", state->expr_context_type, NULL, 0,
-        "Del");
-    if (!state->Del_type) return 0;
-    state->Del_singleton = PyType_GenericNew((PyTypeObject *)state->Del_type,
-                                             NULL, NULL);
-    if (!state->Del_singleton) return 0;
-    state->boolop_type = make_type(state, "boolop", state->AST_type, NULL, 0,
-        "boolop = And | Or");
-    if (!state->boolop_type) return 0;
-    if (!add_attributes(state, state->boolop_type, NULL, 0)) return 0;
-    state->And_type = make_type(state, "And", state->boolop_type, NULL, 0,
-        "And");
-    if (!state->And_type) return 0;
-    state->And_singleton = PyType_GenericNew((PyTypeObject *)state->And_type,
-                                             NULL, NULL);
-    if (!state->And_singleton) return 0;
-    state->Or_type = make_type(state, "Or", state->boolop_type, NULL, 0,
-        "Or");
-    if (!state->Or_type) return 0;
-    state->Or_singleton = PyType_GenericNew((PyTypeObject *)state->Or_type,
-                                            NULL, NULL);
-    if (!state->Or_singleton) return 0;
-    state->operator_type = make_type(state, "operator", state->AST_type, NULL,
-                                     0,
-        "operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv");
-    if (!state->operator_type) return 0;
-    if (!add_attributes(state, state->operator_type, NULL, 0)) return 0;
-    state->Add_type = make_type(state, "Add", state->operator_type, NULL, 0,
-        "Add");
-    if (!state->Add_type) return 0;
-    state->Add_singleton = PyType_GenericNew((PyTypeObject *)state->Add_type,
-                                             NULL, NULL);
-    if (!state->Add_singleton) return 0;
-    state->Sub_type = make_type(state, "Sub", state->operator_type, NULL, 0,
-        "Sub");
-    if (!state->Sub_type) return 0;
-    state->Sub_singleton = PyType_GenericNew((PyTypeObject *)state->Sub_type,
-                                             NULL, NULL);
-    if (!state->Sub_singleton) return 0;
-    state->Mult_type = make_type(state, "Mult", state->operator_type, NULL, 0,
-        "Mult");
-    if (!state->Mult_type) return 0;
-    state->Mult_singleton = PyType_GenericNew((PyTypeObject *)state->Mult_type,
-                                              NULL, NULL);
-    if (!state->Mult_singleton) return 0;
-    state->MatMult_type = make_type(state, "MatMult", state->operator_type,
-                                    NULL, 0,
-        "MatMult");
-    if (!state->MatMult_type) return 0;
-    state->MatMult_singleton = PyType_GenericNew((PyTypeObject
-                                                 *)state->MatMult_type, NULL,
-                                                 NULL);
-    if (!state->MatMult_singleton) return 0;
-    state->Div_type = make_type(state, "Div", state->operator_type, NULL, 0,
-        "Div");
-    if (!state->Div_type) return 0;
-    state->Div_singleton = PyType_GenericNew((PyTypeObject *)state->Div_type,
-                                             NULL, NULL);
-    if (!state->Div_singleton) return 0;
-    state->Mod_type = make_type(state, "Mod", state->operator_type, NULL, 0,
-        "Mod");
-    if (!state->Mod_type) return 0;
-    state->Mod_singleton = PyType_GenericNew((PyTypeObject *)state->Mod_type,
-                                             NULL, NULL);
-    if (!state->Mod_singleton) return 0;
-    state->Pow_type = make_type(state, "Pow", state->operator_type, NULL, 0,
-        "Pow");
-    if (!state->Pow_type) return 0;
-    state->Pow_singleton = PyType_GenericNew((PyTypeObject *)state->Pow_type,
-                                             NULL, NULL);
-    if (!state->Pow_singleton) return 0;
-    state->LShift_type = make_type(state, "LShift", state->operator_type, NULL,
-                                   0,
-        "LShift");
-    if (!state->LShift_type) return 0;
-    state->LShift_singleton = PyType_GenericNew((PyTypeObject
-                                                *)state->LShift_type, NULL,
-                                                NULL);
-    if (!state->LShift_singleton) return 0;
-    state->RShift_type = make_type(state, "RShift", state->operator_type, NULL,
-                                   0,
-        "RShift");
-    if (!state->RShift_type) return 0;
-    state->RShift_singleton = PyType_GenericNew((PyTypeObject
-                                                *)state->RShift_type, NULL,
-                                                NULL);
-    if (!state->RShift_singleton) return 0;
-    state->BitOr_type = make_type(state, "BitOr", state->operator_type, NULL, 0,
-        "BitOr");
-    if (!state->BitOr_type) return 0;
-    state->BitOr_singleton = PyType_GenericNew((PyTypeObject
-                                               *)state->BitOr_type, NULL, NULL);
-    if (!state->BitOr_singleton) return 0;
-    state->BitXor_type = make_type(state, "BitXor", state->operator_type, NULL,
-                                   0,
-        "BitXor");
-    if (!state->BitXor_type) return 0;
-    state->BitXor_singleton = PyType_GenericNew((PyTypeObject
-                                                *)state->BitXor_type, NULL,
-                                                NULL);
-    if (!state->BitXor_singleton) return 0;
-    state->BitAnd_type = make_type(state, "BitAnd", state->operator_type, NULL,
-                                   0,
-        "BitAnd");
-    if (!state->BitAnd_type) return 0;
-    state->BitAnd_singleton = PyType_GenericNew((PyTypeObject
-                                                *)state->BitAnd_type, NULL,
-                                                NULL);
-    if (!state->BitAnd_singleton) return 0;
-    state->FloorDiv_type = make_type(state, "FloorDiv", state->operator_type,
-                                     NULL, 0,
-        "FloorDiv");
-    if (!state->FloorDiv_type) return 0;
-    state->FloorDiv_singleton = PyType_GenericNew((PyTypeObject
-                                                  *)state->FloorDiv_type, NULL,
-                                                  NULL);
-    if (!state->FloorDiv_singleton) return 0;
-    state->unaryop_type = make_type(state, "unaryop", state->AST_type, NULL, 0,
-        "unaryop = Invert | Not | UAdd | USub");
-    if (!state->unaryop_type) return 0;
-    if (!add_attributes(state, state->unaryop_type, NULL, 0)) return 0;
-    state->Invert_type = make_type(state, "Invert", state->unaryop_type, NULL,
-                                   0,
-        "Invert");
-    if (!state->Invert_type) return 0;
-    state->Invert_singleton = PyType_GenericNew((PyTypeObject
-                                                *)state->Invert_type, NULL,
-                                                NULL);
-    if (!state->Invert_singleton) return 0;
-    state->Not_type = make_type(state, "Not", state->unaryop_type, NULL, 0,
-        "Not");
-    if (!state->Not_type) return 0;
-    state->Not_singleton = PyType_GenericNew((PyTypeObject *)state->Not_type,
-                                             NULL, NULL);
-    if (!state->Not_singleton) return 0;
-    state->UAdd_type = make_type(state, "UAdd", state->unaryop_type, NULL, 0,
-        "UAdd");
-    if (!state->UAdd_type) return 0;
-    state->UAdd_singleton = PyType_GenericNew((PyTypeObject *)state->UAdd_type,
-                                              NULL, NULL);
-    if (!state->UAdd_singleton) return 0;
-    state->USub_type = make_type(state, "USub", state->unaryop_type, NULL, 0,
-        "USub");
-    if (!state->USub_type) return 0;
-    state->USub_singleton = PyType_GenericNew((PyTypeObject *)state->USub_type,
-                                              NULL, NULL);
-    if (!state->USub_singleton) return 0;
-    state->cmpop_type = make_type(state, "cmpop", state->AST_type, NULL, 0,
-        "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn");
-    if (!state->cmpop_type) return 0;
-    if (!add_attributes(state, state->cmpop_type, NULL, 0)) return 0;
-    state->Eq_type = make_type(state, "Eq", state->cmpop_type, NULL, 0,
-        "Eq");
-    if (!state->Eq_type) return 0;
-    state->Eq_singleton = PyType_GenericNew((PyTypeObject *)state->Eq_type,
-                                            NULL, NULL);
-    if (!state->Eq_singleton) return 0;
-    state->NotEq_type = make_type(state, "NotEq", state->cmpop_type, NULL, 0,
-        "NotEq");
-    if (!state->NotEq_type) return 0;
-    state->NotEq_singleton = PyType_GenericNew((PyTypeObject
-                                               *)state->NotEq_type, NULL, NULL);
-    if (!state->NotEq_singleton) return 0;
-    state->Lt_type = make_type(state, "Lt", state->cmpop_type, NULL, 0,
-        "Lt");
-    if (!state->Lt_type) return 0;
-    state->Lt_singleton = PyType_GenericNew((PyTypeObject *)state->Lt_type,
-                                            NULL, NULL);
-    if (!state->Lt_singleton) return 0;
-    state->LtE_type = make_type(state, "LtE", state->cmpop_type, NULL, 0,
-        "LtE");
-    if (!state->LtE_type) return 0;
-    state->LtE_singleton = PyType_GenericNew((PyTypeObject *)state->LtE_type,
-                                             NULL, NULL);
-    if (!state->LtE_singleton) return 0;
-    state->Gt_type = make_type(state, "Gt", state->cmpop_type, NULL, 0,
-        "Gt");
-    if (!state->Gt_type) return 0;
-    state->Gt_singleton = PyType_GenericNew((PyTypeObject *)state->Gt_type,
-                                            NULL, NULL);
-    if (!state->Gt_singleton) return 0;
-    state->GtE_type = make_type(state, "GtE", state->cmpop_type, NULL, 0,
-        "GtE");
-    if (!state->GtE_type) return 0;
-    state->GtE_singleton = PyType_GenericNew((PyTypeObject *)state->GtE_type,
-                                             NULL, NULL);
-    if (!state->GtE_singleton) return 0;
-    state->Is_type = make_type(state, "Is", state->cmpop_type, NULL, 0,
-        "Is");
-    if (!state->Is_type) return 0;
-    state->Is_singleton = PyType_GenericNew((PyTypeObject *)state->Is_type,
-                                            NULL, NULL);
-    if (!state->Is_singleton) return 0;
-    state->IsNot_type = make_type(state, "IsNot", state->cmpop_type, NULL, 0,
-        "IsNot");
-    if (!state->IsNot_type) return 0;
-    state->IsNot_singleton = PyType_GenericNew((PyTypeObject
-                                               *)state->IsNot_type, NULL, NULL);
-    if (!state->IsNot_singleton) return 0;
-    state->In_type = make_type(state, "In", state->cmpop_type, NULL, 0,
-        "In");
-    if (!state->In_type) return 0;
-    state->In_singleton = PyType_GenericNew((PyTypeObject *)state->In_type,
-                                            NULL, NULL);
-    if (!state->In_singleton) return 0;
-    state->NotIn_type = make_type(state, "NotIn", state->cmpop_type, NULL, 0,
-        "NotIn");
-    if (!state->NotIn_type) return 0;
-    state->NotIn_singleton = PyType_GenericNew((PyTypeObject
-                                               *)state->NotIn_type, NULL, NULL);
-    if (!state->NotIn_singleton) return 0;
-    state->comprehension_type = make_type(state, "comprehension",
-                                          state->AST_type,
-                                          comprehension_fields, 4,
-        "comprehension(expr target, expr iter, expr* ifs, int is_async)");
-    if (!state->comprehension_type) return 0;
-    if (!add_attributes(state, state->comprehension_type, NULL, 0)) return 0;
-    state->excepthandler_type = make_type(state, "excepthandler",
-                                          state->AST_type, NULL, 0,
-        "excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)");
-    if (!state->excepthandler_type) return 0;
-    if (!add_attributes(state, state->excepthandler_type,
-        excepthandler_attributes, 4)) return 0;
-    if (PyObject_SetAttr(state->excepthandler_type, state->end_lineno, Py_None)
-        == -1)
-        return 0;
-    if (PyObject_SetAttr(state->excepthandler_type, state->end_col_offset,
-        Py_None) == -1)
-        return 0;
-    state->ExceptHandler_type = make_type(state, "ExceptHandler",
-                                          state->excepthandler_type,
-                                          ExceptHandler_fields, 3,
-        "ExceptHandler(expr? type, identifier? name, stmt* body)");
-    if (!state->ExceptHandler_type) return 0;
-    if (PyObject_SetAttr(state->ExceptHandler_type, state->type, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->ExceptHandler_type, state->name, Py_None) == -1)
-        return 0;
-    state->arguments_type = make_type(state, "arguments", state->AST_type,
-                                      arguments_fields, 7,
-        "arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults)");
-    if (!state->arguments_type) return 0;
-    if (!add_attributes(state, state->arguments_type, NULL, 0)) return 0;
-    if (PyObject_SetAttr(state->arguments_type, state->vararg, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->arguments_type, state->kwarg, Py_None) == -1)
-        return 0;
-    state->arg_type = make_type(state, "arg", state->AST_type, arg_fields, 3,
-        "arg(identifier arg, expr? annotation, string? type_comment)");
-    if (!state->arg_type) return 0;
-    if (!add_attributes(state, state->arg_type, arg_attributes, 4)) return 0;
-    if (PyObject_SetAttr(state->arg_type, state->annotation, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->arg_type, state->type_comment, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->arg_type, state->end_lineno, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->arg_type, state->end_col_offset, Py_None) == -1)
-        return 0;
-    state->keyword_type = make_type(state, "keyword", state->AST_type,
-                                    keyword_fields, 2,
-        "keyword(identifier? arg, expr value)");
-    if (!state->keyword_type) return 0;
-    if (!add_attributes(state, state->keyword_type, keyword_attributes, 4))
-        return 0;
-    if (PyObject_SetAttr(state->keyword_type, state->arg, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->keyword_type, state->end_lineno, Py_None) == -1)
-        return 0;
-    if (PyObject_SetAttr(state->keyword_type, state->end_col_offset, Py_None)
-        == -1)
-        return 0;
-    state->alias_type = make_type(state, "alias", state->AST_type,
-                                  alias_fields, 2,
-        "alias(identifier name, identifier? asname)");
-    if (!state->alias_type) return 0;
-    if (!add_attributes(state, state->alias_type, NULL, 0)) return 0;
-    if (PyObject_SetAttr(state->alias_type, state->asname, Py_None) == -1)
-        return 0;
-    state->withitem_type = make_type(state, "withitem", state->AST_type,
-                                     withitem_fields, 2,
-        "withitem(expr context_expr, expr? optional_vars)");
-    if (!state->withitem_type) return 0;
-    if (!add_attributes(state, state->withitem_type, NULL, 0)) return 0;
-    if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None)
-        == -1)
-        return 0;
-    state->type_ignore_type = make_type(state, "type_ignore", state->AST_type,
-                                        NULL, 0,
-        "type_ignore = TypeIgnore(int lineno, string tag)");
-    if (!state->type_ignore_type) return 0;
-    if (!add_attributes(state, state->type_ignore_type, NULL, 0)) return 0;
-    state->TypeIgnore_type = make_type(state, "TypeIgnore",
-                                       state->type_ignore_type,
-                                       TypeIgnore_fields, 2,
-        "TypeIgnore(int lineno, string tag)");
-    if (!state->TypeIgnore_type) return 0;
-    state->initialized = 1;
+    if (state->initialized) return 1; 
+    if (init_identifiers(state) < 0) return 0; 
+    state->AST_type = PyType_FromSpec(&AST_type_spec); 
+    if (!state->AST_type) return 0; 
+    if (add_ast_fields(state) < 0) return 0; 
+    state->mod_type = make_type(state, "mod", state->AST_type, NULL, 0, 
+        "mod = Module(stmt* body, type_ignore* type_ignores)\n" 
+        "    | Interactive(stmt* body)\n" 
+        "    | Expression(expr body)\n" 
+        "    | FunctionType(expr* argtypes, expr returns)"); 
+    if (!state->mod_type) return 0; 
+    if (!add_attributes(state, state->mod_type, NULL, 0)) return 0; 
+    state->Module_type = make_type(state, "Module", state->mod_type, 
+                                   Module_fields, 2, 
+        "Module(stmt* body, type_ignore* type_ignores)"); 
+    if (!state->Module_type) return 0; 
+    state->Interactive_type = make_type(state, "Interactive", state->mod_type, 
+                                        Interactive_fields, 1, 
+        "Interactive(stmt* body)"); 
+    if (!state->Interactive_type) return 0; 
+    state->Expression_type = make_type(state, "Expression", state->mod_type, 
+                                       Expression_fields, 1, 
+        "Expression(expr body)"); 
+    if (!state->Expression_type) return 0; 
+    state->FunctionType_type = make_type(state, "FunctionType", 
+                                         state->mod_type, FunctionType_fields, 
+                                         2, 
+        "FunctionType(expr* argtypes, expr returns)"); 
+    if (!state->FunctionType_type) return 0; 
+    state->stmt_type = make_type(state, "stmt", state->AST_type, NULL, 0, 
+        "stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n" 
+        "     | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n" 
+        "     | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n" 
+        "     | Return(expr? value)\n" 
+        "     | Delete(expr* targets)\n" 
+        "     | Assign(expr* targets, expr value, string? type_comment)\n" 
+        "     | AugAssign(expr target, operator op, expr value)\n" 
+        "     | AnnAssign(expr target, expr annotation, expr? value, int simple)\n" 
+        "     | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n" 
+        "     | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n" 
+        "     | While(expr test, stmt* body, stmt* orelse)\n" 
+        "     | If(expr test, stmt* body, stmt* orelse)\n" 
+        "     | With(withitem* items, stmt* body, string? type_comment)\n" 
+        "     | AsyncWith(withitem* items, stmt* body, string? type_comment)\n" 
+        "     | Raise(expr? exc, expr? cause)\n" 
+        "     | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n" 
+        "     | Assert(expr test, expr? msg)\n" 
+        "     | Import(alias* names)\n" 
+        "     | ImportFrom(identifier? module, alias* names, int? level)\n" 
+        "     | Global(identifier* names)\n" 
+        "     | Nonlocal(identifier* names)\n" 
+        "     | Expr(expr value)\n" 
+        "     | Pass\n" 
+        "     | Break\n" 
+        "     | Continue"); 
+    if (!state->stmt_type) return 0; 
+    if (!add_attributes(state, state->stmt_type, stmt_attributes, 4)) return 0; 
+    if (PyObject_SetAttr(state->stmt_type, state->end_lineno, Py_None) == -1) 
+        return 0;
+    if (PyObject_SetAttr(state->stmt_type, state->end_col_offset, Py_None) == 
+        -1) 
+        return 0; 
+    state->FunctionDef_type = make_type(state, "FunctionDef", state->stmt_type, 
+                                        FunctionDef_fields, 6, 
+        "FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)"); 
+    if (!state->FunctionDef_type) return 0; 
+    if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) == 
+        -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->FunctionDef_type, state->type_comment, Py_None) 
+        == -1) 
+        return 0; 
+    state->AsyncFunctionDef_type = make_type(state, "AsyncFunctionDef", 
+                                             state->stmt_type, 
+                                             AsyncFunctionDef_fields, 6, 
+        "AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)"); 
+    if (!state->AsyncFunctionDef_type) return 0; 
+    if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None) 
+        == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->type_comment, 
+        Py_None) == -1) 
+        return 0; 
+    state->ClassDef_type = make_type(state, "ClassDef", state->stmt_type, 
+                                     ClassDef_fields, 5, 
+        "ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)"); 
+    if (!state->ClassDef_type) return 0; 
+    state->Return_type = make_type(state, "Return", state->stmt_type, 
+                                   Return_fields, 1, 
+        "Return(expr? value)"); 
+    if (!state->Return_type) return 0; 
+    if (PyObject_SetAttr(state->Return_type, state->value, Py_None) == -1) 
+        return 0; 
+    state->Delete_type = make_type(state, "Delete", state->stmt_type, 
+                                   Delete_fields, 1, 
+        "Delete(expr* targets)"); 
+    if (!state->Delete_type) return 0; 
+    state->Assign_type = make_type(state, "Assign", state->stmt_type, 
+                                   Assign_fields, 3, 
+        "Assign(expr* targets, expr value, string? type_comment)"); 
+    if (!state->Assign_type) return 0; 
+    if (PyObject_SetAttr(state->Assign_type, state->type_comment, Py_None) == 
+        -1) 
+        return 0; 
+    state->AugAssign_type = make_type(state, "AugAssign", state->stmt_type, 
+                                      AugAssign_fields, 3, 
+        "AugAssign(expr target, operator op, expr value)"); 
+    if (!state->AugAssign_type) return 0; 
+    state->AnnAssign_type = make_type(state, "AnnAssign", state->stmt_type, 
+                                      AnnAssign_fields, 4, 
+        "AnnAssign(expr target, expr annotation, expr? value, int simple)"); 
+    if (!state->AnnAssign_type) return 0; 
+    if (PyObject_SetAttr(state->AnnAssign_type, state->value, Py_None) == -1) 
+        return 0; 
+    state->For_type = make_type(state, "For", state->stmt_type, For_fields, 5, 
+        "For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)"); 
+    if (!state->For_type) return 0; 
+    if (PyObject_SetAttr(state->For_type, state->type_comment, Py_None) == -1) 
+        return 0; 
+    state->AsyncFor_type = make_type(state, "AsyncFor", state->stmt_type, 
+                                     AsyncFor_fields, 5, 
+        "AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)"); 
+    if (!state->AsyncFor_type) return 0; 
+    if (PyObject_SetAttr(state->AsyncFor_type, state->type_comment, Py_None) == 
+        -1) 
+        return 0; 
+    state->While_type = make_type(state, "While", state->stmt_type, 
+                                  While_fields, 3, 
+        "While(expr test, stmt* body, stmt* orelse)"); 
+    if (!state->While_type) return 0; 
+    state->If_type = make_type(state, "If", state->stmt_type, If_fields, 3, 
+        "If(expr test, stmt* body, stmt* orelse)"); 
+    if (!state->If_type) return 0; 
+    state->With_type = make_type(state, "With", state->stmt_type, With_fields, 
+                                 3, 
+        "With(withitem* items, stmt* body, string? type_comment)"); 
+    if (!state->With_type) return 0; 
+    if (PyObject_SetAttr(state->With_type, state->type_comment, Py_None) == -1) 
+        return 0; 
+    state->AsyncWith_type = make_type(state, "AsyncWith", state->stmt_type, 
+                                      AsyncWith_fields, 3, 
+        "AsyncWith(withitem* items, stmt* body, string? type_comment)"); 
+    if (!state->AsyncWith_type) return 0; 
+    if (PyObject_SetAttr(state->AsyncWith_type, state->type_comment, Py_None) 
+        == -1) 
+        return 0; 
+    state->Raise_type = make_type(state, "Raise", state->stmt_type, 
+                                  Raise_fields, 2, 
+        "Raise(expr? exc, expr? cause)"); 
+    if (!state->Raise_type) return 0; 
+    if (PyObject_SetAttr(state->Raise_type, state->exc, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->Raise_type, state->cause, Py_None) == -1) 
+        return 0; 
+    state->Try_type = make_type(state, "Try", state->stmt_type, Try_fields, 4, 
+        "Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)"); 
+    if (!state->Try_type) return 0; 
+    state->Assert_type = make_type(state, "Assert", state->stmt_type, 
+                                   Assert_fields, 2, 
+        "Assert(expr test, expr? msg)"); 
+    if (!state->Assert_type) return 0; 
+    if (PyObject_SetAttr(state->Assert_type, state->msg, Py_None) == -1) 
+        return 0; 
+    state->Import_type = make_type(state, "Import", state->stmt_type, 
+                                   Import_fields, 1, 
+        "Import(alias* names)"); 
+    if (!state->Import_type) return 0; 
+    state->ImportFrom_type = make_type(state, "ImportFrom", state->stmt_type, 
+                                       ImportFrom_fields, 3, 
+        "ImportFrom(identifier? module, alias* names, int? level)"); 
+    if (!state->ImportFrom_type) return 0; 
+    if (PyObject_SetAttr(state->ImportFrom_type, state->module, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->ImportFrom_type, state->level, Py_None) == -1) 
+        return 0; 
+    state->Global_type = make_type(state, "Global", state->stmt_type, 
+                                   Global_fields, 1, 
+        "Global(identifier* names)"); 
+    if (!state->Global_type) return 0; 
+    state->Nonlocal_type = make_type(state, "Nonlocal", state->stmt_type, 
+                                     Nonlocal_fields, 1, 
+        "Nonlocal(identifier* names)"); 
+    if (!state->Nonlocal_type) return 0; 
+    state->Expr_type = make_type(state, "Expr", state->stmt_type, Expr_fields, 
+                                 1, 
+        "Expr(expr value)"); 
+    if (!state->Expr_type) return 0; 
+    state->Pass_type = make_type(state, "Pass", state->stmt_type, NULL, 0, 
+        "Pass"); 
+    if (!state->Pass_type) return 0; 
+    state->Break_type = make_type(state, "Break", state->stmt_type, NULL, 0, 
+        "Break"); 
+    if (!state->Break_type) return 0; 
+    state->Continue_type = make_type(state, "Continue", state->stmt_type, NULL, 
+                                     0, 
+        "Continue"); 
+    if (!state->Continue_type) return 0; 
+    state->expr_type = make_type(state, "expr", state->AST_type, NULL, 0, 
+        "expr = BoolOp(boolop op, expr* values)\n" 
+        "     | NamedExpr(expr target, expr value)\n" 
+        "     | BinOp(expr left, operator op, expr right)\n" 
+        "     | UnaryOp(unaryop op, expr operand)\n" 
+        "     | Lambda(arguments args, expr body)\n" 
+        "     | IfExp(expr test, expr body, expr orelse)\n" 
+        "     | Dict(expr* keys, expr* values)\n" 
+        "     | Set(expr* elts)\n" 
+        "     | ListComp(expr elt, comprehension* generators)\n" 
+        "     | SetComp(expr elt, comprehension* generators)\n" 
+        "     | DictComp(expr key, expr value, comprehension* generators)\n" 
+        "     | GeneratorExp(expr elt, comprehension* generators)\n" 
+        "     | Await(expr value)\n" 
+        "     | Yield(expr? value)\n" 
+        "     | YieldFrom(expr value)\n" 
+        "     | Compare(expr left, cmpop* ops, expr* comparators)\n" 
+        "     | Call(expr func, expr* args, keyword* keywords)\n" 
+        "     | FormattedValue(expr value, int? conversion, expr? format_spec)\n" 
+        "     | JoinedStr(expr* values)\n" 
+        "     | Constant(constant value, string? kind)\n" 
+        "     | Attribute(expr value, identifier attr, expr_context ctx)\n" 
+        "     | Subscript(expr value, expr slice, expr_context ctx)\n" 
+        "     | Starred(expr value, expr_context ctx)\n" 
+        "     | Name(identifier id, expr_context ctx)\n" 
+        "     | List(expr* elts, expr_context ctx)\n" 
+        "     | Tuple(expr* elts, expr_context ctx)\n" 
+        "     | Slice(expr? lower, expr? upper, expr? step)"); 
+    if (!state->expr_type) return 0; 
+    if (!add_attributes(state, state->expr_type, expr_attributes, 4)) return 0; 
+    if (PyObject_SetAttr(state->expr_type, state->end_lineno, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->expr_type, state->end_col_offset, Py_None) == 
+        -1) 
+        return 0; 
+    state->BoolOp_type = make_type(state, "BoolOp", state->expr_type, 
+                                   BoolOp_fields, 2, 
+        "BoolOp(boolop op, expr* values)"); 
+    if (!state->BoolOp_type) return 0; 
+    state->NamedExpr_type = make_type(state, "NamedExpr", state->expr_type, 
+                                      NamedExpr_fields, 2, 
+        "NamedExpr(expr target, expr value)"); 
+    if (!state->NamedExpr_type) return 0; 
+    state->BinOp_type = make_type(state, "BinOp", state->expr_type, 
+                                  BinOp_fields, 3, 
+        "BinOp(expr left, operator op, expr right)"); 
+    if (!state->BinOp_type) return 0; 
+    state->UnaryOp_type = make_type(state, "UnaryOp", state->expr_type, 
+                                    UnaryOp_fields, 2, 
+        "UnaryOp(unaryop op, expr operand)"); 
+    if (!state->UnaryOp_type) return 0; 
+    state->Lambda_type = make_type(state, "Lambda", state->expr_type, 
+                                   Lambda_fields, 2, 
+        "Lambda(arguments args, expr body)"); 
+    if (!state->Lambda_type) return 0; 
+    state->IfExp_type = make_type(state, "IfExp", state->expr_type, 
+                                  IfExp_fields, 3, 
+        "IfExp(expr test, expr body, expr orelse)"); 
+    if (!state->IfExp_type) return 0; 
+    state->Dict_type = make_type(state, "Dict", state->expr_type, Dict_fields, 
+                                 2, 
+        "Dict(expr* keys, expr* values)"); 
+    if (!state->Dict_type) return 0; 
+    state->Set_type = make_type(state, "Set", state->expr_type, Set_fields, 1, 
+        "Set(expr* elts)"); 
+    if (!state->Set_type) return 0; 
+    state->ListComp_type = make_type(state, "ListComp", state->expr_type, 
+                                     ListComp_fields, 2, 
+        "ListComp(expr elt, comprehension* generators)"); 
+    if (!state->ListComp_type) return 0; 
+    state->SetComp_type = make_type(state, "SetComp", state->expr_type, 
+                                    SetComp_fields, 2, 
+        "SetComp(expr elt, comprehension* generators)"); 
+    if (!state->SetComp_type) return 0; 
+    state->DictComp_type = make_type(state, "DictComp", state->expr_type, 
+                                     DictComp_fields, 3, 
+        "DictComp(expr key, expr value, comprehension* generators)"); 
+    if (!state->DictComp_type) return 0; 
+    state->GeneratorExp_type = make_type(state, "GeneratorExp", 
+                                         state->expr_type, GeneratorExp_fields, 
+                                         2, 
+        "GeneratorExp(expr elt, comprehension* generators)"); 
+    if (!state->GeneratorExp_type) return 0; 
+    state->Await_type = make_type(state, "Await", state->expr_type, 
+                                  Await_fields, 1, 
+        "Await(expr value)"); 
+    if (!state->Await_type) return 0; 
+    state->Yield_type = make_type(state, "Yield", state->expr_type, 
+                                  Yield_fields, 1, 
+        "Yield(expr? value)"); 
+    if (!state->Yield_type) return 0; 
+    if (PyObject_SetAttr(state->Yield_type, state->value, Py_None) == -1) 
+        return 0; 
+    state->YieldFrom_type = make_type(state, "YieldFrom", state->expr_type, 
+                                      YieldFrom_fields, 1, 
+        "YieldFrom(expr value)"); 
+    if (!state->YieldFrom_type) return 0; 
+    state->Compare_type = make_type(state, "Compare", state->expr_type, 
+                                    Compare_fields, 3, 
+        "Compare(expr left, cmpop* ops, expr* comparators)"); 
+    if (!state->Compare_type) return 0; 
+    state->Call_type = make_type(state, "Call", state->expr_type, Call_fields, 
+                                 3, 
+        "Call(expr func, expr* args, keyword* keywords)"); 
+    if (!state->Call_type) return 0; 
+    state->FormattedValue_type = make_type(state, "FormattedValue", 
+                                           state->expr_type, 
+                                           FormattedValue_fields, 3, 
+        "FormattedValue(expr value, int? conversion, expr? format_spec)"); 
+    if (!state->FormattedValue_type) return 0; 
+    if (PyObject_SetAttr(state->FormattedValue_type, state->conversion, 
+        Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->FormattedValue_type, state->format_spec, 
+        Py_None) == -1) 
+        return 0; 
+    state->JoinedStr_type = make_type(state, "JoinedStr", state->expr_type, 
+                                      JoinedStr_fields, 1, 
+        "JoinedStr(expr* values)"); 
+    if (!state->JoinedStr_type) return 0; 
+    state->Constant_type = make_type(state, "Constant", state->expr_type, 
+                                     Constant_fields, 2, 
+        "Constant(constant value, string? kind)"); 
+    if (!state->Constant_type) return 0; 
+    if (PyObject_SetAttr(state->Constant_type, state->kind, Py_None) == -1) 
+        return 0; 
+    state->Attribute_type = make_type(state, "Attribute", state->expr_type, 
+                                      Attribute_fields, 3, 
+        "Attribute(expr value, identifier attr, expr_context ctx)"); 
+    if (!state->Attribute_type) return 0; 
+    state->Subscript_type = make_type(state, "Subscript", state->expr_type, 
+                                      Subscript_fields, 3, 
+        "Subscript(expr value, expr slice, expr_context ctx)"); 
+    if (!state->Subscript_type) return 0; 
+    state->Starred_type = make_type(state, "Starred", state->expr_type, 
+                                    Starred_fields, 2, 
+        "Starred(expr value, expr_context ctx)"); 
+    if (!state->Starred_type) return 0; 
+    state->Name_type = make_type(state, "Name", state->expr_type, Name_fields, 
+                                 2, 
+        "Name(identifier id, expr_context ctx)"); 
+    if (!state->Name_type) return 0; 
+    state->List_type = make_type(state, "List", state->expr_type, List_fields, 
+                                 2, 
+        "List(expr* elts, expr_context ctx)"); 
+    if (!state->List_type) return 0; 
+    state->Tuple_type = make_type(state, "Tuple", state->expr_type, 
+                                  Tuple_fields, 2, 
+        "Tuple(expr* elts, expr_context ctx)"); 
+    if (!state->Tuple_type) return 0; 
+    state->Slice_type = make_type(state, "Slice", state->expr_type, 
+                                  Slice_fields, 3, 
+        "Slice(expr? lower, expr? upper, expr? step)"); 
+    if (!state->Slice_type) return 0; 
+    if (PyObject_SetAttr(state->Slice_type, state->lower, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->Slice_type, state->upper, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->Slice_type, state->step, Py_None) == -1) 
+        return 0; 
+    state->expr_context_type = make_type(state, "expr_context", 
+                                         state->AST_type, NULL, 0, 
+        "expr_context = Load | Store | Del"); 
+    if (!state->expr_context_type) return 0; 
+    if (!add_attributes(state, state->expr_context_type, NULL, 0)) return 0; 
+    state->Load_type = make_type(state, "Load", state->expr_context_type, NULL, 
+                                 0, 
+        "Load"); 
+    if (!state->Load_type) return 0; 
+    state->Load_singleton = PyType_GenericNew((PyTypeObject *)state->Load_type, 
+                                              NULL, NULL); 
+    if (!state->Load_singleton) return 0; 
+    state->Store_type = make_type(state, "Store", state->expr_context_type, 
+                                  NULL, 0, 
+        "Store"); 
+    if (!state->Store_type) return 0; 
+    state->Store_singleton = PyType_GenericNew((PyTypeObject 
+                                               *)state->Store_type, NULL, NULL); 
+    if (!state->Store_singleton) return 0; 
+    state->Del_type = make_type(state, "Del", state->expr_context_type, NULL, 0, 
+        "Del"); 
+    if (!state->Del_type) return 0; 
+    state->Del_singleton = PyType_GenericNew((PyTypeObject *)state->Del_type, 
+                                             NULL, NULL); 
+    if (!state->Del_singleton) return 0; 
+    state->boolop_type = make_type(state, "boolop", state->AST_type, NULL, 0, 
+        "boolop = And | Or"); 
+    if (!state->boolop_type) return 0; 
+    if (!add_attributes(state, state->boolop_type, NULL, 0)) return 0; 
+    state->And_type = make_type(state, "And", state->boolop_type, NULL, 0, 
+        "And"); 
+    if (!state->And_type) return 0; 
+    state->And_singleton = PyType_GenericNew((PyTypeObject *)state->And_type, 
+                                             NULL, NULL); 
+    if (!state->And_singleton) return 0; 
+    state->Or_type = make_type(state, "Or", state->boolop_type, NULL, 0, 
+        "Or"); 
+    if (!state->Or_type) return 0; 
+    state->Or_singleton = PyType_GenericNew((PyTypeObject *)state->Or_type, 
+                                            NULL, NULL); 
+    if (!state->Or_singleton) return 0; 
+    state->operator_type = make_type(state, "operator", state->AST_type, NULL, 
+                                     0, 
+        "operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv"); 
+    if (!state->operator_type) return 0; 
+    if (!add_attributes(state, state->operator_type, NULL, 0)) return 0; 
+    state->Add_type = make_type(state, "Add", state->operator_type, NULL, 0, 
+        "Add"); 
+    if (!state->Add_type) return 0; 
+    state->Add_singleton = PyType_GenericNew((PyTypeObject *)state->Add_type, 
+                                             NULL, NULL); 
+    if (!state->Add_singleton) return 0; 
+    state->Sub_type = make_type(state, "Sub", state->operator_type, NULL, 0, 
+        "Sub"); 
+    if (!state->Sub_type) return 0; 
+    state->Sub_singleton = PyType_GenericNew((PyTypeObject *)state->Sub_type, 
+                                             NULL, NULL); 
+    if (!state->Sub_singleton) return 0; 
+    state->Mult_type = make_type(state, "Mult", state->operator_type, NULL, 0, 
+        "Mult"); 
+    if (!state->Mult_type) return 0; 
+    state->Mult_singleton = PyType_GenericNew((PyTypeObject *)state->Mult_type, 
+                                              NULL, NULL); 
+    if (!state->Mult_singleton) return 0; 
+    state->MatMult_type = make_type(state, "MatMult", state->operator_type, 
+                                    NULL, 0, 
+        "MatMult"); 
+    if (!state->MatMult_type) return 0; 
+    state->MatMult_singleton = PyType_GenericNew((PyTypeObject 
+                                                 *)state->MatMult_type, NULL, 
+                                                 NULL); 
+    if (!state->MatMult_singleton) return 0; 
+    state->Div_type = make_type(state, "Div", state->operator_type, NULL, 0, 
+        "Div"); 
+    if (!state->Div_type) return 0; 
+    state->Div_singleton = PyType_GenericNew((PyTypeObject *)state->Div_type, 
+                                             NULL, NULL); 
+    if (!state->Div_singleton) return 0; 
+    state->Mod_type = make_type(state, "Mod", state->operator_type, NULL, 0, 
+        "Mod"); 
+    if (!state->Mod_type) return 0; 
+    state->Mod_singleton = PyType_GenericNew((PyTypeObject *)state->Mod_type, 
+                                             NULL, NULL); 
+    if (!state->Mod_singleton) return 0; 
+    state->Pow_type = make_type(state, "Pow", state->operator_type, NULL, 0, 
+        "Pow"); 
+    if (!state->Pow_type) return 0; 
+    state->Pow_singleton = PyType_GenericNew((PyTypeObject *)state->Pow_type, 
+                                             NULL, NULL); 
+    if (!state->Pow_singleton) return 0; 
+    state->LShift_type = make_type(state, "LShift", state->operator_type, NULL, 
+                                   0, 
+        "LShift"); 
+    if (!state->LShift_type) return 0; 
+    state->LShift_singleton = PyType_GenericNew((PyTypeObject 
+                                                *)state->LShift_type, NULL, 
+                                                NULL); 
+    if (!state->LShift_singleton) return 0; 
+    state->RShift_type = make_type(state, "RShift", state->operator_type, NULL, 
+                                   0, 
+        "RShift"); 
+    if (!state->RShift_type) return 0; 
+    state->RShift_singleton = PyType_GenericNew((PyTypeObject 
+                                                *)state->RShift_type, NULL, 
+                                                NULL); 
+    if (!state->RShift_singleton) return 0; 
+    state->BitOr_type = make_type(state, "BitOr", state->operator_type, NULL, 0, 
+        "BitOr"); 
+    if (!state->BitOr_type) return 0; 
+    state->BitOr_singleton = PyType_GenericNew((PyTypeObject 
+                                               *)state->BitOr_type, NULL, NULL); 
+    if (!state->BitOr_singleton) return 0; 
+    state->BitXor_type = make_type(state, "BitXor", state->operator_type, NULL, 
+                                   0, 
+        "BitXor"); 
+    if (!state->BitXor_type) return 0; 
+    state->BitXor_singleton = PyType_GenericNew((PyTypeObject 
+                                                *)state->BitXor_type, NULL, 
+                                                NULL); 
+    if (!state->BitXor_singleton) return 0; 
+    state->BitAnd_type = make_type(state, "BitAnd", state->operator_type, NULL, 
+                                   0, 
+        "BitAnd"); 
+    if (!state->BitAnd_type) return 0; 
+    state->BitAnd_singleton = PyType_GenericNew((PyTypeObject 
+                                                *)state->BitAnd_type, NULL, 
+                                                NULL); 
+    if (!state->BitAnd_singleton) return 0; 
+    state->FloorDiv_type = make_type(state, "FloorDiv", state->operator_type, 
+                                     NULL, 0, 
+        "FloorDiv"); 
+    if (!state->FloorDiv_type) return 0; 
+    state->FloorDiv_singleton = PyType_GenericNew((PyTypeObject 
+                                                  *)state->FloorDiv_type, NULL, 
+                                                  NULL); 
+    if (!state->FloorDiv_singleton) return 0; 
+    state->unaryop_type = make_type(state, "unaryop", state->AST_type, NULL, 0, 
+        "unaryop = Invert | Not | UAdd | USub"); 
+    if (!state->unaryop_type) return 0; 
+    if (!add_attributes(state, state->unaryop_type, NULL, 0)) return 0; 
+    state->Invert_type = make_type(state, "Invert", state->unaryop_type, NULL, 
+                                   0, 
+        "Invert"); 
+    if (!state->Invert_type) return 0; 
+    state->Invert_singleton = PyType_GenericNew((PyTypeObject 
+                                                *)state->Invert_type, NULL, 
+                                                NULL); 
+    if (!state->Invert_singleton) return 0; 
+    state->Not_type = make_type(state, "Not", state->unaryop_type, NULL, 0, 
+        "Not"); 
+    if (!state->Not_type) return 0; 
+    state->Not_singleton = PyType_GenericNew((PyTypeObject *)state->Not_type, 
+                                             NULL, NULL); 
+    if (!state->Not_singleton) return 0; 
+    state->UAdd_type = make_type(state, "UAdd", state->unaryop_type, NULL, 0, 
+        "UAdd"); 
+    if (!state->UAdd_type) return 0; 
+    state->UAdd_singleton = PyType_GenericNew((PyTypeObject *)state->UAdd_type, 
+                                              NULL, NULL); 
+    if (!state->UAdd_singleton) return 0; 
+    state->USub_type = make_type(state, "USub", state->unaryop_type, NULL, 0, 
+        "USub"); 
+    if (!state->USub_type) return 0; 
+    state->USub_singleton = PyType_GenericNew((PyTypeObject *)state->USub_type, 
+                                              NULL, NULL); 
+    if (!state->USub_singleton) return 0; 
+    state->cmpop_type = make_type(state, "cmpop", state->AST_type, NULL, 0, 
+        "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn"); 
+    if (!state->cmpop_type) return 0; 
+    if (!add_attributes(state, state->cmpop_type, NULL, 0)) return 0; 
+    state->Eq_type = make_type(state, "Eq", state->cmpop_type, NULL, 0, 
+        "Eq"); 
+    if (!state->Eq_type) return 0; 
+    state->Eq_singleton = PyType_GenericNew((PyTypeObject *)state->Eq_type, 
+                                            NULL, NULL); 
+    if (!state->Eq_singleton) return 0; 
+    state->NotEq_type = make_type(state, "NotEq", state->cmpop_type, NULL, 0, 
+        "NotEq"); 
+    if (!state->NotEq_type) return 0; 
+    state->NotEq_singleton = PyType_GenericNew((PyTypeObject 
+                                               *)state->NotEq_type, NULL, NULL); 
+    if (!state->NotEq_singleton) return 0; 
+    state->Lt_type = make_type(state, "Lt", state->cmpop_type, NULL, 0, 
+        "Lt"); 
+    if (!state->Lt_type) return 0; 
+    state->Lt_singleton = PyType_GenericNew((PyTypeObject *)state->Lt_type, 
+                                            NULL, NULL); 
+    if (!state->Lt_singleton) return 0; 
+    state->LtE_type = make_type(state, "LtE", state->cmpop_type, NULL, 0, 
+        "LtE"); 
+    if (!state->LtE_type) return 0; 
+    state->LtE_singleton = PyType_GenericNew((PyTypeObject *)state->LtE_type, 
+                                             NULL, NULL); 
+    if (!state->LtE_singleton) return 0; 
+    state->Gt_type = make_type(state, "Gt", state->cmpop_type, NULL, 0, 
+        "Gt"); 
+    if (!state->Gt_type) return 0; 
+    state->Gt_singleton = PyType_GenericNew((PyTypeObject *)state->Gt_type, 
+                                            NULL, NULL); 
+    if (!state->Gt_singleton) return 0; 
+    state->GtE_type = make_type(state, "GtE", state->cmpop_type, NULL, 0, 
+        "GtE"); 
+    if (!state->GtE_type) return 0; 
+    state->GtE_singleton = PyType_GenericNew((PyTypeObject *)state->GtE_type, 
+                                             NULL, NULL); 
+    if (!state->GtE_singleton) return 0; 
+    state->Is_type = make_type(state, "Is", state->cmpop_type, NULL, 0, 
+        "Is"); 
+    if (!state->Is_type) return 0; 
+    state->Is_singleton = PyType_GenericNew((PyTypeObject *)state->Is_type, 
+                                            NULL, NULL); 
+    if (!state->Is_singleton) return 0; 
+    state->IsNot_type = make_type(state, "IsNot", state->cmpop_type, NULL, 0, 
+        "IsNot"); 
+    if (!state->IsNot_type) return 0; 
+    state->IsNot_singleton = PyType_GenericNew((PyTypeObject 
+                                               *)state->IsNot_type, NULL, NULL); 
+    if (!state->IsNot_singleton) return 0; 
+    state->In_type = make_type(state, "In", state->cmpop_type, NULL, 0, 
+        "In"); 
+    if (!state->In_type) return 0; 
+    state->In_singleton = PyType_GenericNew((PyTypeObject *)state->In_type, 
+                                            NULL, NULL); 
+    if (!state->In_singleton) return 0; 
+    state->NotIn_type = make_type(state, "NotIn", state->cmpop_type, NULL, 0, 
+        "NotIn"); 
+    if (!state->NotIn_type) return 0; 
+    state->NotIn_singleton = PyType_GenericNew((PyTypeObject 
+                                               *)state->NotIn_type, NULL, NULL); 
+    if (!state->NotIn_singleton) return 0; 
+    state->comprehension_type = make_type(state, "comprehension", 
+                                          state->AST_type, 
+                                          comprehension_fields, 4, 
+        "comprehension(expr target, expr iter, expr* ifs, int is_async)"); 
+    if (!state->comprehension_type) return 0; 
+    if (!add_attributes(state, state->comprehension_type, NULL, 0)) return 0; 
+    state->excepthandler_type = make_type(state, "excepthandler", 
+                                          state->AST_type, NULL, 0, 
+        "excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)"); 
+    if (!state->excepthandler_type) return 0; 
+    if (!add_attributes(state, state->excepthandler_type, 
+        excepthandler_attributes, 4)) return 0; 
+    if (PyObject_SetAttr(state->excepthandler_type, state->end_lineno, Py_None) 
+        == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->excepthandler_type, state->end_col_offset, 
+        Py_None) == -1) 
+        return 0; 
+    state->ExceptHandler_type = make_type(state, "ExceptHandler", 
+                                          state->excepthandler_type, 
+                                          ExceptHandler_fields, 3, 
+        "ExceptHandler(expr? type, identifier? name, stmt* body)"); 
+    if (!state->ExceptHandler_type) return 0; 
+    if (PyObject_SetAttr(state->ExceptHandler_type, state->type, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->ExceptHandler_type, state->name, Py_None) == -1) 
+        return 0; 
+    state->arguments_type = make_type(state, "arguments", state->AST_type, 
+                                      arguments_fields, 7, 
+        "arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults)"); 
+    if (!state->arguments_type) return 0; 
+    if (!add_attributes(state, state->arguments_type, NULL, 0)) return 0; 
+    if (PyObject_SetAttr(state->arguments_type, state->vararg, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->arguments_type, state->kwarg, Py_None) == -1) 
+        return 0; 
+    state->arg_type = make_type(state, "arg", state->AST_type, arg_fields, 3, 
+        "arg(identifier arg, expr? annotation, string? type_comment)"); 
+    if (!state->arg_type) return 0; 
+    if (!add_attributes(state, state->arg_type, arg_attributes, 4)) return 0; 
+    if (PyObject_SetAttr(state->arg_type, state->annotation, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->arg_type, state->type_comment, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->arg_type, state->end_lineno, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->arg_type, state->end_col_offset, Py_None) == -1) 
+        return 0; 
+    state->keyword_type = make_type(state, "keyword", state->AST_type, 
+                                    keyword_fields, 2, 
+        "keyword(identifier? arg, expr value)"); 
+    if (!state->keyword_type) return 0; 
+    if (!add_attributes(state, state->keyword_type, keyword_attributes, 4)) 
+        return 0; 
+    if (PyObject_SetAttr(state->keyword_type, state->arg, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->keyword_type, state->end_lineno, Py_None) == -1) 
+        return 0; 
+    if (PyObject_SetAttr(state->keyword_type, state->end_col_offset, Py_None) 
+        == -1) 
+        return 0; 
+    state->alias_type = make_type(state, "alias", state->AST_type, 
+                                  alias_fields, 2, 
+        "alias(identifier name, identifier? asname)"); 
+    if (!state->alias_type) return 0; 
+    if (!add_attributes(state, state->alias_type, NULL, 0)) return 0; 
+    if (PyObject_SetAttr(state->alias_type, state->asname, Py_None) == -1) 
+        return 0; 
+    state->withitem_type = make_type(state, "withitem", state->AST_type, 
+                                     withitem_fields, 2, 
+        "withitem(expr context_expr, expr? optional_vars)"); 
+    if (!state->withitem_type) return 0; 
+    if (!add_attributes(state, state->withitem_type, NULL, 0)) return 0; 
+    if (PyObject_SetAttr(state->withitem_type, state->optional_vars, Py_None) 
+        == -1) 
+        return 0; 
+    state->type_ignore_type = make_type(state, "type_ignore", state->AST_type, 
+                                        NULL, 0, 
+        "type_ignore = TypeIgnore(int lineno, string tag)"); 
+    if (!state->type_ignore_type) return 0; 
+    if (!add_attributes(state, state->type_ignore_type, NULL, 0)) return 0; 
+    state->TypeIgnore_type = make_type(state, "TypeIgnore", 
+                                       state->type_ignore_type, 
+                                       TypeIgnore_fields, 2, 
+        "TypeIgnore(int lineno, string tag)"); 
+    if (!state->TypeIgnore_type) return 0; 
+    state->initialized = 1; 
     return 1;
 }
 
-static int obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out,
-                       PyArena* arena);
-static int obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out,
-                        PyArena* arena);
-static int obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out,
-                        PyArena* arena);
-static int obj2ast_expr_context(astmodulestate *state, PyObject* obj,
-                                expr_context_ty* out, PyArena* arena);
-static int obj2ast_boolop(astmodulestate *state, PyObject* obj, boolop_ty* out,
-                          PyArena* arena);
-static int obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty*
-                            out, PyArena* arena);
-static int obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty*
-                           out, PyArena* arena);
-static int obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out,
-                         PyArena* arena);
-static int obj2ast_comprehension(astmodulestate *state, PyObject* obj,
-                                 comprehension_ty* out, PyArena* arena);
-static int obj2ast_excepthandler(astmodulestate *state, PyObject* obj,
-                                 excepthandler_ty* out, PyArena* arena);
-static int obj2ast_arguments(astmodulestate *state, PyObject* obj,
-                             arguments_ty* out, PyArena* arena);
-static int obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out,
-                       PyArena* arena);
-static int obj2ast_keyword(astmodulestate *state, PyObject* obj, keyword_ty*
-                           out, PyArena* arena);
-static int obj2ast_alias(astmodulestate *state, PyObject* obj, alias_ty* out,
-                         PyArena* arena);
-static int obj2ast_withitem(astmodulestate *state, PyObject* obj, withitem_ty*
-                            out, PyArena* arena);
-static int obj2ast_type_ignore(astmodulestate *state, PyObject* obj,
-                               type_ignore_ty* out, PyArena* arena);
+static int obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, 
+                       PyArena* arena); 
+static int obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, 
+                        PyArena* arena); 
+static int obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, 
+                        PyArena* arena); 
+static int obj2ast_expr_context(astmodulestate *state, PyObject* obj, 
+                                expr_context_ty* out, PyArena* arena); 
+static int obj2ast_boolop(astmodulestate *state, PyObject* obj, boolop_ty* out, 
+                          PyArena* arena); 
+static int obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* 
+                            out, PyArena* arena); 
+static int obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* 
+                           out, PyArena* arena); 
+static int obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, 
+                         PyArena* arena); 
+static int obj2ast_comprehension(astmodulestate *state, PyObject* obj, 
+                                 comprehension_ty* out, PyArena* arena); 
+static int obj2ast_excepthandler(astmodulestate *state, PyObject* obj, 
+                                 excepthandler_ty* out, PyArena* arena); 
+static int obj2ast_arguments(astmodulestate *state, PyObject* obj, 
+                             arguments_ty* out, PyArena* arena); 
+static int obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, 
+                       PyArena* arena); 
+static int obj2ast_keyword(astmodulestate *state, PyObject* obj, keyword_ty* 
+                           out, PyArena* arena); 
+static int obj2ast_alias(astmodulestate *state, PyObject* obj, alias_ty* out, 
+                         PyArena* arena); 
+static int obj2ast_withitem(astmodulestate *state, PyObject* obj, withitem_ty* 
+                            out, PyArena* arena); 
+static int obj2ast_type_ignore(astmodulestate *state, PyObject* obj, 
+                               type_ignore_ty* out, PyArena* arena); 
 
 mod_ty
-Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena)
+Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena) 
 {
     mod_ty p;
     p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -1920,7 +1920,7 @@ Module(asdl_seq * body, asdl_seq * type_ignores, PyArena *arena)
         return NULL;
     p->kind = Module_kind;
     p->v.Module.body = body;
-    p->v.Module.type_ignores = type_ignores;
+    p->v.Module.type_ignores = type_ignores; 
     return p;
 }
 
@@ -1942,7 +1942,7 @@ Expression(expr_ty body, PyArena *arena)
     mod_ty p;
     if (!body) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'body' is required for Expression");
+                        "field 'body' is required for Expression"); 
         return NULL;
     }
     p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -1954,37 +1954,37 @@ Expression(expr_ty body, PyArena *arena)
 }
 
 mod_ty
-FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena)
-{
-    mod_ty p;
-    if (!returns) {
-        PyErr_SetString(PyExc_ValueError,
-                        "field 'returns' is required for FunctionType");
-        return NULL;
-    }
-    p = (mod_ty)PyArena_Malloc(arena, sizeof(*p));
-    if (!p)
-        return NULL;
-    p->kind = FunctionType_kind;
-    p->v.FunctionType.argtypes = argtypes;
-    p->v.FunctionType.returns = returns;
-    return p;
-}
-
+FunctionType(asdl_seq * argtypes, expr_ty returns, PyArena *arena) 
+{ 
+    mod_ty p; 
+    if (!returns) { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "field 'returns' is required for FunctionType"); 
+        return NULL; 
+    } 
+    p = (mod_ty)PyArena_Malloc(arena, sizeof(*p)); 
+    if (!p) 
+        return NULL; 
+    p->kind = FunctionType_kind; 
+    p->v.FunctionType.argtypes = argtypes; 
+    p->v.FunctionType.returns = returns; 
+    return p; 
+} 
+ 
 stmt_ty
 FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
-            decorator_list, expr_ty returns, string type_comment, int lineno,
-            int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+            decorator_list, expr_ty returns, string type_comment, int lineno, 
+            int col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!name) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'name' is required for FunctionDef");
+                        "field 'name' is required for FunctionDef"); 
         return NULL;
     }
     if (!args) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'args' is required for FunctionDef");
+                        "field 'args' is required for FunctionDef"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -1996,29 +1996,29 @@ FunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq *
     p->v.FunctionDef.body = body;
     p->v.FunctionDef.decorator_list = decorator_list;
     p->v.FunctionDef.returns = returns;
-    p->v.FunctionDef.type_comment = type_comment;
+    p->v.FunctionDef.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq
-                 * decorator_list, expr_ty returns, string type_comment, int
-                 lineno, int col_offset, int end_lineno, int end_col_offset,
+                 * decorator_list, expr_ty returns, string type_comment, int 
+                 lineno, int col_offset, int end_lineno, int end_col_offset, 
                  PyArena *arena)
 {
     stmt_ty p;
     if (!name) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'name' is required for AsyncFunctionDef");
+                        "field 'name' is required for AsyncFunctionDef"); 
         return NULL;
     }
     if (!args) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'args' is required for AsyncFunctionDef");
+                        "field 'args' is required for AsyncFunctionDef"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2030,23 +2030,23 @@ AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * body, asdl_seq
     p->v.AsyncFunctionDef.body = body;
     p->v.AsyncFunctionDef.decorator_list = decorator_list;
     p->v.AsyncFunctionDef.returns = returns;
-    p->v.AsyncFunctionDef.type_comment = type_comment;
+    p->v.AsyncFunctionDef.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, asdl_seq *
-         body, asdl_seq * decorator_list, int lineno, int col_offset, int
-         end_lineno, int end_col_offset, PyArena *arena)
+         body, asdl_seq * decorator_list, int lineno, int col_offset, int 
+         end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!name) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'name' is required for ClassDef");
+                        "field 'name' is required for ClassDef"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2060,14 +2060,14 @@ ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, asdl_seq *
     p->v.ClassDef.decorator_list = decorator_list;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Return(expr_ty value, int lineno, int col_offset, int end_lineno, int
-       end_col_offset, PyArena *arena)
+Return(expr_ty value, int lineno, int col_offset, int end_lineno, int 
+       end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2077,14 +2077,14 @@ Return(expr_ty value, int lineno, int col_offset, int end_lineno, int
     p->v.Return.value = value;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Delete(asdl_seq * targets, int lineno, int col_offset, int end_lineno, int
-       end_col_offset, PyArena *arena)
+Delete(asdl_seq * targets, int lineno, int col_offset, int end_lineno, int 
+       end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2094,19 +2094,19 @@ Delete(asdl_seq * targets, int lineno, int col_offset, int end_lineno, int
     p->v.Delete.targets = targets;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int
-       col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int 
+       col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Assign");
+                        "field 'value' is required for Assign"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2115,32 +2115,32 @@ Assign(asdl_seq * targets, expr_ty value, string type_comment, int lineno, int
     p->kind = Assign_kind;
     p->v.Assign.targets = targets;
     p->v.Assign.value = value;
-    p->v.Assign.type_comment = type_comment;
+    p->v.Assign.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
-          col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+          col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!target) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'target' is required for AugAssign");
+                        "field 'target' is required for AugAssign"); 
         return NULL;
     }
     if (!op) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'op' is required for AugAssign");
+                        "field 'op' is required for AugAssign"); 
         return NULL;
     }
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for AugAssign");
+                        "field 'value' is required for AugAssign"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2152,25 +2152,25 @@ AugAssign(expr_ty target, operator_ty op, expr_ty value, int lineno, int
     p->v.AugAssign.value = value;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple, int
-          lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
-          *arena)
+          lineno, int col_offset, int end_lineno, int end_col_offset, PyArena 
+          *arena) 
 {
     stmt_ty p;
     if (!target) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'target' is required for AnnAssign");
+                        "field 'target' is required for AnnAssign"); 
         return NULL;
     }
     if (!annotation) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'annotation' is required for AnnAssign");
+                        "field 'annotation' is required for AnnAssign"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2183,25 +2183,25 @@ AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int simple, int
     p->v.AnnAssign.simple = simple;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string
-    type_comment, int lineno, int col_offset, int end_lineno, int
-    end_col_offset, PyArena *arena)
+For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string 
+    type_comment, int lineno, int col_offset, int end_lineno, int 
+    end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!target) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'target' is required for For");
+                        "field 'target' is required for For"); 
         return NULL;
     }
     if (!iter) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'iter' is required for For");
+                        "field 'iter' is required for For"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2212,28 +2212,28 @@ For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, string
     p->v.For.iter = iter;
     p->v.For.body = body;
     p->v.For.orelse = orelse;
-    p->v.For.type_comment = type_comment;
+    p->v.For.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse,
-         string type_comment, int lineno, int col_offset, int end_lineno, int
-         end_col_offset, PyArena *arena)
+AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse, 
+         string type_comment, int lineno, int col_offset, int end_lineno, int 
+         end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!target) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'target' is required for AsyncFor");
+                        "field 'target' is required for AsyncFor"); 
         return NULL;
     }
     if (!iter) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'iter' is required for AsyncFor");
+                        "field 'iter' is required for AsyncFor"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2244,22 +2244,22 @@ AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * orelse,
     p->v.AsyncFor.iter = iter;
     p->v.AsyncFor.body = body;
     p->v.AsyncFor.orelse = orelse;
-    p->v.AsyncFor.type_comment = type_comment;
+    p->v.AsyncFor.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
-      col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+      col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!test) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'test' is required for While");
+                        "field 'test' is required for While"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2271,19 +2271,19 @@ While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
     p->v.While.orelse = orelse;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
-   col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+   col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!test) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'test' is required for If");
+                        "field 'test' is required for If"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2295,14 +2295,14 @@ If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, int
     p->v.If.orelse = orelse;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-With(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int
-     col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+With(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int 
+     col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2311,17 +2311,17 @@ With(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, int
     p->kind = With_kind;
     p->v.With.items = items;
     p->v.With.body = body;
-    p->v.With.type_comment = type_comment;
+    p->v.With.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment, int lineno,
-          int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment, int lineno, 
+          int col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2330,17 +2330,17 @@ AsyncWith(asdl_seq * items, asdl_seq * body, string type_comment, int lineno,
     p->kind = AsyncWith_kind;
     p->v.AsyncWith.items = items;
     p->v.AsyncWith.body = body;
-    p->v.AsyncWith.type_comment = type_comment;
+    p->v.AsyncWith.type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int end_lineno,
-      int end_col_offset, PyArena *arena)
+Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int end_lineno, 
+      int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2351,15 +2351,15 @@ Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, int end_lineno,
     p->v.Raise.cause = cause;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, asdl_seq *
-    finalbody, int lineno, int col_offset, int end_lineno, int end_col_offset,
-    PyArena *arena)
+    finalbody, int lineno, int col_offset, int end_lineno, int end_col_offset, 
+    PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2372,19 +2372,19 @@ Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, asdl_seq *
     p->v.Try.finalbody = finalbody;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int end_lineno,
-       int end_col_offset, PyArena *arena)
+Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int end_lineno, 
+       int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!test) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'test' is required for Assert");
+                        "field 'test' is required for Assert"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2395,14 +2395,14 @@ Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, int end_lineno,
     p->v.Assert.msg = msg;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Import(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
-       end_col_offset, PyArena *arena)
+Import(asdl_seq * names, int lineno, int col_offset, int end_lineno, int 
+       end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2412,14 +2412,14 @@ Import(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
     p->v.Import.names = names;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
 ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int
-           col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+           col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2431,14 +2431,14 @@ ImportFrom(identifier module, asdl_seq * names, int level, int lineno, int
     p->v.ImportFrom.level = level;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Global(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
-       end_col_offset, PyArena *arena)
+Global(asdl_seq * names, int lineno, int col_offset, int end_lineno, int 
+       end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2448,14 +2448,14 @@ Global(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
     p->v.Global.names = names;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Nonlocal(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
-         end_col_offset, PyArena *arena)
+Nonlocal(asdl_seq * names, int lineno, int col_offset, int end_lineno, int 
+         end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2465,19 +2465,19 @@ Nonlocal(asdl_seq * names, int lineno, int col_offset, int end_lineno, int
     p->v.Nonlocal.names = names;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
-     end_col_offset, PyArena *arena)
+Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int 
+     end_col_offset, PyArena *arena) 
 {
     stmt_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Expr");
+                        "field 'value' is required for Expr"); 
         return NULL;
     }
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2487,14 +2487,14 @@ Expr(expr_ty value, int lineno, int col_offset, int end_lineno, int
     p->v.Expr.value = value;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Pass(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
-     *arena)
+Pass(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena 
+     *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2503,14 +2503,14 @@ Pass(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
     p->kind = Pass_kind;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Break(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
-      *arena)
+Break(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena 
+      *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2519,14 +2519,14 @@ Break(int lineno, int col_offset, int end_lineno, int end_col_offset, PyArena
     p->kind = Break_kind;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 stmt_ty
-Continue(int lineno, int col_offset, int end_lineno, int end_col_offset,
-         PyArena *arena)
+Continue(int lineno, int col_offset, int end_lineno, int end_col_offset, 
+         PyArena *arena) 
 {
     stmt_ty p;
     p = (stmt_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2535,19 +2535,19 @@ Continue(int lineno, int col_offset, int end_lineno, int end_col_offset,
     p->kind = Continue_kind;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, int
-       end_lineno, int end_col_offset, PyArena *arena)
+BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, int 
+       end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!op) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'op' is required for BoolOp");
+                        "field 'op' is required for BoolOp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2558,57 +2558,57 @@ BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, int
     p->v.BoolOp.values = values;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
-    return p;
-}
-
-expr_ty
-NamedExpr(expr_ty target, expr_ty value, int lineno, int col_offset, int
-          end_lineno, int end_col_offset, PyArena *arena)
-{
-    expr_ty p;
-    if (!target) {
-        PyErr_SetString(PyExc_ValueError,
-                        "field 'target' is required for NamedExpr");
-        return NULL;
-    }
-    if (!value) {
-        PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for NamedExpr");
-        return NULL;
-    }
-    p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
-    if (!p)
-        return NULL;
-    p->kind = NamedExpr_kind;
-    p->v.NamedExpr.target = target;
-    p->v.NamedExpr.value = value;
-    p->lineno = lineno;
-    p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
+NamedExpr(expr_ty target, expr_ty value, int lineno, int col_offset, int 
+          end_lineno, int end_col_offset, PyArena *arena) 
+{ 
+    expr_ty p; 
+    if (!target) { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "field 'target' is required for NamedExpr"); 
+        return NULL; 
+    } 
+    if (!value) { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "field 'value' is required for NamedExpr"); 
+        return NULL; 
+    } 
+    p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); 
+    if (!p) 
+        return NULL; 
+    p->kind = NamedExpr_kind; 
+    p->v.NamedExpr.target = target; 
+    p->v.NamedExpr.value = value; 
+    p->lineno = lineno; 
+    p->col_offset = col_offset; 
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
+    return p; 
+} 
+ 
+expr_ty 
 BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset,
-      int end_lineno, int end_col_offset, PyArena *arena)
+      int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!left) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'left' is required for BinOp");
+                        "field 'left' is required for BinOp"); 
         return NULL;
     }
     if (!op) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'op' is required for BinOp");
+                        "field 'op' is required for BinOp"); 
         return NULL;
     }
     if (!right) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'right' is required for BinOp");
+                        "field 'right' is required for BinOp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2620,24 +2620,24 @@ BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int col_offset,
     p->v.BinOp.right = right;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, int
-        end_lineno, int end_col_offset, PyArena *arena)
+UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, int 
+        end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!op) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'op' is required for UnaryOp");
+                        "field 'op' is required for UnaryOp"); 
         return NULL;
     }
     if (!operand) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'operand' is required for UnaryOp");
+                        "field 'operand' is required for UnaryOp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2648,24 +2648,24 @@ UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, int
     p->v.UnaryOp.operand = operand;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, int
-       end_lineno, int end_col_offset, PyArena *arena)
+Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, int 
+       end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!args) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'args' is required for Lambda");
+                        "field 'args' is required for Lambda"); 
         return NULL;
     }
     if (!body) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'body' is required for Lambda");
+                        "field 'body' is required for Lambda"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2676,29 +2676,29 @@ Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, int
     p->v.Lambda.body = body;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset,
-      int end_lineno, int end_col_offset, PyArena *arena)
+      int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!test) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'test' is required for IfExp");
+                        "field 'test' is required for IfExp"); 
         return NULL;
     }
     if (!body) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'body' is required for IfExp");
+                        "field 'body' is required for IfExp"); 
         return NULL;
     }
     if (!orelse) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'orelse' is required for IfExp");
+                        "field 'orelse' is required for IfExp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2710,14 +2710,14 @@ IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int col_offset,
     p->v.IfExp.orelse = orelse;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, int
-     end_lineno, int end_col_offset, PyArena *arena)
+Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, int 
+     end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2728,14 +2728,14 @@ Dict(asdl_seq * keys, asdl_seq * values, int lineno, int col_offset, int
     p->v.Dict.values = values;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Set(asdl_seq * elts, int lineno, int col_offset, int end_lineno, int
-    end_col_offset, PyArena *arena)
+Set(asdl_seq * elts, int lineno, int col_offset, int end_lineno, int 
+    end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2745,19 +2745,19 @@ Set(asdl_seq * elts, int lineno, int col_offset, int end_lineno, int
     p->v.Set.elts = elts;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int
-         end_lineno, int end_col_offset, PyArena *arena)
+ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int 
+         end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!elt) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'elt' is required for ListComp");
+                        "field 'elt' is required for ListComp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2768,19 +2768,19 @@ ListComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int
     p->v.ListComp.generators = generators;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int
-        end_lineno, int end_col_offset, PyArena *arena)
+SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int 
+        end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!elt) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'elt' is required for SetComp");
+                        "field 'elt' is required for SetComp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2791,24 +2791,24 @@ SetComp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset, int
     p->v.SetComp.generators = generators;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int
-         col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+         col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!key) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'key' is required for DictComp");
+                        "field 'key' is required for DictComp"); 
         return NULL;
     }
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for DictComp");
+                        "field 'value' is required for DictComp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2820,19 +2820,19 @@ DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int lineno, int
     p->v.DictComp.generators = generators;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
-             int end_lineno, int end_col_offset, PyArena *arena)
+             int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!elt) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'elt' is required for GeneratorExp");
+                        "field 'elt' is required for GeneratorExp"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2843,19 +2843,19 @@ GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int col_offset,
     p->v.GeneratorExp.generators = generators;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Await(expr_ty value, int lineno, int col_offset, int end_lineno, int
-      end_col_offset, PyArena *arena)
+Await(expr_ty value, int lineno, int col_offset, int end_lineno, int 
+      end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Await");
+                        "field 'value' is required for Await"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2865,14 +2865,14 @@ Await(expr_ty value, int lineno, int col_offset, int end_lineno, int
     p->v.Await.value = value;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Yield(expr_ty value, int lineno, int col_offset, int end_lineno, int
-      end_col_offset, PyArena *arena)
+Yield(expr_ty value, int lineno, int col_offset, int end_lineno, int 
+      end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2882,19 +2882,19 @@ Yield(expr_ty value, int lineno, int col_offset, int end_lineno, int
     p->v.Yield.value = value;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-YieldFrom(expr_ty value, int lineno, int col_offset, int end_lineno, int
-          end_col_offset, PyArena *arena)
+YieldFrom(expr_ty value, int lineno, int col_offset, int end_lineno, int 
+          end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for YieldFrom");
+                        "field 'value' is required for YieldFrom"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2904,19 +2904,19 @@ YieldFrom(expr_ty value, int lineno, int col_offset, int end_lineno, int
     p->v.YieldFrom.value = value;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno,
-        int col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+        int col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!left) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'left' is required for Compare");
+                        "field 'left' is required for Compare"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2928,19 +2928,19 @@ Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, int lineno,
     p->v.Compare.comparators = comparators;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int lineno, int
-     col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+     col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!func) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'func' is required for Call");
+                        "field 'func' is required for Call"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2952,20 +2952,20 @@ Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int lineno, int
     p->v.Call.keywords = keywords;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno,
-               int col_offset, int end_lineno, int end_col_offset, PyArena
-               *arena)
+               int col_offset, int end_lineno, int end_col_offset, PyArena 
+               *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for FormattedValue");
+                        "field 'value' is required for FormattedValue"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2977,14 +2977,14 @@ FormattedValue(expr_ty value, int conversion, expr_ty format_spec, int lineno,
     p->v.FormattedValue.format_spec = format_spec;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-JoinedStr(asdl_seq * values, int lineno, int col_offset, int end_lineno, int
-          end_col_offset, PyArena *arena)
+JoinedStr(asdl_seq * values, int lineno, int col_offset, int end_lineno, int 
+          end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -2994,19 +2994,19 @@ JoinedStr(asdl_seq * values, int lineno, int col_offset, int end_lineno, int
     p->v.JoinedStr.values = values;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Constant(constant value, string kind, int lineno, int col_offset, int
-         end_lineno, int end_col_offset, PyArena *arena)
+Constant(constant value, string kind, int lineno, int col_offset, int 
+         end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Constant");
+                        "field 'value' is required for Constant"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3014,32 +3014,32 @@ Constant(constant value, string kind, int lineno, int col_offset, int
         return NULL;
     p->kind = Constant_kind;
     p->v.Constant.value = value;
-    p->v.Constant.kind = kind;
+    p->v.Constant.kind = kind; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
 Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int
-          col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+          col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Attribute");
+                        "field 'value' is required for Attribute"); 
         return NULL;
     }
     if (!attr) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'attr' is required for Attribute");
+                        "field 'attr' is required for Attribute"); 
         return NULL;
     }
     if (!ctx) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'ctx' is required for Attribute");
+                        "field 'ctx' is required for Attribute"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3051,29 +3051,29 @@ Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int lineno, int
     p->v.Attribute.ctx = ctx;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int lineno, int
-          col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int lineno, int 
+          col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Subscript");
+                        "field 'value' is required for Subscript"); 
         return NULL;
     }
     if (!slice) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'slice' is required for Subscript");
+                        "field 'slice' is required for Subscript"); 
         return NULL;
     }
     if (!ctx) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'ctx' is required for Subscript");
+                        "field 'ctx' is required for Subscript"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3085,24 +3085,24 @@ Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int lineno, int
     p->v.Subscript.ctx = ctx;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset, int
-        end_lineno, int end_col_offset, PyArena *arena)
+Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset, int 
+        end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for Starred");
+                        "field 'value' is required for Starred"); 
         return NULL;
     }
     if (!ctx) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'ctx' is required for Starred");
+                        "field 'ctx' is required for Starred"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3113,24 +3113,24 @@ Starred(expr_ty value, expr_context_ty ctx, int lineno, int col_offset, int
     p->v.Starred.ctx = ctx;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, int
-     end_lineno, int end_col_offset, PyArena *arena)
+Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, int 
+     end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!id) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'id' is required for Name");
+                        "field 'id' is required for Name"); 
         return NULL;
     }
     if (!ctx) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'ctx' is required for Name");
+                        "field 'ctx' is required for Name"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3141,19 +3141,19 @@ Name(identifier id, expr_context_ty ctx, int lineno, int col_offset, int
     p->v.Name.ctx = ctx;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int
-     end_lineno, int end_col_offset, PyArena *arena)
+List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int 
+     end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!ctx) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'ctx' is required for List");
+                        "field 'ctx' is required for List"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3164,19 +3164,19 @@ List(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int
     p->v.List.ctx = ctx;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 expr_ty
-Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int
-      end_lineno, int end_col_offset, PyArena *arena)
+Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int 
+      end_lineno, int end_col_offset, PyArena *arena) 
 {
     expr_ty p;
     if (!ctx) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'ctx' is required for Tuple");
+                        "field 'ctx' is required for Tuple"); 
         return NULL;
     }
     p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3187,27 +3187,27 @@ Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int col_offset, int
     p->v.Tuple.ctx = ctx;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
-expr_ty
-Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int col_offset,
-      int end_lineno, int end_col_offset, PyArena *arena)
+expr_ty 
+Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, int col_offset, 
+      int end_lineno, int end_col_offset, PyArena *arena) 
 {
-    expr_ty p;
-    p = (expr_ty)PyArena_Malloc(arena, sizeof(*p));
+    expr_ty p; 
+    p = (expr_ty)PyArena_Malloc(arena, sizeof(*p)); 
     if (!p)
         return NULL;
     p->kind = Slice_kind;
     p->v.Slice.lower = lower;
     p->v.Slice.upper = upper;
     p->v.Slice.step = step;
-    p->lineno = lineno;
-    p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->lineno = lineno; 
+    p->col_offset = col_offset; 
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
@@ -3218,12 +3218,12 @@ comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, int is_async,
     comprehension_ty p;
     if (!target) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'target' is required for comprehension");
+                        "field 'target' is required for comprehension"); 
         return NULL;
     }
     if (!iter) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'iter' is required for comprehension");
+                        "field 'iter' is required for comprehension"); 
         return NULL;
     }
     p = (comprehension_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3238,7 +3238,7 @@ comprehension(expr_ty target, expr_ty iter, asdl_seq * ifs, int is_async,
 
 excepthandler_ty
 ExceptHandler(expr_ty type, identifier name, asdl_seq * body, int lineno, int
-              col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+              col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     excepthandler_ty p;
     p = (excepthandler_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3250,21 +3250,21 @@ ExceptHandler(expr_ty type, identifier name, asdl_seq * body, int lineno, int
     p->v.ExceptHandler.body = body;
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 arguments_ty
-arguments(asdl_seq * posonlyargs, asdl_seq * args, arg_ty vararg, asdl_seq *
-          kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg, asdl_seq *
-          defaults, PyArena *arena)
+arguments(asdl_seq * posonlyargs, asdl_seq * args, arg_ty vararg, asdl_seq * 
+          kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg, asdl_seq * 
+          defaults, PyArena *arena) 
 {
     arguments_ty p;
     p = (arguments_ty)PyArena_Malloc(arena, sizeof(*p));
     if (!p)
         return NULL;
-    p->posonlyargs = posonlyargs;
+    p->posonlyargs = posonlyargs; 
     p->args = args;
     p->vararg = vararg;
     p->kwonlyargs = kwonlyargs;
@@ -3275,13 +3275,13 @@ arguments(asdl_seq * posonlyargs, asdl_seq * args, arg_ty vararg, asdl_seq *
 }
 
 arg_ty
-arg(identifier arg, expr_ty annotation, string type_comment, int lineno, int
-    col_offset, int end_lineno, int end_col_offset, PyArena *arena)
+arg(identifier arg, expr_ty annotation, string type_comment, int lineno, int 
+    col_offset, int end_lineno, int end_col_offset, PyArena *arena) 
 {
     arg_ty p;
     if (!arg) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'arg' is required for arg");
+                        "field 'arg' is required for arg"); 
         return NULL;
     }
     p = (arg_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3289,22 +3289,22 @@ arg(identifier arg, expr_ty annotation, string type_comment, int lineno, int
         return NULL;
     p->arg = arg;
     p->annotation = annotation;
-    p->type_comment = type_comment;
+    p->type_comment = type_comment; 
     p->lineno = lineno;
     p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
 keyword_ty
-keyword(identifier arg, expr_ty value, int lineno, int col_offset, int
-        end_lineno, int end_col_offset, PyArena *arena)
+keyword(identifier arg, expr_ty value, int lineno, int col_offset, int 
+        end_lineno, int end_col_offset, PyArena *arena) 
 {
     keyword_ty p;
     if (!value) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'value' is required for keyword");
+                        "field 'value' is required for keyword"); 
         return NULL;
     }
     p = (keyword_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3312,10 +3312,10 @@ keyword(identifier arg, expr_ty value, int lineno, int col_offset, int
         return NULL;
     p->arg = arg;
     p->value = value;
-    p->lineno = lineno;
-    p->col_offset = col_offset;
-    p->end_lineno = end_lineno;
-    p->end_col_offset = end_col_offset;
+    p->lineno = lineno; 
+    p->col_offset = col_offset; 
+    p->end_lineno = end_lineno; 
+    p->end_col_offset = end_col_offset; 
     return p;
 }
 
@@ -3325,7 +3325,7 @@ alias(identifier name, identifier asname, PyArena *arena)
     alias_ty p;
     if (!name) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'name' is required for alias");
+                        "field 'name' is required for alias"); 
         return NULL;
     }
     p = (alias_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3342,7 +3342,7 @@ withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena)
     withitem_ty p;
     if (!context_expr) {
         PyErr_SetString(PyExc_ValueError,
-                        "field 'context_expr' is required for withitem");
+                        "field 'context_expr' is required for withitem"); 
         return NULL;
     }
     p = (withitem_ty)PyArena_Malloc(arena, sizeof(*p));
@@ -3353,86 +3353,86 @@ withitem(expr_ty context_expr, expr_ty optional_vars, PyArena *arena)
     return p;
 }
 
-type_ignore_ty
-TypeIgnore(int lineno, string tag, PyArena *arena)
-{
-    type_ignore_ty p;
-    if (!tag) {
-        PyErr_SetString(PyExc_ValueError,
-                        "field 'tag' is required for TypeIgnore");
-        return NULL;
-    }
-    p = (type_ignore_ty)PyArena_Malloc(arena, sizeof(*p));
-    if (!p)
-        return NULL;
-    p->kind = TypeIgnore_kind;
-    p->v.TypeIgnore.lineno = lineno;
-    p->v.TypeIgnore.tag = tag;
-    return p;
-}
-
-
+type_ignore_ty 
+TypeIgnore(int lineno, string tag, PyArena *arena) 
+{ 
+    type_ignore_ty p; 
+    if (!tag) { 
+        PyErr_SetString(PyExc_ValueError, 
+                        "field 'tag' is required for TypeIgnore"); 
+        return NULL; 
+    } 
+    p = (type_ignore_ty)PyArena_Malloc(arena, sizeof(*p)); 
+    if (!p) 
+        return NULL; 
+    p->kind = TypeIgnore_kind; 
+    p->v.TypeIgnore.lineno = lineno; 
+    p->v.TypeIgnore.tag = tag; 
+    return p; 
+} 
+
+ 
 PyObject*
-ast2obj_mod(astmodulestate *state, void* _o)
+ast2obj_mod(astmodulestate *state, void* _o) 
 {
     mod_ty o = (mod_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
     switch (o->kind) {
     case Module_kind:
-        tp = (PyTypeObject *)state->Module_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Module_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Module.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.Module.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Module.type_ignores,
-                             ast2obj_type_ignore);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_ignores, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_list(state, o->v.Module.type_ignores, 
+                             ast2obj_type_ignore); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_ignores, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case Interactive_kind:
-        tp = (PyTypeObject *)state->Interactive_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Interactive_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Interactive.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.Interactive.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Expression_kind:
-        tp = (PyTypeObject *)state->Expression_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Expression_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Expression.body);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        break;
-    case FunctionType_kind:
-        tp = (PyTypeObject *)state->FunctionType_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
-        if (!result) goto failed;
-        value = ast2obj_list(state, o->v.FunctionType.argtypes, ast2obj_expr);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->argtypes, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.FunctionType.returns);
+        value = ast2obj_expr(state, o->v.Expression.body); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->returns, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
+    case FunctionType_kind: 
+        tp = (PyTypeObject *)state->FunctionType_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
+        if (!result) goto failed; 
+        value = ast2obj_list(state, o->v.FunctionType.argtypes, ast2obj_expr); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->argtypes, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        value = ast2obj_expr(state, o->v.FunctionType.returns); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->returns, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        break; 
     }
     return result;
 failed:
@@ -3442,493 +3442,493 @@ failed:
 }
 
 PyObject*
-ast2obj_stmt(astmodulestate *state, void* _o)
+ast2obj_stmt(astmodulestate *state, void* _o) 
 {
     stmt_ty o = (stmt_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
     switch (o->kind) {
     case FunctionDef_kind:
-        tp = (PyTypeObject *)state->FunctionDef_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->FunctionDef_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_identifier(state, o->v.FunctionDef.name);
+        value = ast2obj_identifier(state, o->v.FunctionDef.name); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->name, value) == -1)
+        if (PyObject_SetAttr(result, state->name, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_arguments(state, o->v.FunctionDef.args);
+        value = ast2obj_arguments(state, o->v.FunctionDef.args); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->args, value) == -1)
+        if (PyObject_SetAttr(result, state->args, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.FunctionDef.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.FunctionDef.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.FunctionDef.decorator_list,
-                             ast2obj_expr);
+        value = ast2obj_list(state, o->v.FunctionDef.decorator_list, 
+                             ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
+        if (PyObject_SetAttr(result, state->decorator_list, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.FunctionDef.returns);
+        value = ast2obj_expr(state, o->v.FunctionDef.returns); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->returns, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_string(state, o->v.FunctionDef.type_comment);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->returns, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.FunctionDef.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case AsyncFunctionDef_kind:
-        tp = (PyTypeObject *)state->AsyncFunctionDef_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->AsyncFunctionDef_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_identifier(state, o->v.AsyncFunctionDef.name);
+        value = ast2obj_identifier(state, o->v.AsyncFunctionDef.name); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->name, value) == -1)
+        if (PyObject_SetAttr(result, state->name, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args);
+        value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->args, value) == -1)
+        if (PyObject_SetAttr(result, state->args, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.AsyncFunctionDef.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.AsyncFunctionDef.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.AsyncFunctionDef.decorator_list,
+        value = ast2obj_list(state, o->v.AsyncFunctionDef.decorator_list, 
                              ast2obj_expr);
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.AsyncFunctionDef.returns);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->returns, value) == -1)
+        if (PyObject_SetAttr(result, state->decorator_list, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_string(state, o->v.AsyncFunctionDef.type_comment);
+        value = ast2obj_expr(state, o->v.AsyncFunctionDef.returns); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->returns, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.AsyncFunctionDef.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case ClassDef_kind:
-        tp = (PyTypeObject *)state->ClassDef_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->ClassDef_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_identifier(state, o->v.ClassDef.name);
+        value = ast2obj_identifier(state, o->v.ClassDef.name); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->name, value) == -1)
+        if (PyObject_SetAttr(result, state->name, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ClassDef.bases, ast2obj_expr);
+        value = ast2obj_list(state, o->v.ClassDef.bases, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->bases, value) == -1)
+        if (PyObject_SetAttr(result, state->bases, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ClassDef.keywords, ast2obj_keyword);
+        value = ast2obj_list(state, o->v.ClassDef.keywords, ast2obj_keyword); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->keywords, value) == -1)
+        if (PyObject_SetAttr(result, state->keywords, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ClassDef.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.ClassDef.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ClassDef.decorator_list, ast2obj_expr);
+        value = ast2obj_list(state, o->v.ClassDef.decorator_list, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
+        if (PyObject_SetAttr(result, state->decorator_list, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Return_kind:
-        tp = (PyTypeObject *)state->Return_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Return_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Return.value);
+        value = ast2obj_expr(state, o->v.Return.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Delete_kind:
-        tp = (PyTypeObject *)state->Delete_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Delete_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Delete.targets, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Delete.targets, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->targets, value) == -1)
+        if (PyObject_SetAttr(result, state->targets, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Assign_kind:
-        tp = (PyTypeObject *)state->Assign_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Assign_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Assign.targets, ast2obj_expr);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->targets, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Assign.value);
+        value = ast2obj_list(state, o->v.Assign.targets, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->targets, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_string(state, o->v.Assign.type_comment);
+        value = ast2obj_expr(state, o->v.Assign.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.Assign.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case AugAssign_kind:
-        tp = (PyTypeObject *)state->AugAssign_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->AugAssign_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.AugAssign.target);
+        value = ast2obj_expr(state, o->v.AugAssign.target); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->target, value) == -1)
+        if (PyObject_SetAttr(result, state->target, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_operator(state, o->v.AugAssign.op);
+        value = ast2obj_operator(state, o->v.AugAssign.op); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->op, value) == -1)
+        if (PyObject_SetAttr(result, state->op, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.AugAssign.value);
+        value = ast2obj_expr(state, o->v.AugAssign.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case AnnAssign_kind:
-        tp = (PyTypeObject *)state->AnnAssign_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->AnnAssign_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.AnnAssign.target);
+        value = ast2obj_expr(state, o->v.AnnAssign.target); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->target, value) == -1)
+        if (PyObject_SetAttr(result, state->target, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.AnnAssign.annotation);
+        value = ast2obj_expr(state, o->v.AnnAssign.annotation); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->annotation, value) == -1)
+        if (PyObject_SetAttr(result, state->annotation, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.AnnAssign.value);
+        value = ast2obj_expr(state, o->v.AnnAssign.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_int(state, o->v.AnnAssign.simple);
+        value = ast2obj_int(state, o->v.AnnAssign.simple); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->simple, value) == -1)
+        if (PyObject_SetAttr(result, state->simple, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case For_kind:
-        tp = (PyTypeObject *)state->For_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->For_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.For.target);
+        value = ast2obj_expr(state, o->v.For.target); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->target, value) == -1)
+        if (PyObject_SetAttr(result, state->target, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.For.iter);
+        value = ast2obj_expr(state, o->v.For.iter); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->iter, value) == -1)
+        if (PyObject_SetAttr(result, state->iter, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.For.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.For.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.For.orelse, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.For.orelse, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->orelse, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_string(state, o->v.For.type_comment);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->orelse, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.For.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case AsyncFor_kind:
-        tp = (PyTypeObject *)state->AsyncFor_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->AsyncFor_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.AsyncFor.target);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->target, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.AsyncFor.iter);
+        value = ast2obj_expr(state, o->v.AsyncFor.target); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->iter, value) == -1)
+        if (PyObject_SetAttr(result, state->target, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.AsyncFor.body, ast2obj_stmt);
+        value = ast2obj_expr(state, o->v.AsyncFor.iter); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->iter, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.AsyncFor.orelse, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.AsyncFor.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->orelse, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_string(state, o->v.AsyncFor.type_comment);
+        value = ast2obj_list(state, o->v.AsyncFor.orelse, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->orelse, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.AsyncFor.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case While_kind:
-        tp = (PyTypeObject *)state->While_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->While_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.While.test);
+        value = ast2obj_expr(state, o->v.While.test); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->test, value) == -1)
+        if (PyObject_SetAttr(result, state->test, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.While.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.While.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.While.orelse, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.While.orelse, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->orelse, value) == -1)
+        if (PyObject_SetAttr(result, state->orelse, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case If_kind:
-        tp = (PyTypeObject *)state->If_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->If_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.If.test);
+        value = ast2obj_expr(state, o->v.If.test); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->test, value) == -1)
+        if (PyObject_SetAttr(result, state->test, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.If.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.If.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.If.orelse, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.If.orelse, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->orelse, value) == -1)
+        if (PyObject_SetAttr(result, state->orelse, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case With_kind:
-        tp = (PyTypeObject *)state->With_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->With_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.With.items, ast2obj_withitem);
+        value = ast2obj_list(state, o->v.With.items, ast2obj_withitem); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->items, value) == -1)
+        if (PyObject_SetAttr(result, state->items, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.With.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.With.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_string(state, o->v.With.type_comment);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.With.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case AsyncWith_kind:
-        tp = (PyTypeObject *)state->AsyncWith_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->AsyncWith_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.AsyncWith.items, ast2obj_withitem);
+        value = ast2obj_list(state, o->v.AsyncWith.items, ast2obj_withitem); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->items, value) == -1)
+        if (PyObject_SetAttr(result, state->items, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.AsyncWith.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.AsyncWith.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_string(state, o->v.AsyncWith.type_comment);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type_comment, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.AsyncWith.type_comment); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case Raise_kind:
-        tp = (PyTypeObject *)state->Raise_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Raise_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Raise.exc);
+        value = ast2obj_expr(state, o->v.Raise.exc); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->exc, value) == -1)
+        if (PyObject_SetAttr(result, state->exc, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Raise.cause);
+        value = ast2obj_expr(state, o->v.Raise.cause); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->cause, value) == -1)
+        if (PyObject_SetAttr(result, state->cause, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Try_kind:
-        tp = (PyTypeObject *)state->Try_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Try_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Try.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.Try.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Try.handlers, ast2obj_excepthandler);
+        value = ast2obj_list(state, o->v.Try.handlers, ast2obj_excepthandler); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->handlers, value) == -1)
+        if (PyObject_SetAttr(result, state->handlers, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Try.orelse, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.Try.orelse, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->orelse, value) == -1)
+        if (PyObject_SetAttr(result, state->orelse, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Try.finalbody, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.Try.finalbody, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->finalbody, value) == -1)
+        if (PyObject_SetAttr(result, state->finalbody, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Assert_kind:
-        tp = (PyTypeObject *)state->Assert_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Assert_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Assert.test);
+        value = ast2obj_expr(state, o->v.Assert.test); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->test, value) == -1)
+        if (PyObject_SetAttr(result, state->test, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Assert.msg);
+        value = ast2obj_expr(state, o->v.Assert.msg); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->msg, value) == -1)
+        if (PyObject_SetAttr(result, state->msg, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Import_kind:
-        tp = (PyTypeObject *)state->Import_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Import_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Import.names, ast2obj_alias);
+        value = ast2obj_list(state, o->v.Import.names, ast2obj_alias); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->names, value) == -1)
+        if (PyObject_SetAttr(result, state->names, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case ImportFrom_kind:
-        tp = (PyTypeObject *)state->ImportFrom_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->ImportFrom_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_identifier(state, o->v.ImportFrom.module);
+        value = ast2obj_identifier(state, o->v.ImportFrom.module); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->module, value) == -1)
+        if (PyObject_SetAttr(result, state->module, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ImportFrom.names, ast2obj_alias);
+        value = ast2obj_list(state, o->v.ImportFrom.names, ast2obj_alias); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->names, value) == -1)
+        if (PyObject_SetAttr(result, state->names, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_int(state, o->v.ImportFrom.level);
+        value = ast2obj_int(state, o->v.ImportFrom.level); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->level, value) == -1)
+        if (PyObject_SetAttr(result, state->level, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Global_kind:
-        tp = (PyTypeObject *)state->Global_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Global_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Global.names, ast2obj_identifier);
+        value = ast2obj_list(state, o->v.Global.names, ast2obj_identifier); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->names, value) == -1)
+        if (PyObject_SetAttr(result, state->names, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Nonlocal_kind:
-        tp = (PyTypeObject *)state->Nonlocal_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Nonlocal_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Nonlocal.names, ast2obj_identifier);
+        value = ast2obj_list(state, o->v.Nonlocal.names, ast2obj_identifier); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->names, value) == -1)
+        if (PyObject_SetAttr(result, state->names, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Expr_kind:
-        tp = (PyTypeObject *)state->Expr_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Expr_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Expr.value);
+        value = ast2obj_expr(state, o->v.Expr.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Pass_kind:
-        tp = (PyTypeObject *)state->Pass_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Pass_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
         break;
     case Break_kind:
-        tp = (PyTypeObject *)state->Break_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Break_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
         break;
     case Continue_kind:
-        tp = (PyTypeObject *)state->Continue_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Continue_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
         break;
     }
-    value = ast2obj_int(state, o->lineno);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->col_offset);
+    value = ast2obj_int(state, o->lineno); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->lineno, value) < 0) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->end_lineno);
+    value = ast2obj_int(state, o->col_offset); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->end_col_offset);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->col_offset, value) < 0) 
         goto failed;
     Py_DECREF(value);
+    value = ast2obj_int(state, o->end_lineno); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_lineno, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->end_col_offset); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
     return result;
 failed:
     Py_XDECREF(value);
@@ -3937,246 +3937,246 @@ failed:
 }
 
 PyObject*
-ast2obj_expr(astmodulestate *state, void* _o)
+ast2obj_expr(astmodulestate *state, void* _o) 
 {
     expr_ty o = (expr_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
     switch (o->kind) {
     case BoolOp_kind:
-        tp = (PyTypeObject *)state->BoolOp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->BoolOp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_boolop(state, o->v.BoolOp.op);
+        value = ast2obj_boolop(state, o->v.BoolOp.op); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->op, value) == -1)
+        if (PyObject_SetAttr(result, state->op, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.BoolOp.values, ast2obj_expr);
+        value = ast2obj_list(state, o->v.BoolOp.values, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->values, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        break;
-    case NamedExpr_kind:
-        tp = (PyTypeObject *)state->NamedExpr_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
-        if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.NamedExpr.target);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->target, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.NamedExpr.value);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->values, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
+    case NamedExpr_kind: 
+        tp = (PyTypeObject *)state->NamedExpr_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
+        if (!result) goto failed; 
+        value = ast2obj_expr(state, o->v.NamedExpr.target); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->target, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        value = ast2obj_expr(state, o->v.NamedExpr.value); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        break; 
     case BinOp_kind:
-        tp = (PyTypeObject *)state->BinOp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->BinOp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.BinOp.left);
+        value = ast2obj_expr(state, o->v.BinOp.left); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->left, value) == -1)
+        if (PyObject_SetAttr(result, state->left, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_operator(state, o->v.BinOp.op);
+        value = ast2obj_operator(state, o->v.BinOp.op); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->op, value) == -1)
+        if (PyObject_SetAttr(result, state->op, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.BinOp.right);
+        value = ast2obj_expr(state, o->v.BinOp.right); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->right, value) == -1)
+        if (PyObject_SetAttr(result, state->right, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case UnaryOp_kind:
-        tp = (PyTypeObject *)state->UnaryOp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->UnaryOp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_unaryop(state, o->v.UnaryOp.op);
+        value = ast2obj_unaryop(state, o->v.UnaryOp.op); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->op, value) == -1)
+        if (PyObject_SetAttr(result, state->op, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.UnaryOp.operand);
+        value = ast2obj_expr(state, o->v.UnaryOp.operand); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->operand, value) == -1)
+        if (PyObject_SetAttr(result, state->operand, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Lambda_kind:
-        tp = (PyTypeObject *)state->Lambda_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Lambda_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_arguments(state, o->v.Lambda.args);
+        value = ast2obj_arguments(state, o->v.Lambda.args); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->args, value) == -1)
+        if (PyObject_SetAttr(result, state->args, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Lambda.body);
+        value = ast2obj_expr(state, o->v.Lambda.body); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case IfExp_kind:
-        tp = (PyTypeObject *)state->IfExp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->IfExp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.IfExp.test);
+        value = ast2obj_expr(state, o->v.IfExp.test); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->test, value) == -1)
+        if (PyObject_SetAttr(result, state->test, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.IfExp.body);
+        value = ast2obj_expr(state, o->v.IfExp.body); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.IfExp.orelse);
+        value = ast2obj_expr(state, o->v.IfExp.orelse); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->orelse, value) == -1)
+        if (PyObject_SetAttr(result, state->orelse, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Dict_kind:
-        tp = (PyTypeObject *)state->Dict_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Dict_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Dict.keys, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Dict.keys, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->keys, value) == -1)
+        if (PyObject_SetAttr(result, state->keys, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Dict.values, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Dict.values, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->values, value) == -1)
+        if (PyObject_SetAttr(result, state->values, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Set_kind:
-        tp = (PyTypeObject *)state->Set_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Set_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Set.elts, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Set.elts, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->elts, value) == -1)
+        if (PyObject_SetAttr(result, state->elts, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case ListComp_kind:
-        tp = (PyTypeObject *)state->ListComp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->ListComp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.ListComp.elt);
+        value = ast2obj_expr(state, o->v.ListComp.elt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->elt, value) == -1)
+        if (PyObject_SetAttr(result, state->elt, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ListComp.generators,
-                             ast2obj_comprehension);
+        value = ast2obj_list(state, o->v.ListComp.generators, 
+                             ast2obj_comprehension); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->generators, value) == -1)
+        if (PyObject_SetAttr(result, state->generators, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case SetComp_kind:
-        tp = (PyTypeObject *)state->SetComp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->SetComp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.SetComp.elt);
+        value = ast2obj_expr(state, o->v.SetComp.elt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->elt, value) == -1)
+        if (PyObject_SetAttr(result, state->elt, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.SetComp.generators,
-                             ast2obj_comprehension);
+        value = ast2obj_list(state, o->v.SetComp.generators, 
+                             ast2obj_comprehension); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->generators, value) == -1)
+        if (PyObject_SetAttr(result, state->generators, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case DictComp_kind:
-        tp = (PyTypeObject *)state->DictComp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->DictComp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.DictComp.key);
+        value = ast2obj_expr(state, o->v.DictComp.key); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->key, value) == -1)
+        if (PyObject_SetAttr(result, state->key, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.DictComp.value);
+        value = ast2obj_expr(state, o->v.DictComp.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.DictComp.generators,
-                             ast2obj_comprehension);
+        value = ast2obj_list(state, o->v.DictComp.generators, 
+                             ast2obj_comprehension); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->generators, value) == -1)
+        if (PyObject_SetAttr(result, state->generators, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case GeneratorExp_kind:
-        tp = (PyTypeObject *)state->GeneratorExp_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->GeneratorExp_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.GeneratorExp.elt);
+        value = ast2obj_expr(state, o->v.GeneratorExp.elt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->elt, value) == -1)
+        if (PyObject_SetAttr(result, state->elt, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.GeneratorExp.generators,
+        value = ast2obj_list(state, o->v.GeneratorExp.generators, 
                              ast2obj_comprehension);
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->generators, value) == -1)
+        if (PyObject_SetAttr(result, state->generators, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Await_kind:
-        tp = (PyTypeObject *)state->Await_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Await_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Await.value);
+        value = ast2obj_expr(state, o->v.Await.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Yield_kind:
-        tp = (PyTypeObject *)state->Yield_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Yield_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Yield.value);
+        value = ast2obj_expr(state, o->v.Yield.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case YieldFrom_kind:
-        tp = (PyTypeObject *)state->YieldFrom_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->YieldFrom_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.YieldFrom.value);
+        value = ast2obj_expr(state, o->v.YieldFrom.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Compare_kind:
-        tp = (PyTypeObject *)state->Compare_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Compare_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Compare.left);
+        value = ast2obj_expr(state, o->v.Compare.left); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->left, value) == -1)
+        if (PyObject_SetAttr(result, state->left, value) == -1) 
             goto failed;
         Py_DECREF(value);
         {
@@ -4184,224 +4184,224 @@ ast2obj_expr(astmodulestate *state, void* _o)
             value = PyList_New(n);
             if (!value) goto failed;
             for(i = 0; i < n; i++)
-                PyList_SET_ITEM(value, i, ast2obj_cmpop(state, (cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
+                PyList_SET_ITEM(value, i, ast2obj_cmpop(state, (cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i))); 
         }
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ops, value) == -1)
+        if (PyObject_SetAttr(result, state->ops, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Compare.comparators, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Compare.comparators, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->comparators, value) == -1)
+        if (PyObject_SetAttr(result, state->comparators, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Call_kind:
-        tp = (PyTypeObject *)state->Call_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Call_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Call.func);
+        value = ast2obj_expr(state, o->v.Call.func); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->func, value) == -1)
+        if (PyObject_SetAttr(result, state->func, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Call.args, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Call.args, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->args, value) == -1)
+        if (PyObject_SetAttr(result, state->args, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.Call.keywords, ast2obj_keyword);
+        value = ast2obj_list(state, o->v.Call.keywords, ast2obj_keyword); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->keywords, value) == -1)
+        if (PyObject_SetAttr(result, state->keywords, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case FormattedValue_kind:
-        tp = (PyTypeObject *)state->FormattedValue_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->FormattedValue_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.FormattedValue.value);
+        value = ast2obj_expr(state, o->v.FormattedValue.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_int(state, o->v.FormattedValue.conversion);
+        value = ast2obj_int(state, o->v.FormattedValue.conversion); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->conversion, value) == -1)
+        if (PyObject_SetAttr(result, state->conversion, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.FormattedValue.format_spec);
+        value = ast2obj_expr(state, o->v.FormattedValue.format_spec); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->format_spec, value) == -1)
+        if (PyObject_SetAttr(result, state->format_spec, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case JoinedStr_kind:
-        tp = (PyTypeObject *)state->JoinedStr_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->JoinedStr_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.JoinedStr.values, ast2obj_expr);
+        value = ast2obj_list(state, o->v.JoinedStr.values, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->values, value) == -1)
+        if (PyObject_SetAttr(result, state->values, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Constant_kind:
-        tp = (PyTypeObject *)state->Constant_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Constant_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_constant(state, o->v.Constant.value);
+        value = ast2obj_constant(state, o->v.Constant.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_string(state, o->v.Constant.kind);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->kind, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
+        value = ast2obj_string(state, o->v.Constant.kind); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->kind, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
         break;
     case Attribute_kind:
-        tp = (PyTypeObject *)state->Attribute_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Attribute_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Attribute.value);
+        value = ast2obj_expr(state, o->v.Attribute.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_identifier(state, o->v.Attribute.attr);
+        value = ast2obj_identifier(state, o->v.Attribute.attr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->attr, value) == -1)
+        if (PyObject_SetAttr(result, state->attr, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr_context(state, o->v.Attribute.ctx);
+        value = ast2obj_expr_context(state, o->v.Attribute.ctx); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ctx, value) == -1)
+        if (PyObject_SetAttr(result, state->ctx, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Subscript_kind:
-        tp = (PyTypeObject *)state->Subscript_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Subscript_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Subscript.value);
+        value = ast2obj_expr(state, o->v.Subscript.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Subscript.slice);
+        value = ast2obj_expr(state, o->v.Subscript.slice); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->slice, value) == -1)
+        if (PyObject_SetAttr(result, state->slice, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr_context(state, o->v.Subscript.ctx);
+        value = ast2obj_expr_context(state, o->v.Subscript.ctx); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ctx, value) == -1)
+        if (PyObject_SetAttr(result, state->ctx, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Starred_kind:
-        tp = (PyTypeObject *)state->Starred_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Starred_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Starred.value);
+        value = ast2obj_expr(state, o->v.Starred.value); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->value, value) == -1)
+        if (PyObject_SetAttr(result, state->value, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr_context(state, o->v.Starred.ctx);
+        value = ast2obj_expr_context(state, o->v.Starred.ctx); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ctx, value) == -1)
+        if (PyObject_SetAttr(result, state->ctx, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Name_kind:
-        tp = (PyTypeObject *)state->Name_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Name_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_identifier(state, o->v.Name.id);
+        value = ast2obj_identifier(state, o->v.Name.id); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->id, value) == -1)
+        if (PyObject_SetAttr(result, state->id, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr_context(state, o->v.Name.ctx);
+        value = ast2obj_expr_context(state, o->v.Name.ctx); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ctx, value) == -1)
+        if (PyObject_SetAttr(result, state->ctx, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case List_kind:
-        tp = (PyTypeObject *)state->List_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->List_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.List.elts, ast2obj_expr);
+        value = ast2obj_list(state, o->v.List.elts, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->elts, value) == -1)
+        if (PyObject_SetAttr(result, state->elts, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr_context(state, o->v.List.ctx);
+        value = ast2obj_expr_context(state, o->v.List.ctx); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ctx, value) == -1)
+        if (PyObject_SetAttr(result, state->ctx, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     case Tuple_kind:
-        tp = (PyTypeObject *)state->Tuple_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->Tuple_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_list(state, o->v.Tuple.elts, ast2obj_expr);
+        value = ast2obj_list(state, o->v.Tuple.elts, ast2obj_expr); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->elts, value) == -1)
+        if (PyObject_SetAttr(result, state->elts, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_expr_context(state, o->v.Tuple.ctx);
+        value = ast2obj_expr_context(state, o->v.Tuple.ctx); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->ctx, value) == -1)
+        if (PyObject_SetAttr(result, state->ctx, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
-    case Slice_kind:
-        tp = (PyTypeObject *)state->Slice_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
-        if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.Slice.lower);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->lower, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Slice.upper);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->upper, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_expr(state, o->v.Slice.step);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->step, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        break;
-    }
-    value = ast2obj_int(state, o->lineno);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->col_offset);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->col_offset, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->end_lineno);
+    case Slice_kind: 
+        tp = (PyTypeObject *)state->Slice_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
+        if (!result) goto failed; 
+        value = ast2obj_expr(state, o->v.Slice.lower); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->lower, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        value = ast2obj_expr(state, o->v.Slice.upper); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->upper, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        value = ast2obj_expr(state, o->v.Slice.step); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->step, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        break; 
+    }
+    value = ast2obj_int(state, o->lineno); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
+    if (PyObject_SetAttr(result, state->lineno, value) < 0) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->end_col_offset);
+    value = ast2obj_int(state, o->col_offset); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->col_offset, value) < 0) 
         goto failed;
     Py_DECREF(value);
+    value = ast2obj_int(state, o->end_lineno); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_lineno, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->end_col_offset); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
     return result;
 failed:
     Py_XDECREF(value);
@@ -4409,162 +4409,162 @@ failed:
     return NULL;
 }
 
-PyObject* ast2obj_expr_context(astmodulestate *state, expr_context_ty o)
+PyObject* ast2obj_expr_context(astmodulestate *state, expr_context_ty o) 
 {
     switch(o) {
         case Load:
-            Py_INCREF(state->Load_singleton);
-            return state->Load_singleton;
+            Py_INCREF(state->Load_singleton); 
+            return state->Load_singleton; 
         case Store:
-            Py_INCREF(state->Store_singleton);
-            return state->Store_singleton;
+            Py_INCREF(state->Store_singleton); 
+            return state->Store_singleton; 
         case Del:
-            Py_INCREF(state->Del_singleton);
-            return state->Del_singleton;
+            Py_INCREF(state->Del_singleton); 
+            return state->Del_singleton; 
     }
-    Py_UNREACHABLE();
+    Py_UNREACHABLE(); 
 }
-PyObject* ast2obj_boolop(astmodulestate *state, boolop_ty o)
+PyObject* ast2obj_boolop(astmodulestate *state, boolop_ty o) 
 {
     switch(o) {
         case And:
-            Py_INCREF(state->And_singleton);
-            return state->And_singleton;
+            Py_INCREF(state->And_singleton); 
+            return state->And_singleton; 
         case Or:
-            Py_INCREF(state->Or_singleton);
-            return state->Or_singleton;
+            Py_INCREF(state->Or_singleton); 
+            return state->Or_singleton; 
     }
-    Py_UNREACHABLE();
+    Py_UNREACHABLE(); 
 }
-PyObject* ast2obj_operator(astmodulestate *state, operator_ty o)
+PyObject* ast2obj_operator(astmodulestate *state, operator_ty o) 
 {
     switch(o) {
         case Add:
-            Py_INCREF(state->Add_singleton);
-            return state->Add_singleton;
+            Py_INCREF(state->Add_singleton); 
+            return state->Add_singleton; 
         case Sub:
-            Py_INCREF(state->Sub_singleton);
-            return state->Sub_singleton;
+            Py_INCREF(state->Sub_singleton); 
+            return state->Sub_singleton; 
         case Mult:
-            Py_INCREF(state->Mult_singleton);
-            return state->Mult_singleton;
+            Py_INCREF(state->Mult_singleton); 
+            return state->Mult_singleton; 
         case MatMult:
-            Py_INCREF(state->MatMult_singleton);
-            return state->MatMult_singleton;
+            Py_INCREF(state->MatMult_singleton); 
+            return state->MatMult_singleton; 
         case Div:
-            Py_INCREF(state->Div_singleton);
-            return state->Div_singleton;
+            Py_INCREF(state->Div_singleton); 
+            return state->Div_singleton; 
         case Mod:
-            Py_INCREF(state->Mod_singleton);
-            return state->Mod_singleton;
+            Py_INCREF(state->Mod_singleton); 
+            return state->Mod_singleton; 
         case Pow:
-            Py_INCREF(state->Pow_singleton);
-            return state->Pow_singleton;
+            Py_INCREF(state->Pow_singleton); 
+            return state->Pow_singleton; 
         case LShift:
-            Py_INCREF(state->LShift_singleton);
-            return state->LShift_singleton;
+            Py_INCREF(state->LShift_singleton); 
+            return state->LShift_singleton; 
         case RShift:
-            Py_INCREF(state->RShift_singleton);
-            return state->RShift_singleton;
+            Py_INCREF(state->RShift_singleton); 
+            return state->RShift_singleton; 
         case BitOr:
-            Py_INCREF(state->BitOr_singleton);
-            return state->BitOr_singleton;
+            Py_INCREF(state->BitOr_singleton); 
+            return state->BitOr_singleton; 
         case BitXor:
-            Py_INCREF(state->BitXor_singleton);
-            return state->BitXor_singleton;
+            Py_INCREF(state->BitXor_singleton); 
+            return state->BitXor_singleton; 
         case BitAnd:
-            Py_INCREF(state->BitAnd_singleton);
-            return state->BitAnd_singleton;
+            Py_INCREF(state->BitAnd_singleton); 
+            return state->BitAnd_singleton; 
         case FloorDiv:
-            Py_INCREF(state->FloorDiv_singleton);
-            return state->FloorDiv_singleton;
+            Py_INCREF(state->FloorDiv_singleton); 
+            return state->FloorDiv_singleton; 
     }
-    Py_UNREACHABLE();
+    Py_UNREACHABLE(); 
 }
-PyObject* ast2obj_unaryop(astmodulestate *state, unaryop_ty o)
+PyObject* ast2obj_unaryop(astmodulestate *state, unaryop_ty o) 
 {
     switch(o) {
         case Invert:
-            Py_INCREF(state->Invert_singleton);
-            return state->Invert_singleton;
+            Py_INCREF(state->Invert_singleton); 
+            return state->Invert_singleton; 
         case Not:
-            Py_INCREF(state->Not_singleton);
-            return state->Not_singleton;
+            Py_INCREF(state->Not_singleton); 
+            return state->Not_singleton; 
         case UAdd:
-            Py_INCREF(state->UAdd_singleton);
-            return state->UAdd_singleton;
+            Py_INCREF(state->UAdd_singleton); 
+            return state->UAdd_singleton; 
         case USub:
-            Py_INCREF(state->USub_singleton);
-            return state->USub_singleton;
+            Py_INCREF(state->USub_singleton); 
+            return state->USub_singleton; 
     }
-    Py_UNREACHABLE();
+    Py_UNREACHABLE(); 
 }
-PyObject* ast2obj_cmpop(astmodulestate *state, cmpop_ty o)
+PyObject* ast2obj_cmpop(astmodulestate *state, cmpop_ty o) 
 {
     switch(o) {
         case Eq:
-            Py_INCREF(state->Eq_singleton);
-            return state->Eq_singleton;
+            Py_INCREF(state->Eq_singleton); 
+            return state->Eq_singleton; 
         case NotEq:
-            Py_INCREF(state->NotEq_singleton);
-            return state->NotEq_singleton;
+            Py_INCREF(state->NotEq_singleton); 
+            return state->NotEq_singleton; 
         case Lt:
-            Py_INCREF(state->Lt_singleton);
-            return state->Lt_singleton;
+            Py_INCREF(state->Lt_singleton); 
+            return state->Lt_singleton; 
         case LtE:
-            Py_INCREF(state->LtE_singleton);
-            return state->LtE_singleton;
+            Py_INCREF(state->LtE_singleton); 
+            return state->LtE_singleton; 
         case Gt:
-            Py_INCREF(state->Gt_singleton);
-            return state->Gt_singleton;
+            Py_INCREF(state->Gt_singleton); 
+            return state->Gt_singleton; 
         case GtE:
-            Py_INCREF(state->GtE_singleton);
-            return state->GtE_singleton;
+            Py_INCREF(state->GtE_singleton); 
+            return state->GtE_singleton; 
         case Is:
-            Py_INCREF(state->Is_singleton);
-            return state->Is_singleton;
+            Py_INCREF(state->Is_singleton); 
+            return state->Is_singleton; 
         case IsNot:
-            Py_INCREF(state->IsNot_singleton);
-            return state->IsNot_singleton;
+            Py_INCREF(state->IsNot_singleton); 
+            return state->IsNot_singleton; 
         case In:
-            Py_INCREF(state->In_singleton);
-            return state->In_singleton;
+            Py_INCREF(state->In_singleton); 
+            return state->In_singleton; 
         case NotIn:
-            Py_INCREF(state->NotIn_singleton);
-            return state->NotIn_singleton;
+            Py_INCREF(state->NotIn_singleton); 
+            return state->NotIn_singleton; 
     }
-    Py_UNREACHABLE();
+    Py_UNREACHABLE(); 
 }
 PyObject*
-ast2obj_comprehension(astmodulestate *state, void* _o)
+ast2obj_comprehension(astmodulestate *state, void* _o) 
 {
     comprehension_ty o = (comprehension_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
-    tp = (PyTypeObject *)state->comprehension_type;
-    result = PyType_GenericNew(tp, NULL, NULL);
+    tp = (PyTypeObject *)state->comprehension_type; 
+    result = PyType_GenericNew(tp, NULL, NULL); 
     if (!result) return NULL;
-    value = ast2obj_expr(state, o->target);
+    value = ast2obj_expr(state, o->target); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->target, value) == -1)
+    if (PyObject_SetAttr(result, state->target, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_expr(state, o->iter);
+    value = ast2obj_expr(state, o->iter); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->iter, value) == -1)
+    if (PyObject_SetAttr(result, state->iter, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_list(state, o->ifs, ast2obj_expr);
+    value = ast2obj_list(state, o->ifs, ast2obj_expr); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->ifs, value) == -1)
+    if (PyObject_SetAttr(result, state->ifs, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->is_async);
+    value = ast2obj_int(state, o->is_async); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->is_async, value) == -1)
+    if (PyObject_SetAttr(result, state->is_async, value) == -1) 
         goto failed;
     Py_DECREF(value);
     return result;
@@ -4575,56 +4575,56 @@ failed:
 }
 
 PyObject*
-ast2obj_excepthandler(astmodulestate *state, void* _o)
+ast2obj_excepthandler(astmodulestate *state, void* _o) 
 {
     excepthandler_ty o = (excepthandler_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
     switch (o->kind) {
     case ExceptHandler_kind:
-        tp = (PyTypeObject *)state->ExceptHandler_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
+        tp = (PyTypeObject *)state->ExceptHandler_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
         if (!result) goto failed;
-        value = ast2obj_expr(state, o->v.ExceptHandler.type);
+        value = ast2obj_expr(state, o->v.ExceptHandler.type); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->type, value) == -1)
+        if (PyObject_SetAttr(result, state->type, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_identifier(state, o->v.ExceptHandler.name);
+        value = ast2obj_identifier(state, o->v.ExceptHandler.name); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->name, value) == -1)
+        if (PyObject_SetAttr(result, state->name, value) == -1) 
             goto failed;
         Py_DECREF(value);
-        value = ast2obj_list(state, o->v.ExceptHandler.body, ast2obj_stmt);
+        value = ast2obj_list(state, o->v.ExceptHandler.body, ast2obj_stmt); 
         if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->body, value) == -1)
+        if (PyObject_SetAttr(result, state->body, value) == -1) 
             goto failed;
         Py_DECREF(value);
         break;
     }
-    value = ast2obj_int(state, o->lineno);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->col_offset);
+    value = ast2obj_int(state, o->lineno); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->lineno, value) < 0) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->end_lineno);
+    value = ast2obj_int(state, o->col_offset); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->end_col_offset);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->col_offset, value) < 0) 
         goto failed;
     Py_DECREF(value);
+    value = ast2obj_int(state, o->end_lineno); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_lineno, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->end_col_offset); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
     return result;
 failed:
     Py_XDECREF(value);
@@ -4633,50 +4633,50 @@ failed:
 }
 
 PyObject*
-ast2obj_arguments(astmodulestate *state, void* _o)
+ast2obj_arguments(astmodulestate *state, void* _o) 
 {
     arguments_ty o = (arguments_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
-    tp = (PyTypeObject *)state->arguments_type;
-    result = PyType_GenericNew(tp, NULL, NULL);
+    tp = (PyTypeObject *)state->arguments_type; 
+    result = PyType_GenericNew(tp, NULL, NULL); 
     if (!result) return NULL;
-    value = ast2obj_list(state, o->posonlyargs, ast2obj_arg);
+    value = ast2obj_list(state, o->posonlyargs, ast2obj_arg); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->posonlyargs, value) == -1) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_list(state, o->args, ast2obj_arg); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->posonlyargs, value) == -1)
+    if (PyObject_SetAttr(result, state->args, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_list(state, o->args, ast2obj_arg);
+    value = ast2obj_arg(state, o->vararg); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->args, value) == -1)
+    if (PyObject_SetAttr(result, state->vararg, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_arg(state, o->vararg);
+    value = ast2obj_list(state, o->kwonlyargs, ast2obj_arg); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->vararg, value) == -1)
+    if (PyObject_SetAttr(result, state->kwonlyargs, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_list(state, o->kwonlyargs, ast2obj_arg);
+    value = ast2obj_list(state, o->kw_defaults, ast2obj_expr); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->kwonlyargs, value) == -1)
+    if (PyObject_SetAttr(result, state->kw_defaults, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_list(state, o->kw_defaults, ast2obj_expr);
+    value = ast2obj_arg(state, o->kwarg); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->kw_defaults, value) == -1)
+    if (PyObject_SetAttr(result, state->kwarg, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_arg(state, o->kwarg);
+    value = ast2obj_list(state, o->defaults, ast2obj_expr); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->kwarg, value) == -1)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_list(state, o->defaults, ast2obj_expr);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->defaults, value) == -1)
+    if (PyObject_SetAttr(result, state->defaults, value) == -1) 
         goto failed;
     Py_DECREF(value);
     return result;
@@ -4687,52 +4687,52 @@ failed:
 }
 
 PyObject*
-ast2obj_arg(astmodulestate *state, void* _o)
+ast2obj_arg(astmodulestate *state, void* _o) 
 {
     arg_ty o = (arg_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
-    tp = (PyTypeObject *)state->arg_type;
-    result = PyType_GenericNew(tp, NULL, NULL);
+    tp = (PyTypeObject *)state->arg_type; 
+    result = PyType_GenericNew(tp, NULL, NULL); 
     if (!result) return NULL;
-    value = ast2obj_identifier(state, o->arg);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->arg, value) == -1)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_expr(state, o->annotation);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->annotation, value) == -1)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_string(state, o->type_comment);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->type_comment, value) == -1)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->lineno);
+    value = ast2obj_identifier(state, o->arg); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->lineno, value) < 0)
+    if (PyObject_SetAttr(result, state->arg, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->col_offset);
+    value = ast2obj_expr(state, o->annotation); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->annotation, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->end_lineno);
+    value = ast2obj_string(state, o->type_comment); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->type_comment, value) == -1) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->lineno); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
+    if (PyObject_SetAttr(result, state->lineno, value) < 0) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->end_col_offset);
+    value = ast2obj_int(state, o->col_offset); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->col_offset, value) < 0) 
         goto failed;
     Py_DECREF(value);
+    value = ast2obj_int(state, o->end_lineno); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_lineno, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->end_col_offset); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
     return result;
 failed:
     Py_XDECREF(value);
@@ -4741,47 +4741,47 @@ failed:
 }
 
 PyObject*
-ast2obj_keyword(astmodulestate *state, void* _o)
+ast2obj_keyword(astmodulestate *state, void* _o) 
 {
     keyword_ty o = (keyword_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
-    tp = (PyTypeObject *)state->keyword_type;
-    result = PyType_GenericNew(tp, NULL, NULL);
+    tp = (PyTypeObject *)state->keyword_type; 
+    result = PyType_GenericNew(tp, NULL, NULL); 
     if (!result) return NULL;
-    value = ast2obj_identifier(state, o->arg);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->arg, value) == -1)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_expr(state, o->value);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->value, value) == -1)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->lineno);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->col_offset);
+    value = ast2obj_identifier(state, o->arg); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->arg, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_int(state, o->end_lineno);
+    value = ast2obj_expr(state, o->value); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
-        goto failed;
-    Py_DECREF(value);
-    value = ast2obj_int(state, o->end_col_offset);
-    if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
+    if (PyObject_SetAttr(result, state->value, value) == -1) 
         goto failed;
     Py_DECREF(value);
+    value = ast2obj_int(state, o->lineno); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->lineno, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->col_offset); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->col_offset, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->end_lineno); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_lineno, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
+    value = ast2obj_int(state, o->end_col_offset); 
+    if (!value) goto failed; 
+    if (PyObject_SetAttr(result, state->end_col_offset, value) < 0) 
+        goto failed; 
+    Py_DECREF(value); 
     return result;
 failed:
     Py_XDECREF(value);
@@ -4790,25 +4790,25 @@ failed:
 }
 
 PyObject*
-ast2obj_alias(astmodulestate *state, void* _o)
+ast2obj_alias(astmodulestate *state, void* _o) 
 {
     alias_ty o = (alias_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
-    tp = (PyTypeObject *)state->alias_type;
-    result = PyType_GenericNew(tp, NULL, NULL);
+    tp = (PyTypeObject *)state->alias_type; 
+    result = PyType_GenericNew(tp, NULL, NULL); 
     if (!result) return NULL;
-    value = ast2obj_identifier(state, o->name);
+    value = ast2obj_identifier(state, o->name); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->name, value) == -1)
+    if (PyObject_SetAttr(result, state->name, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_identifier(state, o->asname);
+    value = ast2obj_identifier(state, o->asname); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->asname, value) == -1)
+    if (PyObject_SetAttr(result, state->asname, value) == -1) 
         goto failed;
     Py_DECREF(value);
     return result;
@@ -4819,25 +4819,25 @@ failed:
 }
 
 PyObject*
-ast2obj_withitem(astmodulestate *state, void* _o)
+ast2obj_withitem(astmodulestate *state, void* _o) 
 {
     withitem_ty o = (withitem_ty)_o;
     PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
+    PyTypeObject *tp; 
     if (!o) {
         Py_RETURN_NONE;
     }
-    tp = (PyTypeObject *)state->withitem_type;
-    result = PyType_GenericNew(tp, NULL, NULL);
+    tp = (PyTypeObject *)state->withitem_type; 
+    result = PyType_GenericNew(tp, NULL, NULL); 
     if (!result) return NULL;
-    value = ast2obj_expr(state, o->context_expr);
+    value = ast2obj_expr(state, o->context_expr); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->context_expr, value) == -1)
+    if (PyObject_SetAttr(result, state->context_expr, value) == -1) 
         goto failed;
     Py_DECREF(value);
-    value = ast2obj_expr(state, o->optional_vars);
+    value = ast2obj_expr(state, o->optional_vars); 
     if (!value) goto failed;
-    if (PyObject_SetAttr(result, state->optional_vars, value) == -1)
+    if (PyObject_SetAttr(result, state->optional_vars, value) == -1) 
         goto failed;
     Py_DECREF(value);
     return result;
@@ -4847,62 +4847,62 @@ failed:
     return NULL;
 }
 
-PyObject*
-ast2obj_type_ignore(astmodulestate *state, void* _o)
-{
-    type_ignore_ty o = (type_ignore_ty)_o;
-    PyObject *result = NULL, *value = NULL;
-    PyTypeObject *tp;
-    if (!o) {
-        Py_RETURN_NONE;
-    }
-    switch (o->kind) {
-    case TypeIgnore_kind:
-        tp = (PyTypeObject *)state->TypeIgnore_type;
-        result = PyType_GenericNew(tp, NULL, NULL);
-        if (!result) goto failed;
-        value = ast2obj_int(state, o->v.TypeIgnore.lineno);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->lineno, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        value = ast2obj_string(state, o->v.TypeIgnore.tag);
-        if (!value) goto failed;
-        if (PyObject_SetAttr(result, state->tag, value) == -1)
-            goto failed;
-        Py_DECREF(value);
-        break;
-    }
-    return result;
-failed:
-    Py_XDECREF(value);
-    Py_XDECREF(result);
-    return NULL;
-}
-
-
+PyObject* 
+ast2obj_type_ignore(astmodulestate *state, void* _o) 
+{ 
+    type_ignore_ty o = (type_ignore_ty)_o; 
+    PyObject *result = NULL, *value = NULL; 
+    PyTypeObject *tp; 
+    if (!o) { 
+        Py_RETURN_NONE; 
+    } 
+    switch (o->kind) { 
+    case TypeIgnore_kind: 
+        tp = (PyTypeObject *)state->TypeIgnore_type; 
+        result = PyType_GenericNew(tp, NULL, NULL); 
+        if (!result) goto failed; 
+        value = ast2obj_int(state, o->v.TypeIgnore.lineno); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->lineno, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        value = ast2obj_string(state, o->v.TypeIgnore.tag); 
+        if (!value) goto failed; 
+        if (PyObject_SetAttr(result, state->tag, value) == -1) 
+            goto failed; 
+        Py_DECREF(value); 
+        break; 
+    } 
+    return result; 
+failed: 
+    Py_XDECREF(value); 
+    Py_XDECREF(result); 
+    return NULL; 
+} 
+ 
+ 
 int
-obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
+obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena) 
 {
     int isinstance;
 
     PyObject *tmp = NULL;
-    PyObject *tp;
+    PyObject *tp; 
 
     if (obj == Py_None) {
         *out = NULL;
         return 0;
     }
-    tp = state->Module_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Module_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* body;
-        asdl_seq* type_ignores;
+        asdl_seq* type_ignores; 
 
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -4914,7 +4914,7 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Module field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -4922,14 +4922,14 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Module' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Module' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Module field \"body\" changed size during iteration");
@@ -4939,56 +4939,56 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->type_ignores, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module");
-            return 1;
-        }
-        else {
-            int res;
-            Py_ssize_t len;
-            Py_ssize_t i;
-            if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
-                goto failed;
-            }
-            len = PyList_GET_SIZE(tmp);
-            type_ignores = _Py_asdl_seq_new(len, arena);
-            if (type_ignores == NULL) goto failed;
-            for (i = 0; i < len; i++) {
-                type_ignore_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Module' node")) {
-                    goto failed;
-                }
-                res = obj2ast_type_ignore(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
-                if (res != 0) goto failed;
-                if (len != PyList_GET_SIZE(tmp)) {
-                    PyErr_SetString(PyExc_RuntimeError, "Module field \"type_ignores\" changed size during iteration");
-                    goto failed;
-                }
-                asdl_seq_SET(type_ignores, i, val);
-            }
-            Py_CLEAR(tmp);
-        }
-        *out = Module(body, type_ignores, arena);
+        if (_PyObject_LookupAttr(obj, state->type_ignores, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"type_ignores\" missing from Module"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            Py_ssize_t len; 
+            Py_ssize_t i; 
+            if (!PyList_Check(tmp)) { 
+                PyErr_Format(PyExc_TypeError, "Module field \"type_ignores\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
+                goto failed; 
+            } 
+            len = PyList_GET_SIZE(tmp); 
+            type_ignores = _Py_asdl_seq_new(len, arena); 
+            if (type_ignores == NULL) goto failed; 
+            for (i = 0; i < len; i++) { 
+                type_ignore_ty val; 
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Module' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_type_ignore(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
+                if (res != 0) goto failed; 
+                if (len != PyList_GET_SIZE(tmp)) { 
+                    PyErr_SetString(PyExc_RuntimeError, "Module field \"type_ignores\" changed size during iteration"); 
+                    goto failed; 
+                } 
+                asdl_seq_SET(type_ignores, i, val); 
+            } 
+            Py_CLEAR(tmp); 
+        } 
+        *out = Module(body, type_ignores, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Interactive_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Interactive_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* body;
 
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5000,7 +5000,7 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Interactive field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5008,14 +5008,14 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Interactive' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Interactive' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Interactive field \"body\" changed size during iteration");
@@ -5029,15 +5029,15 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Expression_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Expression_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty body;
 
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5046,11 +5046,11 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Expression' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &body, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Expression' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &body, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
@@ -5058,73 +5058,73 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->FunctionType_type;
-    isinstance = PyObject_IsInstance(obj, tp);
-    if (isinstance == -1) {
-        return 1;
-    }
-    if (isinstance) {
-        asdl_seq* argtypes;
-        expr_ty returns;
-
-        if (_PyObject_LookupAttr(obj, state->argtypes, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType");
-            return 1;
-        }
-        else {
-            int res;
-            Py_ssize_t len;
-            Py_ssize_t i;
-            if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
-                goto failed;
-            }
-            len = PyList_GET_SIZE(tmp);
-            argtypes = _Py_asdl_seq_new(len, arena);
-            if (argtypes == NULL) goto failed;
-            for (i = 0; i < len; i++) {
-                expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
-                if (res != 0) goto failed;
-                if (len != PyList_GET_SIZE(tmp)) {
-                    PyErr_SetString(PyExc_RuntimeError, "FunctionType field \"argtypes\" changed size during iteration");
-                    goto failed;
-                }
-                asdl_seq_SET(argtypes, i, val);
-            }
-            Py_CLEAR(tmp);
-        }
-        if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType");
-            return 1;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &returns, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = FunctionType(argtypes, returns, arena);
-        if (*out == NULL) goto failed;
-        return 0;
-    }
+    tp = state->FunctionType_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
+    if (isinstance == -1) { 
+        return 1; 
+    } 
+    if (isinstance) { 
+        asdl_seq* argtypes; 
+        expr_ty returns; 
+ 
+        if (_PyObject_LookupAttr(obj, state->argtypes, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"argtypes\" missing from FunctionType"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            Py_ssize_t len; 
+            Py_ssize_t i; 
+            if (!PyList_Check(tmp)) { 
+                PyErr_Format(PyExc_TypeError, "FunctionType field \"argtypes\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
+                goto failed; 
+            } 
+            len = PyList_GET_SIZE(tmp); 
+            argtypes = _Py_asdl_seq_new(len, arena); 
+            if (argtypes == NULL) goto failed; 
+            for (i = 0; i < len; i++) { 
+                expr_ty val; 
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
+                if (res != 0) goto failed; 
+                if (len != PyList_GET_SIZE(tmp)) { 
+                    PyErr_SetString(PyExc_RuntimeError, "FunctionType field \"argtypes\" changed size during iteration"); 
+                    goto failed; 
+                } 
+                asdl_seq_SET(argtypes, i, val); 
+            } 
+            Py_CLEAR(tmp); 
+        } 
+        if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"returns\" missing from FunctionType"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'FunctionType' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &returns, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = FunctionType(argtypes, returns, arena); 
+        if (*out == NULL) goto failed; 
+        return 0; 
+    } 
 
     PyErr_Format(PyExc_TypeError, "expected some sort of mod, but got %R", obj);
     failed:
@@ -5133,22 +5133,22 @@ obj2ast_mod(astmodulestate *state, PyObject* obj, mod_ty* out, PyArena* arena)
 }
 
 int
-obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
+obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena) 
 {
     int isinstance;
 
     PyObject *tmp = NULL;
-    PyObject *tp;
+    PyObject *tp; 
     int lineno;
     int col_offset;
-    int end_lineno;
-    int end_col_offset;
+    int end_lineno; 
+    int end_col_offset; 
 
     if (obj == Py_None) {
         *out = NULL;
         return 0;
     }
-    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -5157,15 +5157,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &lineno, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &lineno, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -5174,50 +5174,50 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &col_offset, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_lineno = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_lineno, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_col_offset = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_col_offset, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    tp = state->FunctionDef_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_lineno = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_lineno, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_col_offset = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'stmt' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    tp = state->FunctionDef_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -5227,9 +5227,9 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* body;
         asdl_seq* decorator_list;
         expr_ty returns;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5238,15 +5238,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &name, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &name, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5255,15 +5255,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_arguments(state, tmp, &args, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_arguments(state, tmp, &args, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5275,7 +5275,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "FunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5283,14 +5283,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"body\" changed size during iteration");
@@ -5300,7 +5300,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5312,7 +5312,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "FunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5320,14 +5320,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (decorator_list == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"decorator_list\" changed size during iteration");
@@ -5337,7 +5337,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -5346,39 +5346,39 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &returns, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &returns, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = FunctionDef(name, args, body, decorator_list, returns,
-                           type_comment, lineno, col_offset, end_lineno,
-                           end_col_offset, arena);
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = FunctionDef(name, args, body, decorator_list, returns, 
+                           type_comment, lineno, col_offset, end_lineno, 
+                           end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->AsyncFunctionDef_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->AsyncFunctionDef_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -5388,9 +5388,9 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* body;
         asdl_seq* decorator_list;
         expr_ty returns;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5399,15 +5399,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &name, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &name, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5416,15 +5416,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_arguments(state, tmp, &args, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_arguments(state, tmp, &args, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5436,7 +5436,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5444,14 +5444,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"body\" changed size during iteration");
@@ -5461,7 +5461,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5473,7 +5473,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5481,14 +5481,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (decorator_list == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"decorator_list\" changed size during iteration");
@@ -5498,7 +5498,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->returns, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -5507,39 +5507,39 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &returns, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &returns, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
         *out = AsyncFunctionDef(name, args, body, decorator_list, returns,
-                                type_comment, lineno, col_offset, end_lineno,
-                                end_col_offset, arena);
+                                type_comment, lineno, col_offset, end_lineno, 
+                                end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->ClassDef_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->ClassDef_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -5550,7 +5550,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* body;
         asdl_seq* decorator_list;
 
-        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5559,15 +5559,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &name, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &name, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->bases, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->bases, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5579,7 +5579,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ClassDef field \"bases\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5587,14 +5587,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (bases == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"bases\" changed size during iteration");
@@ -5604,7 +5604,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5616,7 +5616,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ClassDef field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ClassDef field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5624,14 +5624,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (keywords == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 keyword_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_keyword(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_keyword(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"keywords\" changed size during iteration");
@@ -5641,7 +5641,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5653,7 +5653,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ClassDef field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5661,14 +5661,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"body\" changed size during iteration");
@@ -5678,7 +5678,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->decorator_list, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5690,7 +5690,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ClassDef field \"decorator_list\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5698,14 +5698,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (decorator_list == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"decorator_list\" changed size during iteration");
@@ -5716,19 +5716,19 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_CLEAR(tmp);
         }
         *out = ClassDef(name, bases, keywords, body, decorator_list, lineno,
-                        col_offset, end_lineno, end_col_offset, arena);
+                        col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Return_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Return_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty value;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -5737,28 +5737,28 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Return' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Return' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Return(value, lineno, col_offset, end_lineno, end_col_offset,
-                      arena);
+        *out = Return(value, lineno, col_offset, end_lineno, end_col_offset, 
+                      arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Delete_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Delete_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* targets;
 
-        if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5770,7 +5770,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Delete field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5778,14 +5778,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (targets == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Delete' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Delete' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Delete field \"targets\" changed size during iteration");
@@ -5795,22 +5795,22 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Delete(targets, lineno, col_offset, end_lineno, end_col_offset,
-                      arena);
+        *out = Delete(targets, lineno, col_offset, end_lineno, end_col_offset, 
+                      arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Assign_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Assign_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* targets;
         expr_ty value;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->targets, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5822,7 +5822,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Assign field \"targets\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -5830,14 +5830,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (targets == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Assign' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Assign field \"targets\" changed size during iteration");
@@ -5847,7 +5847,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5856,38 +5856,38 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Assign' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Assign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Assign(targets, value, type_comment, lineno, col_offset,
-                      end_lineno, end_col_offset, arena);
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'Assign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = Assign(targets, value, type_comment, lineno, col_offset, 
+                      end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->AugAssign_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->AugAssign_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -5896,7 +5896,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         operator_ty op;
         expr_ty value;
 
-        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5905,15 +5905,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &target, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &target, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5922,15 +5922,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_operator(state, tmp, &op, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_operator(state, tmp, &op, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5939,21 +5939,21 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AugAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = AugAssign(target, op, value, lineno, col_offset, end_lineno,
-                         end_col_offset, arena);
+        *out = AugAssign(target, op, value, lineno, col_offset, end_lineno, 
+                         end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->AnnAssign_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->AnnAssign_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -5963,7 +5963,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         expr_ty value;
         int simple;
 
-        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5972,15 +5972,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &target, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &target, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -5989,15 +5989,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &annotation, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &annotation, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -6006,15 +6006,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->simple, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->simple, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6023,21 +6023,21 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) {
-                goto failed;
-            }
-            res = obj2ast_int(state, tmp, &simple, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AnnAssign' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_int(state, tmp, &simple, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
         *out = AnnAssign(target, annotation, value, simple, lineno, col_offset,
-                         end_lineno, end_col_offset, arena);
+                         end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->For_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->For_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6046,9 +6046,9 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         expr_ty iter;
         asdl_seq* body;
         asdl_seq* orelse;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6057,15 +6057,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'For' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &target, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'For' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &target, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6074,15 +6074,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'For' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &iter, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'For' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &iter, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6094,7 +6094,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "For field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6102,14 +6102,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'For' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'For' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "For field \"body\" changed size during iteration");
@@ -6119,7 +6119,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6131,7 +6131,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "For field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6139,14 +6139,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (orelse == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'For' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'For' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "For field \"orelse\" changed size during iteration");
@@ -6156,30 +6156,30 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'For' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = For(target, iter, body, orelse, type_comment, lineno,
-                   col_offset, end_lineno, end_col_offset, arena);
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'For' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = For(target, iter, body, orelse, type_comment, lineno, 
+                   col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->AsyncFor_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->AsyncFor_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6188,9 +6188,9 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         expr_ty iter;
         asdl_seq* body;
         asdl_seq* orelse;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6199,15 +6199,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &target, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &target, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6216,15 +6216,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &iter, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &iter, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6236,7 +6236,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "AsyncFor field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6244,14 +6244,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"body\" changed size during iteration");
@@ -6261,7 +6261,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6273,7 +6273,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "AsyncFor field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6281,14 +6281,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (orelse == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "AsyncFor field \"orelse\" changed size during iteration");
@@ -6298,30 +6298,30 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = AsyncFor(target, iter, body, orelse, type_comment, lineno,
-                        col_offset, end_lineno, end_col_offset, arena);
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncFor' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = AsyncFor(target, iter, body, orelse, type_comment, lineno, 
+                        col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->While_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->While_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6330,7 +6330,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* body;
         asdl_seq* orelse;
 
-        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6339,15 +6339,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'While' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &test, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'While' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &test, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6359,7 +6359,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "While field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6367,14 +6367,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'While' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'While' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "While field \"body\" changed size during iteration");
@@ -6384,7 +6384,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6396,7 +6396,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "While field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6404,14 +6404,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (orelse == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'While' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'While' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "While field \"orelse\" changed size during iteration");
@@ -6421,13 +6421,13 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = While(test, body, orelse, lineno, col_offset, end_lineno,
-                     end_col_offset, arena);
+        *out = While(test, body, orelse, lineno, col_offset, end_lineno, 
+                     end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->If_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->If_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6436,7 +6436,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* body;
         asdl_seq* orelse;
 
-        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6445,15 +6445,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'If' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &test, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'If' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &test, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6465,7 +6465,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "If field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6473,14 +6473,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'If' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'If' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "If field \"body\" changed size during iteration");
@@ -6490,7 +6490,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6502,7 +6502,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "If field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6510,14 +6510,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (orelse == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'If' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'If' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "If field \"orelse\" changed size during iteration");
@@ -6527,22 +6527,22 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = If(test, body, orelse, lineno, col_offset, end_lineno,
-                  end_col_offset, arena);
+        *out = If(test, body, orelse, lineno, col_offset, end_lineno, 
+                  end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->With_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->With_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* items;
         asdl_seq* body;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6554,7 +6554,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "With field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "With field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6562,14 +6562,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (items == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 withitem_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'With' node")) {
-                    goto failed;
-                }
-                res = obj2ast_withitem(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'With' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_withitem(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "With field \"items\" changed size during iteration");
@@ -6579,7 +6579,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6591,7 +6591,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "With field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6599,14 +6599,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'With' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'With' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "With field \"body\" changed size during iteration");
@@ -6616,39 +6616,39 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'With' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = With(items, body, type_comment, lineno, col_offset, end_lineno,
-                    end_col_offset, arena);
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'With' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = With(items, body, type_comment, lineno, col_offset, end_lineno, 
+                    end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->AsyncWith_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->AsyncWith_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* items;
         asdl_seq* body;
-        string type_comment;
+        string type_comment; 
 
-        if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->items, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6660,7 +6660,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "AsyncWith field \"items\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6668,14 +6668,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (items == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 withitem_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
-                    goto failed;
-                }
-                res = obj2ast_withitem(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_withitem(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"items\" changed size during iteration");
@@ -6685,7 +6685,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6697,7 +6697,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "AsyncWith field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6705,14 +6705,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "AsyncWith field \"body\" changed size during iteration");
@@ -6722,30 +6722,30 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL || tmp == Py_None) {
-            Py_CLEAR(tmp);
-            type_comment = NULL;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &type_comment, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = AsyncWith(items, body, type_comment, lineno, col_offset,
-                         end_lineno, end_col_offset, arena);
+        if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL || tmp == Py_None) { 
+            Py_CLEAR(tmp); 
+            type_comment = NULL; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'AsyncWith' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &type_comment, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = AsyncWith(items, body, type_comment, lineno, col_offset, 
+                         end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Raise_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Raise_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6753,7 +6753,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         expr_ty exc;
         expr_ty cause;
 
-        if (_PyObject_LookupAttr(obj, state->exc, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->exc, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -6762,15 +6762,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Raise' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &exc, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Raise' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &exc, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->cause, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->cause, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -6779,21 +6779,21 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Raise' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &cause, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Raise' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &cause, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Raise(exc, cause, lineno, col_offset, end_lineno,
-                     end_col_offset, arena);
+        *out = Raise(exc, cause, lineno, col_offset, end_lineno, 
+                     end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Try_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Try_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6803,7 +6803,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* orelse;
         asdl_seq* finalbody;
 
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6815,7 +6815,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Try field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Try field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6823,14 +6823,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Try field \"body\" changed size during iteration");
@@ -6840,7 +6840,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->handlers, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->handlers, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6852,7 +6852,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Try field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Try field \"handlers\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6860,14 +6860,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (handlers == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 excepthandler_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) {
-                    goto failed;
-                }
-                res = obj2ast_excepthandler(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_excepthandler(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Try field \"handlers\" changed size during iteration");
@@ -6877,7 +6877,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6889,7 +6889,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Try field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Try field \"orelse\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6897,14 +6897,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (orelse == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Try field \"orelse\" changed size during iteration");
@@ -6914,7 +6914,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->finalbody, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->finalbody, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6926,7 +6926,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Try field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Try field \"finalbody\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -6934,14 +6934,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (finalbody == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Try' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Try field \"finalbody\" changed size during iteration");
@@ -6952,12 +6952,12 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_CLEAR(tmp);
         }
         *out = Try(body, handlers, orelse, finalbody, lineno, col_offset,
-                   end_lineno, end_col_offset, arena);
+                   end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Assert_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Assert_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -6965,7 +6965,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         expr_ty test;
         expr_ty msg;
 
-        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -6974,15 +6974,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Assert' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &test, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Assert' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &test, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->msg, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->msg, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -6991,28 +6991,28 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Assert' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &msg, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Assert' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &msg, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Assert(test, msg, lineno, col_offset, end_lineno,
-                      end_col_offset, arena);
+        *out = Assert(test, msg, lineno, col_offset, end_lineno, 
+                      end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Import_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Import_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* names;
 
-        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7024,7 +7024,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Import field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7032,14 +7032,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (names == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 alias_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Import' node")) {
-                    goto failed;
-                }
-                res = obj2ast_alias(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Import' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_alias(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Import field \"names\" changed size during iteration");
@@ -7049,13 +7049,13 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Import(names, lineno, col_offset, end_lineno, end_col_offset,
-                      arena);
+        *out = Import(names, lineno, col_offset, end_lineno, end_col_offset, 
+                      arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->ImportFrom_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->ImportFrom_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7064,7 +7064,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         asdl_seq* names;
         int level;
 
-        if (_PyObject_LookupAttr(obj, state->module, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->module, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -7073,15 +7073,15 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &module, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &module, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7093,7 +7093,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ImportFrom field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7101,14 +7101,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (names == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 alias_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
-                    goto failed;
-                }
-                res = obj2ast_alias(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_alias(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ImportFrom field \"names\" changed size during iteration");
@@ -7118,7 +7118,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->level, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->level, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -7127,28 +7127,28 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) {
-                goto failed;
-            }
-            res = obj2ast_int(state, tmp, &level, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'ImportFrom' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_int(state, tmp, &level, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = ImportFrom(module, names, level, lineno, col_offset, end_lineno,
-                          end_col_offset, arena);
+        *out = ImportFrom(module, names, level, lineno, col_offset, end_lineno, 
+                          end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Global_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Global_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* names;
 
-        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7160,7 +7160,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Global field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7168,14 +7168,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (names == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 identifier val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Global' node")) {
-                    goto failed;
-                }
-                res = obj2ast_identifier(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Global' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_identifier(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Global field \"names\" changed size during iteration");
@@ -7185,20 +7185,20 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Global(names, lineno, col_offset, end_lineno, end_col_offset,
-                      arena);
+        *out = Global(names, lineno, col_offset, end_lineno, end_col_offset, 
+                      arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Nonlocal_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Nonlocal_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* names;
 
-        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->names, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7210,7 +7210,7 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Nonlocal field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Nonlocal field \"names\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7218,14 +7218,14 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             if (names == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 identifier val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Nonlocal' node")) {
-                    goto failed;
-                }
-                res = obj2ast_identifier(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Nonlocal' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_identifier(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Nonlocal field \"names\" changed size during iteration");
@@ -7235,20 +7235,20 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Nonlocal(names, lineno, col_offset, end_lineno, end_col_offset,
-                        arena);
+        *out = Nonlocal(names, lineno, col_offset, end_lineno, end_col_offset, 
+                        arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Expr_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Expr_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty value;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7257,49 +7257,49 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Expr' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Expr' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Expr(value, lineno, col_offset, end_lineno, end_col_offset,
-                    arena);
+        *out = Expr(value, lineno, col_offset, end_lineno, end_col_offset, 
+                    arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Pass_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Pass_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
 
-        *out = Pass(lineno, col_offset, end_lineno, end_col_offset, arena);
+        *out = Pass(lineno, col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Break_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Break_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
 
-        *out = Break(lineno, col_offset, end_lineno, end_col_offset, arena);
+        *out = Break(lineno, col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Continue_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Continue_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
 
-        *out = Continue(lineno, col_offset, end_lineno, end_col_offset, arena);
+        *out = Continue(lineno, col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
@@ -7311,22 +7311,22 @@ obj2ast_stmt(astmodulestate *state, PyObject* obj, stmt_ty* out, PyArena* arena)
 }
 
 int
-obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
+obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena) 
 {
     int isinstance;
 
     PyObject *tmp = NULL;
-    PyObject *tp;
+    PyObject *tp; 
     int lineno;
     int col_offset;
-    int end_lineno;
-    int end_col_offset;
+    int end_lineno; 
+    int end_col_offset; 
 
     if (obj == Py_None) {
         *out = NULL;
         return 0;
     }
-    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -7335,15 +7335,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &lineno, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &lineno, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -7352,50 +7352,50 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &col_offset, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_lineno = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_lineno, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_col_offset = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_col_offset, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    tp = state->BoolOp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_lineno = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_lineno, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_col_offset = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'expr' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    tp = state->BoolOp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7403,7 +7403,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         boolop_ty op;
         asdl_seq* values;
 
-        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7412,15 +7412,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) {
-                goto failed;
-            }
-            res = obj2ast_boolop(state, tmp, &op, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_boolop(state, tmp, &op, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7432,7 +7432,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "BoolOp field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7440,14 +7440,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (values == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'BoolOp' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "BoolOp field \"values\" changed size during iteration");
@@ -7457,61 +7457,61 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = BoolOp(op, values, lineno, col_offset, end_lineno,
-                      end_col_offset, arena);
-        if (*out == NULL) goto failed;
-        return 0;
-    }
-    tp = state->NamedExpr_type;
-    isinstance = PyObject_IsInstance(obj, tp);
-    if (isinstance == -1) {
-        return 1;
-    }
-    if (isinstance) {
-        expr_ty target;
-        expr_ty value;
-
-        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from NamedExpr");
-            return 1;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &target, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NamedExpr");
-            return 1;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = NamedExpr(target, value, lineno, col_offset, end_lineno,
-                         end_col_offset, arena);
+        *out = BoolOp(op, values, lineno, col_offset, end_lineno, 
+                      end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->BinOp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->NamedExpr_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
+    if (isinstance == -1) { 
+        return 1; 
+    } 
+    if (isinstance) { 
+        expr_ty target; 
+        expr_ty value; 
+ 
+        if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"target\" missing from NamedExpr"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &target, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from NamedExpr"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'NamedExpr' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = NamedExpr(target, value, lineno, col_offset, end_lineno, 
+                         end_col_offset, arena); 
+        if (*out == NULL) goto failed; 
+        return 0; 
+    } 
+    tp = state->BinOp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7520,7 +7520,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         operator_ty op;
         expr_ty right;
 
-        if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7529,15 +7529,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &left, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'BinOp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &left, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7546,15 +7546,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
-                goto failed;
-            }
-            res = obj2ast_operator(state, tmp, &op, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'BinOp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_operator(state, tmp, &op, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->right, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->right, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7563,21 +7563,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'BinOp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &right, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'BinOp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &right, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = BinOp(left, op, right, lineno, col_offset, end_lineno,
-                     end_col_offset, arena);
+        *out = BinOp(left, op, right, lineno, col_offset, end_lineno, 
+                     end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->UnaryOp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->UnaryOp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7585,7 +7585,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         unaryop_ty op;
         expr_ty operand;
 
-        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->op, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7594,15 +7594,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) {
-                goto failed;
-            }
-            res = obj2ast_unaryop(state, tmp, &op, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_unaryop(state, tmp, &op, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->operand, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->operand, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7611,21 +7611,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &operand, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'UnaryOp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &operand, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = UnaryOp(op, operand, lineno, col_offset, end_lineno,
-                       end_col_offset, arena);
+        *out = UnaryOp(op, operand, lineno, col_offset, end_lineno, 
+                       end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Lambda_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Lambda_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7633,7 +7633,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         arguments_ty args;
         expr_ty body;
 
-        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7642,15 +7642,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Lambda' node")) {
-                goto failed;
-            }
-            res = obj2ast_arguments(state, tmp, &args, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Lambda' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_arguments(state, tmp, &args, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7659,21 +7659,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Lambda' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &body, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Lambda' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &body, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Lambda(args, body, lineno, col_offset, end_lineno,
-                      end_col_offset, arena);
+        *out = Lambda(args, body, lineno, col_offset, end_lineno, 
+                      end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->IfExp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->IfExp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7682,7 +7682,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty body;
         expr_ty orelse;
 
-        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->test, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7691,15 +7691,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &test, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'IfExp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &test, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7708,15 +7708,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &body, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'IfExp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &body, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->orelse, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7725,21 +7725,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'IfExp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &orelse, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'IfExp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &orelse, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = IfExp(test, body, orelse, lineno, col_offset, end_lineno,
-                     end_col_offset, arena);
+        *out = IfExp(test, body, orelse, lineno, col_offset, end_lineno, 
+                     end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Dict_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Dict_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7747,7 +7747,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         asdl_seq* keys;
         asdl_seq* values;
 
-        if (_PyObject_LookupAttr(obj, state->keys, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->keys, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7759,7 +7759,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Dict field \"keys\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7767,14 +7767,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (keys == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Dict' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Dict' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Dict field \"keys\" changed size during iteration");
@@ -7784,7 +7784,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7796,7 +7796,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Dict field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7804,14 +7804,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (values == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Dict' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Dict' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Dict field \"values\" changed size during iteration");
@@ -7821,20 +7821,20 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Dict(keys, values, lineno, col_offset, end_lineno,
-                    end_col_offset, arena);
+        *out = Dict(keys, values, lineno, col_offset, end_lineno, 
+                    end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Set_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Set_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* elts;
 
-        if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7846,7 +7846,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Set field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7854,14 +7854,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (elts == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Set' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Set' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Set field \"elts\" changed size during iteration");
@@ -7871,12 +7871,12 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Set(elts, lineno, col_offset, end_lineno, end_col_offset, arena);
+        *out = Set(elts, lineno, col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->ListComp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->ListComp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7884,7 +7884,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty elt;
         asdl_seq* generators;
 
-        if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7893,15 +7893,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'ListComp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &elt, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'ListComp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &elt, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7913,7 +7913,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ListComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7921,14 +7921,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (generators == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 comprehension_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ListComp' node")) {
-                    goto failed;
-                }
-                res = obj2ast_comprehension(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ListComp' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_comprehension(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ListComp field \"generators\" changed size during iteration");
@@ -7938,13 +7938,13 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = ListComp(elt, generators, lineno, col_offset, end_lineno,
-                        end_col_offset, arena);
+        *out = ListComp(elt, generators, lineno, col_offset, end_lineno, 
+                        end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->SetComp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->SetComp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -7952,7 +7952,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty elt;
         asdl_seq* generators;
 
-        if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7961,15 +7961,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'SetComp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &elt, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'SetComp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &elt, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -7981,7 +7981,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "SetComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -7989,14 +7989,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (generators == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 comprehension_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'SetComp' node")) {
-                    goto failed;
-                }
-                res = obj2ast_comprehension(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'SetComp' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_comprehension(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "SetComp field \"generators\" changed size during iteration");
@@ -8006,13 +8006,13 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = SetComp(elt, generators, lineno, col_offset, end_lineno,
-                       end_col_offset, arena);
+        *out = SetComp(elt, generators, lineno, col_offset, end_lineno, 
+                       end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->DictComp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->DictComp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8021,7 +8021,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty value;
         asdl_seq* generators;
 
-        if (_PyObject_LookupAttr(obj, state->key, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->key, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8030,15 +8030,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &key, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'DictComp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &key, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8047,15 +8047,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'DictComp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8067,7 +8067,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "DictComp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8075,14 +8075,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (generators == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 comprehension_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'DictComp' node")) {
-                    goto failed;
-                }
-                res = obj2ast_comprehension(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'DictComp' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_comprehension(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "DictComp field \"generators\" changed size during iteration");
@@ -8092,13 +8092,13 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = DictComp(key, value, generators, lineno, col_offset, end_lineno,
-                        end_col_offset, arena);
+        *out = DictComp(key, value, generators, lineno, col_offset, end_lineno, 
+                        end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->GeneratorExp_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->GeneratorExp_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8106,7 +8106,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty elt;
         asdl_seq* generators;
 
-        if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->elt, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8115,15 +8115,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &elt, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &elt, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->generators, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8135,7 +8135,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "GeneratorExp field \"generators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8143,14 +8143,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (generators == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 comprehension_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) {
-                    goto failed;
-                }
-                res = obj2ast_comprehension(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'GeneratorExp' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_comprehension(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "GeneratorExp field \"generators\" changed size during iteration");
@@ -8160,20 +8160,20 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = GeneratorExp(elt, generators, lineno, col_offset, end_lineno,
-                            end_col_offset, arena);
+        *out = GeneratorExp(elt, generators, lineno, col_offset, end_lineno, 
+                            end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Await_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Await_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty value;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8182,28 +8182,28 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Await' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Await' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Await(value, lineno, col_offset, end_lineno, end_col_offset,
-                     arena);
+        *out = Await(value, lineno, col_offset, end_lineno, end_col_offset, 
+                     arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Yield_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Yield_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty value;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -8212,28 +8212,28 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Yield' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Yield' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Yield(value, lineno, col_offset, end_lineno, end_col_offset,
-                     arena);
+        *out = Yield(value, lineno, col_offset, end_lineno, end_col_offset, 
+                     arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->YieldFrom_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->YieldFrom_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty value;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8242,21 +8242,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'YieldFrom' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'YieldFrom' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = YieldFrom(value, lineno, col_offset, end_lineno, end_col_offset,
-                         arena);
+        *out = YieldFrom(value, lineno, col_offset, end_lineno, end_col_offset, 
+                         arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Compare_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Compare_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8265,7 +8265,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         asdl_int_seq* ops;
         asdl_seq* comparators;
 
-        if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->left, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8274,15 +8274,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &left, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Compare' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &left, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ops, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ops, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8294,7 +8294,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Compare field \"ops\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8302,14 +8302,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (ops == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 cmpop_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
-                    goto failed;
-                }
-                res = obj2ast_cmpop(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Compare' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_cmpop(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Compare field \"ops\" changed size during iteration");
@@ -8319,7 +8319,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->comparators, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->comparators, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8331,7 +8331,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Compare field \"comparators\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8339,14 +8339,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (comparators == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Compare' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Compare' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Compare field \"comparators\" changed size during iteration");
@@ -8356,13 +8356,13 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Compare(left, ops, comparators, lineno, col_offset, end_lineno,
-                       end_col_offset, arena);
+        *out = Compare(left, ops, comparators, lineno, col_offset, end_lineno, 
+                       end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Call_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Call_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8371,7 +8371,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         asdl_seq* args;
         asdl_seq* keywords;
 
-        if (_PyObject_LookupAttr(obj, state->func, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->func, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8380,15 +8380,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Call' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &func, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Call' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &func, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8400,7 +8400,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Call field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8408,14 +8408,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (args == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Call' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Call' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Call field \"args\" changed size during iteration");
@@ -8425,7 +8425,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->keywords, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8437,7 +8437,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Call field \"keywords\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8445,14 +8445,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (keywords == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 keyword_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Call' node")) {
-                    goto failed;
-                }
-                res = obj2ast_keyword(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Call' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_keyword(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Call field \"keywords\" changed size during iteration");
@@ -8462,13 +8462,13 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = Call(func, args, keywords, lineno, col_offset, end_lineno,
-                    end_col_offset, arena);
+        *out = Call(func, args, keywords, lineno, col_offset, end_lineno, 
+                    end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->FormattedValue_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->FormattedValue_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8477,7 +8477,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         int conversion;
         expr_ty format_spec;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8486,15 +8486,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->conversion, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->conversion, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -8503,15 +8503,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
-                goto failed;
-            }
-            res = obj2ast_int(state, tmp, &conversion, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_int(state, tmp, &conversion, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->format_spec, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->format_spec, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -8520,28 +8520,28 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &format_spec, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'FormattedValue' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &format_spec, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
         *out = FormattedValue(value, conversion, format_spec, lineno,
-                              col_offset, end_lineno, end_col_offset, arena);
+                              col_offset, end_lineno, end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->JoinedStr_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->JoinedStr_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         asdl_seq* values;
 
-        if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->values, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8553,7 +8553,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "JoinedStr field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "JoinedStr field \"values\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8561,14 +8561,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (values == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'JoinedStr' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'JoinedStr' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "JoinedStr field \"values\" changed size during iteration");
@@ -8578,61 +8578,61 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        *out = JoinedStr(values, lineno, col_offset, end_lineno,
-                         end_col_offset, arena);
+        *out = JoinedStr(values, lineno, col_offset, end_lineno, 
+                         end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Constant_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Constant_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
-        constant value;
-        string kind;
+        constant value; 
+        string kind; 
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Constant");
+            PyErr_SetString(PyExc_TypeError, "required field \"value\" missing from Constant"); 
             return 1;
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Constant' node")) {
-                goto failed;
-            }
-            res = obj2ast_constant(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Constant' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_constant(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->kind, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->kind, &tmp) < 0) { 
             return 1;
         }
-        if (tmp == NULL || tmp == Py_None) {
+        if (tmp == NULL || tmp == Py_None) { 
             Py_CLEAR(tmp);
-            kind = NULL;
+            kind = NULL; 
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Constant' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &kind, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Constant' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &kind, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Constant(value, kind, lineno, col_offset, end_lineno,
-                        end_col_offset, arena);
+        *out = Constant(value, kind, lineno, col_offset, end_lineno, 
+                        end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Attribute_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Attribute_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8641,7 +8641,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         identifier attr;
         expr_context_ty ctx;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8650,15 +8650,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Attribute' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->attr, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->attr, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8667,15 +8667,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &attr, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Attribute' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &attr, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8684,30 +8684,30 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Attribute' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr_context(state, tmp, &ctx, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Attribute' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr_context(state, tmp, &ctx, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Attribute(value, attr, ctx, lineno, col_offset, end_lineno,
-                         end_col_offset, arena);
+        *out = Attribute(value, attr, ctx, lineno, col_offset, end_lineno, 
+                         end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Subscript_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Subscript_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
         expr_ty value;
-        expr_ty slice;
+        expr_ty slice; 
         expr_context_ty ctx;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8716,15 +8716,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Subscript' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->slice, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->slice, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8733,15 +8733,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &slice, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Subscript' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &slice, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8750,21 +8750,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Subscript' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr_context(state, tmp, &ctx, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Subscript' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr_context(state, tmp, &ctx, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Subscript(value, slice, ctx, lineno, col_offset, end_lineno,
-                         end_col_offset, arena);
+        *out = Subscript(value, slice, ctx, lineno, col_offset, end_lineno, 
+                         end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Starred_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Starred_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8772,7 +8772,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty value;
         expr_context_ty ctx;
 
-        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8781,15 +8781,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Starred' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &value, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Starred' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &value, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8798,21 +8798,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Starred' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr_context(state, tmp, &ctx, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Starred' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr_context(state, tmp, &ctx, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Starred(value, ctx, lineno, col_offset, end_lineno,
-                       end_col_offset, arena);
+        *out = Starred(value, ctx, lineno, col_offset, end_lineno, 
+                       end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Name_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Name_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8820,7 +8820,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         identifier id;
         expr_context_ty ctx;
 
-        if (_PyObject_LookupAttr(obj, state->id, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->id, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8829,15 +8829,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Name' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &id, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Name' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &id, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8846,21 +8846,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Name' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr_context(state, tmp, &ctx, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Name' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr_context(state, tmp, &ctx, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Name(id, ctx, lineno, col_offset, end_lineno, end_col_offset,
-                    arena);
+        *out = Name(id, ctx, lineno, col_offset, end_lineno, end_col_offset, 
+                    arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->List_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->List_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8868,7 +8868,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         asdl_seq* elts;
         expr_context_ty ctx;
 
-        if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8880,7 +8880,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "List field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8888,14 +8888,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (elts == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'List' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'List' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "List field \"elts\" changed size during iteration");
@@ -8905,7 +8905,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8914,21 +8914,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'List' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr_context(state, tmp, &ctx, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'List' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr_context(state, tmp, &ctx, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = List(elts, ctx, lineno, col_offset, end_lineno, end_col_offset,
-                    arena);
+        *out = List(elts, ctx, lineno, col_offset, end_lineno, end_col_offset, 
+                    arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Tuple_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Tuple_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -8936,7 +8936,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         asdl_seq* elts;
         expr_context_ty ctx;
 
-        if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->elts, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8948,7 +8948,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "Tuple field \"elts\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -8956,14 +8956,14 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             if (elts == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 expr_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'Tuple' node")) {
-                    goto failed;
-                }
-                res = obj2ast_expr(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'Tuple' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_expr(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "Tuple field \"elts\" changed size during iteration");
@@ -8973,7 +8973,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
             }
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->ctx, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -8982,21 +8982,21 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Tuple' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr_context(state, tmp, &ctx, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Tuple' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr_context(state, tmp, &ctx, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Tuple(elts, ctx, lineno, col_offset, end_lineno, end_col_offset,
-                     arena);
+        *out = Tuple(elts, ctx, lineno, col_offset, end_lineno, end_col_offset, 
+                     arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-    tp = state->Slice_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    tp = state->Slice_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9005,7 +9005,7 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         expr_ty upper;
         expr_ty step;
 
-        if (_PyObject_LookupAttr(obj, state->lower, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->lower, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -9014,15 +9014,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &lower, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Slice' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &lower, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->upper, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->upper, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -9031,15 +9031,15 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &upper, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Slice' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &upper, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->step, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->step, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -9048,68 +9048,68 @@ obj2ast_expr(astmodulestate *state, PyObject* obj, expr_ty* out, PyArena* arena)
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'Slice' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &step, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'Slice' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &step, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        *out = Slice(lower, upper, step, lineno, col_offset, end_lineno,
-                     end_col_offset, arena);
+        *out = Slice(lower, upper, step, lineno, col_offset, end_lineno, 
+                     end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
-
-    PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj);
-    failed:
-    Py_XDECREF(tmp);
-    return 1;
-}
-
-int
-obj2ast_expr_context(astmodulestate *state, PyObject* obj, expr_context_ty*
-                     out, PyArena* arena)
-{
-    int isinstance;
-
-    isinstance = PyObject_IsInstance(obj, state->Load_type);
-    if (isinstance == -1) {
-        return 1;
-    }
-    if (isinstance) {
-        *out = Load;
-        return 0;
-    }
-    isinstance = PyObject_IsInstance(obj, state->Store_type);
+ 
+    PyErr_Format(PyExc_TypeError, "expected some sort of expr, but got %R", obj); 
+    failed: 
+    Py_XDECREF(tmp); 
+    return 1; 
+} 
+ 
+int 
+obj2ast_expr_context(astmodulestate *state, PyObject* obj, expr_context_ty* 
+                     out, PyArena* arena) 
+{ 
+    int isinstance; 
+ 
+    isinstance = PyObject_IsInstance(obj, state->Load_type); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
-        *out = Store;
+        *out = Load; 
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Del_type);
+    isinstance = PyObject_IsInstance(obj, state->Store_type); 
     if (isinstance == -1) {
         return 1;
     }
     if (isinstance) {
-        *out = Del;
+        *out = Store; 
         return 0;
     }
+    isinstance = PyObject_IsInstance(obj, state->Del_type); 
+    if (isinstance == -1) { 
+        return 1; 
+    } 
+    if (isinstance) { 
+        *out = Del; 
+        return 0; 
+    } 
 
-    PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %R", obj);
+    PyErr_Format(PyExc_TypeError, "expected some sort of expr_context, but got %R", obj); 
     return 1;
 }
 
 int
-obj2ast_boolop(astmodulestate *state, PyObject* obj, boolop_ty* out, PyArena*
-               arena)
+obj2ast_boolop(astmodulestate *state, PyObject* obj, boolop_ty* out, PyArena* 
+               arena) 
 {
     int isinstance;
 
-    isinstance = PyObject_IsInstance(obj, state->And_type);
+    isinstance = PyObject_IsInstance(obj, state->And_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9117,7 +9117,7 @@ obj2ast_boolop(astmodulestate *state, PyObject* obj, boolop_ty* out, PyArena*
         *out = And;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Or_type);
+    isinstance = PyObject_IsInstance(obj, state->Or_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9131,12 +9131,12 @@ obj2ast_boolop(astmodulestate *state, PyObject* obj, boolop_ty* out, PyArena*
 }
 
 int
-obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
-                 PyArena* arena)
+obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out, 
+                 PyArena* arena) 
 {
     int isinstance;
 
-    isinstance = PyObject_IsInstance(obj, state->Add_type);
+    isinstance = PyObject_IsInstance(obj, state->Add_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9144,7 +9144,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = Add;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Sub_type);
+    isinstance = PyObject_IsInstance(obj, state->Sub_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9152,7 +9152,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = Sub;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Mult_type);
+    isinstance = PyObject_IsInstance(obj, state->Mult_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9160,7 +9160,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = Mult;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->MatMult_type);
+    isinstance = PyObject_IsInstance(obj, state->MatMult_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9168,7 +9168,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = MatMult;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Div_type);
+    isinstance = PyObject_IsInstance(obj, state->Div_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9176,7 +9176,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = Div;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Mod_type);
+    isinstance = PyObject_IsInstance(obj, state->Mod_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9184,7 +9184,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = Mod;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Pow_type);
+    isinstance = PyObject_IsInstance(obj, state->Pow_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9192,7 +9192,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = Pow;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->LShift_type);
+    isinstance = PyObject_IsInstance(obj, state->LShift_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9200,7 +9200,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = LShift;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->RShift_type);
+    isinstance = PyObject_IsInstance(obj, state->RShift_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9208,7 +9208,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = RShift;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->BitOr_type);
+    isinstance = PyObject_IsInstance(obj, state->BitOr_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9216,7 +9216,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = BitOr;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->BitXor_type);
+    isinstance = PyObject_IsInstance(obj, state->BitXor_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9224,7 +9224,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = BitXor;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->BitAnd_type);
+    isinstance = PyObject_IsInstance(obj, state->BitAnd_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9232,7 +9232,7 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
         *out = BitAnd;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->FloorDiv_type);
+    isinstance = PyObject_IsInstance(obj, state->FloorDiv_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9246,12 +9246,12 @@ obj2ast_operator(astmodulestate *state, PyObject* obj, operator_ty* out,
 }
 
 int
-obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* out, PyArena*
-                arena)
+obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* out, PyArena* 
+                arena) 
 {
     int isinstance;
 
-    isinstance = PyObject_IsInstance(obj, state->Invert_type);
+    isinstance = PyObject_IsInstance(obj, state->Invert_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9259,7 +9259,7 @@ obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* out, PyArena*
         *out = Invert;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Not_type);
+    isinstance = PyObject_IsInstance(obj, state->Not_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9267,7 +9267,7 @@ obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* out, PyArena*
         *out = Not;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->UAdd_type);
+    isinstance = PyObject_IsInstance(obj, state->UAdd_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9275,7 +9275,7 @@ obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* out, PyArena*
         *out = UAdd;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->USub_type);
+    isinstance = PyObject_IsInstance(obj, state->USub_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9289,12 +9289,12 @@ obj2ast_unaryop(astmodulestate *state, PyObject* obj, unaryop_ty* out, PyArena*
 }
 
 int
-obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
-              arena)
+obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena* 
+              arena) 
 {
     int isinstance;
 
-    isinstance = PyObject_IsInstance(obj, state->Eq_type);
+    isinstance = PyObject_IsInstance(obj, state->Eq_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9302,7 +9302,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = Eq;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->NotEq_type);
+    isinstance = PyObject_IsInstance(obj, state->NotEq_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9310,7 +9310,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = NotEq;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Lt_type);
+    isinstance = PyObject_IsInstance(obj, state->Lt_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9318,7 +9318,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = Lt;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->LtE_type);
+    isinstance = PyObject_IsInstance(obj, state->LtE_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9326,7 +9326,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = LtE;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Gt_type);
+    isinstance = PyObject_IsInstance(obj, state->Gt_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9334,7 +9334,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = Gt;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->GtE_type);
+    isinstance = PyObject_IsInstance(obj, state->GtE_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9342,7 +9342,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = GtE;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->Is_type);
+    isinstance = PyObject_IsInstance(obj, state->Is_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9350,7 +9350,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = Is;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->IsNot_type);
+    isinstance = PyObject_IsInstance(obj, state->IsNot_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9358,7 +9358,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = IsNot;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->In_type);
+    isinstance = PyObject_IsInstance(obj, state->In_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9366,7 +9366,7 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
         *out = In;
         return 0;
     }
-    isinstance = PyObject_IsInstance(obj, state->NotIn_type);
+    isinstance = PyObject_IsInstance(obj, state->NotIn_type); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9380,8 +9380,8 @@ obj2ast_cmpop(astmodulestate *state, PyObject* obj, cmpop_ty* out, PyArena*
 }
 
 int
-obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
-                      out, PyArena* arena)
+obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty* 
+                      out, PyArena* arena) 
 {
     PyObject* tmp = NULL;
     expr_ty target;
@@ -9389,7 +9389,7 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
     asdl_seq* ifs;
     int is_async;
 
-    if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->target, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9398,15 +9398,15 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
-            goto failed;
-        }
-        res = obj2ast_expr(state, tmp, &target, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_expr(state, tmp, &target, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->iter, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9415,15 +9415,15 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
-            goto failed;
-        }
-        res = obj2ast_expr(state, tmp, &iter, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_expr(state, tmp, &iter, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->ifs, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->ifs, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9435,7 +9435,7 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
         Py_ssize_t len;
         Py_ssize_t i;
         if (!PyList_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+            PyErr_Format(PyExc_TypeError, "comprehension field \"ifs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
             goto failed;
         }
         len = PyList_GET_SIZE(tmp);
@@ -9443,14 +9443,14 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
         if (ifs == NULL) goto failed;
         for (i = 0; i < len; i++) {
             expr_ty val;
-            PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-            Py_INCREF(tmp2);
-            if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp2, &val, arena);
-            Py_LeaveRecursiveCall();
-            Py_DECREF(tmp2);
+            PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+            Py_INCREF(tmp2); 
+            if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp2, &val, arena); 
+            Py_LeaveRecursiveCall(); 
+            Py_DECREF(tmp2); 
             if (res != 0) goto failed;
             if (len != PyList_GET_SIZE(tmp)) {
                 PyErr_SetString(PyExc_RuntimeError, "comprehension field \"ifs\" changed size during iteration");
@@ -9460,7 +9460,7 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
         }
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->is_async, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->is_async, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9469,11 +9469,11 @@ obj2ast_comprehension(astmodulestate *state, PyObject* obj, comprehension_ty*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &is_async, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'comprehension' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &is_async, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
@@ -9485,23 +9485,23 @@ failed:
 }
 
 int
-obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
-                      out, PyArena* arena)
+obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty* 
+                      out, PyArena* arena) 
 {
     int isinstance;
 
     PyObject *tmp = NULL;
-    PyObject *tp;
+    PyObject *tp; 
     int lineno;
     int col_offset;
-    int end_lineno;
-    int end_col_offset;
+    int end_lineno; 
+    int end_col_offset; 
 
     if (obj == Py_None) {
         *out = NULL;
         return 0;
     }
-    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9510,15 +9510,15 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &lineno, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &lineno, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9527,50 +9527,50 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &col_offset, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_lineno = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_lineno, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_col_offset = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_col_offset, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    tp = state->ExceptHandler_type;
-    isinstance = PyObject_IsInstance(obj, tp);
+    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_lineno = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_lineno, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_col_offset = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'excepthandler' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    tp = state->ExceptHandler_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
     if (isinstance == -1) {
         return 1;
     }
@@ -9579,7 +9579,7 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
         identifier name;
         asdl_seq* body;
 
-        if (_PyObject_LookupAttr(obj, state->type, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->type, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -9588,15 +9588,15 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp, &type, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp, &type, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL || tmp == Py_None) {
@@ -9605,15 +9605,15 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
         }
         else {
             int res;
-            if (Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
-                goto failed;
-            }
-            res = obj2ast_identifier(state, tmp, &name, arena);
-            Py_LeaveRecursiveCall();
+            if (Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_identifier(state, tmp, &name, arena); 
+            Py_LeaveRecursiveCall(); 
             if (res != 0) goto failed;
             Py_CLEAR(tmp);
         }
-        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) {
+        if (_PyObject_LookupAttr(obj, state->body, &tmp) < 0) { 
             return 1;
         }
         if (tmp == NULL) {
@@ -9625,7 +9625,7 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
             Py_ssize_t len;
             Py_ssize_t i;
             if (!PyList_Check(tmp)) {
-                PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+                PyErr_Format(PyExc_TypeError, "ExceptHandler field \"body\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
                 goto failed;
             }
             len = PyList_GET_SIZE(tmp);
@@ -9633,14 +9633,14 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
             if (body == NULL) goto failed;
             for (i = 0; i < len; i++) {
                 stmt_ty val;
-                PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-                Py_INCREF(tmp2);
-                if (Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) {
-                    goto failed;
-                }
-                res = obj2ast_stmt(state, tmp2, &val, arena);
-                Py_LeaveRecursiveCall();
-                Py_DECREF(tmp2);
+                PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+                Py_INCREF(tmp2); 
+                if (Py_EnterRecursiveCall(" while traversing 'ExceptHandler' node")) { 
+                    goto failed; 
+                } 
+                res = obj2ast_stmt(state, tmp2, &val, arena); 
+                Py_LeaveRecursiveCall(); 
+                Py_DECREF(tmp2); 
                 if (res != 0) goto failed;
                 if (len != PyList_GET_SIZE(tmp)) {
                     PyErr_SetString(PyExc_RuntimeError, "ExceptHandler field \"body\" changed size during iteration");
@@ -9650,8 +9650,8 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
             }
             Py_CLEAR(tmp);
         }
-        *out = ExceptHandler(type, name, body, lineno, col_offset, end_lineno,
-                             end_col_offset, arena);
+        *out = ExceptHandler(type, name, body, lineno, col_offset, end_lineno, 
+                             end_col_offset, arena); 
         if (*out == NULL) goto failed;
         return 0;
     }
@@ -9663,11 +9663,11 @@ obj2ast_excepthandler(astmodulestate *state, PyObject* obj, excepthandler_ty*
 }
 
 int
-obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
-                  PyArena* arena)
+obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out, 
+                  PyArena* arena) 
 {
     PyObject* tmp = NULL;
-    asdl_seq* posonlyargs;
+    asdl_seq* posonlyargs; 
     asdl_seq* args;
     arg_ty vararg;
     asdl_seq* kwonlyargs;
@@ -9675,44 +9675,44 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
     arg_ty kwarg;
     asdl_seq* defaults;
 
-    if (_PyObject_LookupAttr(obj, state->posonlyargs, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL) {
-        PyErr_SetString(PyExc_TypeError, "required field \"posonlyargs\" missing from arguments");
-        return 1;
-    }
-    else {
-        int res;
-        Py_ssize_t len;
-        Py_ssize_t i;
-        if (!PyList_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "arguments field \"posonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
-            goto failed;
-        }
-        len = PyList_GET_SIZE(tmp);
-        posonlyargs = _Py_asdl_seq_new(len, arena);
-        if (posonlyargs == NULL) goto failed;
-        for (i = 0; i < len; i++) {
-            arg_ty val;
-            PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-            Py_INCREF(tmp2);
-            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-                goto failed;
-            }
-            res = obj2ast_arg(state, tmp2, &val, arena);
-            Py_LeaveRecursiveCall();
-            Py_DECREF(tmp2);
-            if (res != 0) goto failed;
-            if (len != PyList_GET_SIZE(tmp)) {
-                PyErr_SetString(PyExc_RuntimeError, "arguments field \"posonlyargs\" changed size during iteration");
-                goto failed;
-            }
-            asdl_seq_SET(posonlyargs, i, val);
-        }
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->posonlyargs, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL) { 
+        PyErr_SetString(PyExc_TypeError, "required field \"posonlyargs\" missing from arguments"); 
+        return 1; 
+    } 
+    else { 
+        int res; 
+        Py_ssize_t len; 
+        Py_ssize_t i; 
+        if (!PyList_Check(tmp)) { 
+            PyErr_Format(PyExc_TypeError, "arguments field \"posonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
+            goto failed; 
+        } 
+        len = PyList_GET_SIZE(tmp); 
+        posonlyargs = _Py_asdl_seq_new(len, arena); 
+        if (posonlyargs == NULL) goto failed; 
+        for (i = 0; i < len; i++) { 
+            arg_ty val; 
+            PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+            Py_INCREF(tmp2); 
+            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_arg(state, tmp2, &val, arena); 
+            Py_LeaveRecursiveCall(); 
+            Py_DECREF(tmp2); 
+            if (res != 0) goto failed; 
+            if (len != PyList_GET_SIZE(tmp)) { 
+                PyErr_SetString(PyExc_RuntimeError, "arguments field \"posonlyargs\" changed size during iteration"); 
+                goto failed; 
+            } 
+            asdl_seq_SET(posonlyargs, i, val); 
+        } 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->args, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9724,7 +9724,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         Py_ssize_t len;
         Py_ssize_t i;
         if (!PyList_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+            PyErr_Format(PyExc_TypeError, "arguments field \"args\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
             goto failed;
         }
         len = PyList_GET_SIZE(tmp);
@@ -9732,14 +9732,14 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         if (args == NULL) goto failed;
         for (i = 0; i < len; i++) {
             arg_ty val;
-            PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-            Py_INCREF(tmp2);
-            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-                goto failed;
-            }
-            res = obj2ast_arg(state, tmp2, &val, arena);
-            Py_LeaveRecursiveCall();
-            Py_DECREF(tmp2);
+            PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+            Py_INCREF(tmp2); 
+            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_arg(state, tmp2, &val, arena); 
+            Py_LeaveRecursiveCall(); 
+            Py_DECREF(tmp2); 
             if (res != 0) goto failed;
             if (len != PyList_GET_SIZE(tmp)) {
                 PyErr_SetString(PyExc_RuntimeError, "arguments field \"args\" changed size during iteration");
@@ -9749,7 +9749,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         }
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->vararg, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->vararg, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL || tmp == Py_None) {
@@ -9758,15 +9758,15 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-            goto failed;
-        }
-        res = obj2ast_arg(state, tmp, &vararg, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_arg(state, tmp, &vararg, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->kwonlyargs, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->kwonlyargs, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9778,7 +9778,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         Py_ssize_t len;
         Py_ssize_t i;
         if (!PyList_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "arguments field \"kwonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+            PyErr_Format(PyExc_TypeError, "arguments field \"kwonlyargs\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
             goto failed;
         }
         len = PyList_GET_SIZE(tmp);
@@ -9786,14 +9786,14 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         if (kwonlyargs == NULL) goto failed;
         for (i = 0; i < len; i++) {
             arg_ty val;
-            PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-            Py_INCREF(tmp2);
-            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-                goto failed;
-            }
-            res = obj2ast_arg(state, tmp2, &val, arena);
-            Py_LeaveRecursiveCall();
-            Py_DECREF(tmp2);
+            PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+            Py_INCREF(tmp2); 
+            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_arg(state, tmp2, &val, arena); 
+            Py_LeaveRecursiveCall(); 
+            Py_DECREF(tmp2); 
             if (res != 0) goto failed;
             if (len != PyList_GET_SIZE(tmp)) {
                 PyErr_SetString(PyExc_RuntimeError, "arguments field \"kwonlyargs\" changed size during iteration");
@@ -9803,7 +9803,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         }
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->kw_defaults, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->kw_defaults, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9815,7 +9815,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         Py_ssize_t len;
         Py_ssize_t i;
         if (!PyList_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "arguments field \"kw_defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+            PyErr_Format(PyExc_TypeError, "arguments field \"kw_defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
             goto failed;
         }
         len = PyList_GET_SIZE(tmp);
@@ -9823,14 +9823,14 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         if (kw_defaults == NULL) goto failed;
         for (i = 0; i < len; i++) {
             expr_ty val;
-            PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-            Py_INCREF(tmp2);
-            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp2, &val, arena);
-            Py_LeaveRecursiveCall();
-            Py_DECREF(tmp2);
+            PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+            Py_INCREF(tmp2); 
+            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp2, &val, arena); 
+            Py_LeaveRecursiveCall(); 
+            Py_DECREF(tmp2); 
             if (res != 0) goto failed;
             if (len != PyList_GET_SIZE(tmp)) {
                 PyErr_SetString(PyExc_RuntimeError, "arguments field \"kw_defaults\" changed size during iteration");
@@ -9840,7 +9840,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         }
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->kwarg, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->kwarg, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL || tmp == Py_None) {
@@ -9849,15 +9849,15 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-            goto failed;
-        }
-        res = obj2ast_arg(state, tmp, &kwarg, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_arg(state, tmp, &kwarg, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->defaults, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->defaults, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9869,7 +9869,7 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         Py_ssize_t len;
         Py_ssize_t i;
         if (!PyList_Check(tmp)) {
-            PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
+            PyErr_Format(PyExc_TypeError, "arguments field \"defaults\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); 
             goto failed;
         }
         len = PyList_GET_SIZE(tmp);
@@ -9877,14 +9877,14 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         if (defaults == NULL) goto failed;
         for (i = 0; i < len; i++) {
             expr_ty val;
-            PyObject *tmp2 = PyList_GET_ITEM(tmp, i);
-            Py_INCREF(tmp2);
-            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) {
-                goto failed;
-            }
-            res = obj2ast_expr(state, tmp2, &val, arena);
-            Py_LeaveRecursiveCall();
-            Py_DECREF(tmp2);
+            PyObject *tmp2 = PyList_GET_ITEM(tmp, i); 
+            Py_INCREF(tmp2); 
+            if (Py_EnterRecursiveCall(" while traversing 'arguments' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_expr(state, tmp2, &val, arena); 
+            Py_LeaveRecursiveCall(); 
+            Py_DECREF(tmp2); 
             if (res != 0) goto failed;
             if (len != PyList_GET_SIZE(tmp)) {
                 PyErr_SetString(PyExc_RuntimeError, "arguments field \"defaults\" changed size during iteration");
@@ -9894,8 +9894,8 @@ obj2ast_arguments(astmodulestate *state, PyObject* obj, arguments_ty* out,
         }
         Py_CLEAR(tmp);
     }
-    *out = arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg,
-                     defaults, arena);
+    *out = arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, 
+                     defaults, arena); 
     return 0;
 failed:
     Py_XDECREF(tmp);
@@ -9903,18 +9903,18 @@ failed:
 }
 
 int
-obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, PyArena* arena)
+obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, PyArena* arena) 
 {
     PyObject* tmp = NULL;
     identifier arg;
     expr_ty annotation;
-    string type_comment;
+    string type_comment; 
     int lineno;
     int col_offset;
-    int end_lineno;
-    int end_col_offset;
+    int end_lineno; 
+    int end_col_offset; 
 
-    if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9923,15 +9923,15 @@ obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_identifier(state, tmp, &arg, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_identifier(state, tmp, &arg, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->annotation, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL || tmp == Py_None) {
@@ -9940,32 +9940,32 @@ obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_expr(state, tmp, &annotation, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        type_comment = NULL;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_string(state, tmp, &type_comment, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_expr(state, tmp, &annotation, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->type_comment, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        type_comment = NULL; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_string(state, tmp, &type_comment, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9974,15 +9974,15 @@ obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &lineno, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &lineno, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -9991,50 +9991,50 @@ obj2ast_arg(astmodulestate *state, PyObject* obj, arg_ty* out, PyArena* arena)
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &col_offset, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_lineno = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_lineno, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_col_offset = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_col_offset, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    *out = arg(arg, annotation, type_comment, lineno, col_offset, end_lineno,
-               end_col_offset, arena);
+    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_lineno = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_lineno, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_col_offset = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'arg' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    *out = arg(arg, annotation, type_comment, lineno, col_offset, end_lineno, 
+               end_col_offset, arena); 
     return 0;
 failed:
     Py_XDECREF(tmp);
@@ -10042,18 +10042,18 @@ failed:
 }
 
 int
-obj2ast_keyword(astmodulestate *state, PyObject* obj, keyword_ty* out, PyArena*
-                arena)
+obj2ast_keyword(astmodulestate *state, PyObject* obj, keyword_ty* out, PyArena* 
+                arena) 
 {
     PyObject* tmp = NULL;
     identifier arg;
     expr_ty value;
-    int lineno;
-    int col_offset;
-    int end_lineno;
-    int end_col_offset;
+    int lineno; 
+    int col_offset; 
+    int end_lineno; 
+    int end_col_offset; 
 
-    if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->arg, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL || tmp == Py_None) {
@@ -10062,15 +10062,15 @@ obj2ast_keyword(astmodulestate *state, PyObject* obj, keyword_ty* out, PyArena*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
-            goto failed;
-        }
-        res = obj2ast_identifier(state, tmp, &arg, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_identifier(state, tmp, &arg, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->value, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -10079,84 +10079,84 @@ obj2ast_keyword(astmodulestate *state, PyObject* obj, keyword_ty* out, PyArena*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
-            goto failed;
-        }
-        res = obj2ast_expr(state, tmp, &value, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL) {
-        PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from keyword");
-        return 1;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &lineno, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL) {
-        PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from keyword");
-        return 1;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &col_offset, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_expr(state, tmp, &value, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_lineno = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_lineno, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) {
-        return 1;
-    }
-    if (tmp == NULL || tmp == Py_None) {
-        Py_CLEAR(tmp);
-        end_col_offset = 0;
-    }
-    else {
-        int res;
-        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) {
-            goto failed;
-        }
-        res = obj2ast_int(state, tmp, &end_col_offset, arena);
-        Py_LeaveRecursiveCall();
-        if (res != 0) goto failed;
-        Py_CLEAR(tmp);
-    }
-    *out = keyword(arg, value, lineno, col_offset, end_lineno, end_col_offset,
-                   arena);
+    if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL) { 
+        PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from keyword"); 
+        return 1; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &lineno, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->col_offset, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL) { 
+        PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from keyword"); 
+        return 1; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->end_lineno, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_lineno = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_lineno, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    if (_PyObject_LookupAttr(obj, state->end_col_offset, &tmp) < 0) { 
+        return 1; 
+    } 
+    if (tmp == NULL || tmp == Py_None) { 
+        Py_CLEAR(tmp); 
+        end_col_offset = 0; 
+    } 
+    else { 
+        int res; 
+        if (Py_EnterRecursiveCall(" while traversing 'keyword' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_int(state, tmp, &end_col_offset, arena); 
+        Py_LeaveRecursiveCall(); 
+        if (res != 0) goto failed; 
+        Py_CLEAR(tmp); 
+    } 
+    *out = keyword(arg, value, lineno, col_offset, end_lineno, end_col_offset, 
+                   arena); 
     return 0;
 failed:
     Py_XDECREF(tmp);
@@ -10164,14 +10164,14 @@ failed:
 }
 
 int
-obj2ast_alias(astmodulestate *state, PyObject* obj, alias_ty* out, PyArena*
-              arena)
+obj2ast_alias(astmodulestate *state, PyObject* obj, alias_ty* out, PyArena* 
+              arena) 
 {
     PyObject* tmp = NULL;
     identifier name;
     identifier asname;
 
-    if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -10180,15 +10180,15 @@ obj2ast_alias(astmodulestate *state, PyObject* obj, alias_ty* out, PyArena*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'alias' node")) {
-            goto failed;
-        }
-        res = obj2ast_identifier(state, tmp, &name, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'alias' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_identifier(state, tmp, &name, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->asname, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->asname, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL || tmp == Py_None) {
@@ -10197,11 +10197,11 @@ obj2ast_alias(astmodulestate *state, PyObject* obj, alias_ty* out, PyArena*
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'alias' node")) {
-            goto failed;
-        }
-        res = obj2ast_identifier(state, tmp, &asname, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'alias' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_identifier(state, tmp, &asname, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
@@ -10213,14 +10213,14 @@ failed:
 }
 
 int
-obj2ast_withitem(astmodulestate *state, PyObject* obj, withitem_ty* out,
-                 PyArena* arena)
+obj2ast_withitem(astmodulestate *state, PyObject* obj, withitem_ty* out, 
+                 PyArena* arena) 
 {
     PyObject* tmp = NULL;
     expr_ty context_expr;
     expr_ty optional_vars;
 
-    if (_PyObject_LookupAttr(obj, state->context_expr, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->context_expr, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL) {
@@ -10229,15 +10229,15 @@ obj2ast_withitem(astmodulestate *state, PyObject* obj, withitem_ty* out,
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'withitem' node")) {
-            goto failed;
-        }
-        res = obj2ast_expr(state, tmp, &context_expr, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'withitem' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_expr(state, tmp, &context_expr, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
-    if (_PyObject_LookupAttr(obj, state->optional_vars, &tmp) < 0) {
+    if (_PyObject_LookupAttr(obj, state->optional_vars, &tmp) < 0) { 
         return 1;
     }
     if (tmp == NULL || tmp == Py_None) {
@@ -10246,11 +10246,11 @@ obj2ast_withitem(astmodulestate *state, PyObject* obj, withitem_ty* out,
     }
     else {
         int res;
-        if (Py_EnterRecursiveCall(" while traversing 'withitem' node")) {
-            goto failed;
-        }
-        res = obj2ast_expr(state, tmp, &optional_vars, arena);
-        Py_LeaveRecursiveCall();
+        if (Py_EnterRecursiveCall(" while traversing 'withitem' node")) { 
+            goto failed; 
+        } 
+        res = obj2ast_expr(state, tmp, &optional_vars, arena); 
+        Py_LeaveRecursiveCall(); 
         if (res != 0) goto failed;
         Py_CLEAR(tmp);
     }
@@ -10261,568 +10261,568 @@ failed:
     return 1;
 }
 
-int
-obj2ast_type_ignore(astmodulestate *state, PyObject* obj, type_ignore_ty* out,
-                    PyArena* arena)
-{
-    int isinstance;
-
-    PyObject *tmp = NULL;
-    PyObject *tp;
-
-    if (obj == Py_None) {
-        *out = NULL;
-        return 0;
-    }
-    tp = state->TypeIgnore_type;
-    isinstance = PyObject_IsInstance(obj, tp);
-    if (isinstance == -1) {
-        return 1;
-    }
-    if (isinstance) {
-        int lineno;
-        string tag;
-
-        if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore");
-            return 1;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) {
-                goto failed;
-            }
-            res = obj2ast_int(state, tmp, &lineno, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        if (_PyObject_LookupAttr(obj, state->tag, &tmp) < 0) {
-            return 1;
-        }
-        if (tmp == NULL) {
-            PyErr_SetString(PyExc_TypeError, "required field \"tag\" missing from TypeIgnore");
-            return 1;
-        }
-        else {
-            int res;
-            if (Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) {
-                goto failed;
-            }
-            res = obj2ast_string(state, tmp, &tag, arena);
-            Py_LeaveRecursiveCall();
-            if (res != 0) goto failed;
-            Py_CLEAR(tmp);
-        }
-        *out = TypeIgnore(lineno, tag, arena);
-        if (*out == NULL) goto failed;
-        return 0;
-    }
-
-    PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %R", obj);
-    failed:
-    Py_XDECREF(tmp);
-    return 1;
-}
-
-
-static int
-astmodule_exec(PyObject *m)
-{
-    astmodulestate *state = get_ast_state(m);
-
-    if (!init_types(state)) {
-        return -1;
-    }
-    if (PyModule_AddObject(m, "AST", state->AST_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->AST_type);
-    if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) {
-        return -1;
-    }
-    if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) {
-        return -1;
-    }
-    if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) {
-        return -1;
-    }
-    if (PyModule_AddObject(m, "mod", state->mod_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->mod_type);
-    if (PyModule_AddObject(m, "Module", state->Module_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Module_type);
-    if (PyModule_AddObject(m, "Interactive", state->Interactive_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Interactive_type);
-    if (PyModule_AddObject(m, "Expression", state->Expression_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Expression_type);
-    if (PyModule_AddObject(m, "FunctionType", state->FunctionType_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->FunctionType_type);
-    if (PyModule_AddObject(m, "stmt", state->stmt_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->stmt_type);
-    if (PyModule_AddObject(m, "FunctionDef", state->FunctionDef_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->FunctionDef_type);
-    if (PyModule_AddObject(m, "AsyncFunctionDef", state->AsyncFunctionDef_type)
-        < 0) {
-        return -1;
-    }
-    Py_INCREF(state->AsyncFunctionDef_type);
-    if (PyModule_AddObject(m, "ClassDef", state->ClassDef_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->ClassDef_type);
-    if (PyModule_AddObject(m, "Return", state->Return_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Return_type);
-    if (PyModule_AddObject(m, "Delete", state->Delete_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Delete_type);
-    if (PyModule_AddObject(m, "Assign", state->Assign_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Assign_type);
-    if (PyModule_AddObject(m, "AugAssign", state->AugAssign_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->AugAssign_type);
-    if (PyModule_AddObject(m, "AnnAssign", state->AnnAssign_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->AnnAssign_type);
-    if (PyModule_AddObject(m, "For", state->For_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->For_type);
-    if (PyModule_AddObject(m, "AsyncFor", state->AsyncFor_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->AsyncFor_type);
-    if (PyModule_AddObject(m, "While", state->While_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->While_type);
-    if (PyModule_AddObject(m, "If", state->If_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->If_type);
-    if (PyModule_AddObject(m, "With", state->With_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->With_type);
-    if (PyModule_AddObject(m, "AsyncWith", state->AsyncWith_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->AsyncWith_type);
-    if (PyModule_AddObject(m, "Raise", state->Raise_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Raise_type);
-    if (PyModule_AddObject(m, "Try", state->Try_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Try_type);
-    if (PyModule_AddObject(m, "Assert", state->Assert_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Assert_type);
-    if (PyModule_AddObject(m, "Import", state->Import_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Import_type);
-    if (PyModule_AddObject(m, "ImportFrom", state->ImportFrom_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->ImportFrom_type);
-    if (PyModule_AddObject(m, "Global", state->Global_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Global_type);
-    if (PyModule_AddObject(m, "Nonlocal", state->Nonlocal_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Nonlocal_type);
-    if (PyModule_AddObject(m, "Expr", state->Expr_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Expr_type);
-    if (PyModule_AddObject(m, "Pass", state->Pass_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Pass_type);
-    if (PyModule_AddObject(m, "Break", state->Break_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Break_type);
-    if (PyModule_AddObject(m, "Continue", state->Continue_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Continue_type);
-    if (PyModule_AddObject(m, "expr", state->expr_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->expr_type);
-    if (PyModule_AddObject(m, "BoolOp", state->BoolOp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->BoolOp_type);
-    if (PyModule_AddObject(m, "NamedExpr", state->NamedExpr_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->NamedExpr_type);
-    if (PyModule_AddObject(m, "BinOp", state->BinOp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->BinOp_type);
-    if (PyModule_AddObject(m, "UnaryOp", state->UnaryOp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->UnaryOp_type);
-    if (PyModule_AddObject(m, "Lambda", state->Lambda_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Lambda_type);
-    if (PyModule_AddObject(m, "IfExp", state->IfExp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->IfExp_type);
-    if (PyModule_AddObject(m, "Dict", state->Dict_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Dict_type);
-    if (PyModule_AddObject(m, "Set", state->Set_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Set_type);
-    if (PyModule_AddObject(m, "ListComp", state->ListComp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->ListComp_type);
-    if (PyModule_AddObject(m, "SetComp", state->SetComp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->SetComp_type);
-    if (PyModule_AddObject(m, "DictComp", state->DictComp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->DictComp_type);
-    if (PyModule_AddObject(m, "GeneratorExp", state->GeneratorExp_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->GeneratorExp_type);
-    if (PyModule_AddObject(m, "Await", state->Await_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Await_type);
-    if (PyModule_AddObject(m, "Yield", state->Yield_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Yield_type);
-    if (PyModule_AddObject(m, "YieldFrom", state->YieldFrom_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->YieldFrom_type);
-    if (PyModule_AddObject(m, "Compare", state->Compare_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Compare_type);
-    if (PyModule_AddObject(m, "Call", state->Call_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Call_type);
-    if (PyModule_AddObject(m, "FormattedValue", state->FormattedValue_type) <
-        0) {
-        return -1;
-    }
-    Py_INCREF(state->FormattedValue_type);
-    if (PyModule_AddObject(m, "JoinedStr", state->JoinedStr_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->JoinedStr_type);
-    if (PyModule_AddObject(m, "Constant", state->Constant_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Constant_type);
-    if (PyModule_AddObject(m, "Attribute", state->Attribute_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Attribute_type);
-    if (PyModule_AddObject(m, "Subscript", state->Subscript_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Subscript_type);
-    if (PyModule_AddObject(m, "Starred", state->Starred_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Starred_type);
-    if (PyModule_AddObject(m, "Name", state->Name_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Name_type);
-    if (PyModule_AddObject(m, "List", state->List_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->List_type);
-    if (PyModule_AddObject(m, "Tuple", state->Tuple_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Tuple_type);
-    if (PyModule_AddObject(m, "Slice", state->Slice_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Slice_type);
-    if (PyModule_AddObject(m, "expr_context", state->expr_context_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->expr_context_type);
-    if (PyModule_AddObject(m, "Load", state->Load_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Load_type);
-    if (PyModule_AddObject(m, "Store", state->Store_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Store_type);
-    if (PyModule_AddObject(m, "Del", state->Del_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Del_type);
-    if (PyModule_AddObject(m, "boolop", state->boolop_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->boolop_type);
-    if (PyModule_AddObject(m, "And", state->And_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->And_type);
-    if (PyModule_AddObject(m, "Or", state->Or_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Or_type);
-    if (PyModule_AddObject(m, "operator", state->operator_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->operator_type);
-    if (PyModule_AddObject(m, "Add", state->Add_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Add_type);
-    if (PyModule_AddObject(m, "Sub", state->Sub_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Sub_type);
-    if (PyModule_AddObject(m, "Mult", state->Mult_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Mult_type);
-    if (PyModule_AddObject(m, "MatMult", state->MatMult_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->MatMult_type);
-    if (PyModule_AddObject(m, "Div", state->Div_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Div_type);
-    if (PyModule_AddObject(m, "Mod", state->Mod_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Mod_type);
-    if (PyModule_AddObject(m, "Pow", state->Pow_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Pow_type);
-    if (PyModule_AddObject(m, "LShift", state->LShift_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->LShift_type);
-    if (PyModule_AddObject(m, "RShift", state->RShift_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->RShift_type);
-    if (PyModule_AddObject(m, "BitOr", state->BitOr_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->BitOr_type);
-    if (PyModule_AddObject(m, "BitXor", state->BitXor_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->BitXor_type);
-    if (PyModule_AddObject(m, "BitAnd", state->BitAnd_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->BitAnd_type);
-    if (PyModule_AddObject(m, "FloorDiv", state->FloorDiv_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->FloorDiv_type);
-    if (PyModule_AddObject(m, "unaryop", state->unaryop_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->unaryop_type);
-    if (PyModule_AddObject(m, "Invert", state->Invert_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Invert_type);
-    if (PyModule_AddObject(m, "Not", state->Not_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Not_type);
-    if (PyModule_AddObject(m, "UAdd", state->UAdd_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->UAdd_type);
-    if (PyModule_AddObject(m, "USub", state->USub_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->USub_type);
-    if (PyModule_AddObject(m, "cmpop", state->cmpop_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->cmpop_type);
-    if (PyModule_AddObject(m, "Eq", state->Eq_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Eq_type);
-    if (PyModule_AddObject(m, "NotEq", state->NotEq_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->NotEq_type);
-    if (PyModule_AddObject(m, "Lt", state->Lt_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Lt_type);
-    if (PyModule_AddObject(m, "LtE", state->LtE_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->LtE_type);
-    if (PyModule_AddObject(m, "Gt", state->Gt_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Gt_type);
-    if (PyModule_AddObject(m, "GtE", state->GtE_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->GtE_type);
-    if (PyModule_AddObject(m, "Is", state->Is_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->Is_type);
-    if (PyModule_AddObject(m, "IsNot", state->IsNot_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->IsNot_type);
-    if (PyModule_AddObject(m, "In", state->In_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->In_type);
-    if (PyModule_AddObject(m, "NotIn", state->NotIn_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->NotIn_type);
-    if (PyModule_AddObject(m, "comprehension", state->comprehension_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->comprehension_type);
-    if (PyModule_AddObject(m, "excepthandler", state->excepthandler_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->excepthandler_type);
-    if (PyModule_AddObject(m, "ExceptHandler", state->ExceptHandler_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->ExceptHandler_type);
-    if (PyModule_AddObject(m, "arguments", state->arguments_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->arguments_type);
-    if (PyModule_AddObject(m, "arg", state->arg_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->arg_type);
-    if (PyModule_AddObject(m, "keyword", state->keyword_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->keyword_type);
-    if (PyModule_AddObject(m, "alias", state->alias_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->alias_type);
-    if (PyModule_AddObject(m, "withitem", state->withitem_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->withitem_type);
-    if (PyModule_AddObject(m, "type_ignore", state->type_ignore_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->type_ignore_type);
-    if (PyModule_AddObject(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
-        return -1;
-    }
-    Py_INCREF(state->TypeIgnore_type);
-    return 0;
-}
-
-static PyModuleDef_Slot astmodule_slots[] = {
-    {Py_mod_exec, astmodule_exec},
-    {0, NULL}
-};
-
+int 
+obj2ast_type_ignore(astmodulestate *state, PyObject* obj, type_ignore_ty* out, 
+                    PyArena* arena) 
+{ 
+    int isinstance; 
+
+    PyObject *tmp = NULL; 
+    PyObject *tp; 
+ 
+    if (obj == Py_None) { 
+        *out = NULL; 
+        return 0; 
+    } 
+    tp = state->TypeIgnore_type; 
+    isinstance = PyObject_IsInstance(obj, tp); 
+    if (isinstance == -1) { 
+        return 1; 
+    } 
+    if (isinstance) { 
+        int lineno; 
+        string tag; 
+ 
+        if (_PyObject_LookupAttr(obj, state->lineno, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from TypeIgnore"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_int(state, tmp, &lineno, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        if (_PyObject_LookupAttr(obj, state->tag, &tmp) < 0) { 
+            return 1; 
+        } 
+        if (tmp == NULL) { 
+            PyErr_SetString(PyExc_TypeError, "required field \"tag\" missing from TypeIgnore"); 
+            return 1; 
+        } 
+        else { 
+            int res; 
+            if (Py_EnterRecursiveCall(" while traversing 'TypeIgnore' node")) { 
+                goto failed; 
+            } 
+            res = obj2ast_string(state, tmp, &tag, arena); 
+            Py_LeaveRecursiveCall(); 
+            if (res != 0) goto failed; 
+            Py_CLEAR(tmp); 
+        } 
+        *out = TypeIgnore(lineno, tag, arena); 
+        if (*out == NULL) goto failed; 
+        return 0; 
+    } 
+ 
+    PyErr_Format(PyExc_TypeError, "expected some sort of type_ignore, but got %R", obj); 
+    failed: 
+    Py_XDECREF(tmp); 
+    return 1; 
+} 
+ 
+ 
+static int 
+astmodule_exec(PyObject *m) 
+{ 
+    astmodulestate *state = get_ast_state(m); 
+ 
+    if (!init_types(state)) { 
+        return -1; 
+    } 
+    if (PyModule_AddObject(m, "AST", state->AST_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->AST_type); 
+    if (PyModule_AddIntMacro(m, PyCF_ALLOW_TOP_LEVEL_AWAIT) < 0) { 
+        return -1; 
+    } 
+    if (PyModule_AddIntMacro(m, PyCF_ONLY_AST) < 0) { 
+        return -1; 
+    } 
+    if (PyModule_AddIntMacro(m, PyCF_TYPE_COMMENTS) < 0) { 
+        return -1; 
+    } 
+    if (PyModule_AddObject(m, "mod", state->mod_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->mod_type); 
+    if (PyModule_AddObject(m, "Module", state->Module_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Module_type); 
+    if (PyModule_AddObject(m, "Interactive", state->Interactive_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Interactive_type); 
+    if (PyModule_AddObject(m, "Expression", state->Expression_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Expression_type); 
+    if (PyModule_AddObject(m, "FunctionType", state->FunctionType_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->FunctionType_type); 
+    if (PyModule_AddObject(m, "stmt", state->stmt_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->stmt_type); 
+    if (PyModule_AddObject(m, "FunctionDef", state->FunctionDef_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->FunctionDef_type); 
+    if (PyModule_AddObject(m, "AsyncFunctionDef", state->AsyncFunctionDef_type) 
+        < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->AsyncFunctionDef_type); 
+    if (PyModule_AddObject(m, "ClassDef", state->ClassDef_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->ClassDef_type); 
+    if (PyModule_AddObject(m, "Return", state->Return_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Return_type); 
+    if (PyModule_AddObject(m, "Delete", state->Delete_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Delete_type); 
+    if (PyModule_AddObject(m, "Assign", state->Assign_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Assign_type); 
+    if (PyModule_AddObject(m, "AugAssign", state->AugAssign_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->AugAssign_type); 
+    if (PyModule_AddObject(m, "AnnAssign", state->AnnAssign_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->AnnAssign_type); 
+    if (PyModule_AddObject(m, "For", state->For_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->For_type); 
+    if (PyModule_AddObject(m, "AsyncFor", state->AsyncFor_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->AsyncFor_type); 
+    if (PyModule_AddObject(m, "While", state->While_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->While_type); 
+    if (PyModule_AddObject(m, "If", state->If_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->If_type); 
+    if (PyModule_AddObject(m, "With", state->With_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->With_type); 
+    if (PyModule_AddObject(m, "AsyncWith", state->AsyncWith_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->AsyncWith_type); 
+    if (PyModule_AddObject(m, "Raise", state->Raise_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Raise_type); 
+    if (PyModule_AddObject(m, "Try", state->Try_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Try_type); 
+    if (PyModule_AddObject(m, "Assert", state->Assert_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Assert_type); 
+    if (PyModule_AddObject(m, "Import", state->Import_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Import_type); 
+    if (PyModule_AddObject(m, "ImportFrom", state->ImportFrom_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->ImportFrom_type); 
+    if (PyModule_AddObject(m, "Global", state->Global_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Global_type); 
+    if (PyModule_AddObject(m, "Nonlocal", state->Nonlocal_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Nonlocal_type); 
+    if (PyModule_AddObject(m, "Expr", state->Expr_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Expr_type); 
+    if (PyModule_AddObject(m, "Pass", state->Pass_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Pass_type); 
+    if (PyModule_AddObject(m, "Break", state->Break_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Break_type); 
+    if (PyModule_AddObject(m, "Continue", state->Continue_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Continue_type); 
+    if (PyModule_AddObject(m, "expr", state->expr_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->expr_type); 
+    if (PyModule_AddObject(m, "BoolOp", state->BoolOp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->BoolOp_type); 
+    if (PyModule_AddObject(m, "NamedExpr", state->NamedExpr_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->NamedExpr_type); 
+    if (PyModule_AddObject(m, "BinOp", state->BinOp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->BinOp_type); 
+    if (PyModule_AddObject(m, "UnaryOp", state->UnaryOp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->UnaryOp_type); 
+    if (PyModule_AddObject(m, "Lambda", state->Lambda_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Lambda_type); 
+    if (PyModule_AddObject(m, "IfExp", state->IfExp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->IfExp_type); 
+    if (PyModule_AddObject(m, "Dict", state->Dict_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Dict_type); 
+    if (PyModule_AddObject(m, "Set", state->Set_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Set_type); 
+    if (PyModule_AddObject(m, "ListComp", state->ListComp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->ListComp_type); 
+    if (PyModule_AddObject(m, "SetComp", state->SetComp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->SetComp_type); 
+    if (PyModule_AddObject(m, "DictComp", state->DictComp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->DictComp_type); 
+    if (PyModule_AddObject(m, "GeneratorExp", state->GeneratorExp_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->GeneratorExp_type); 
+    if (PyModule_AddObject(m, "Await", state->Await_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Await_type); 
+    if (PyModule_AddObject(m, "Yield", state->Yield_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Yield_type); 
+    if (PyModule_AddObject(m, "YieldFrom", state->YieldFrom_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->YieldFrom_type); 
+    if (PyModule_AddObject(m, "Compare", state->Compare_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Compare_type); 
+    if (PyModule_AddObject(m, "Call", state->Call_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Call_type); 
+    if (PyModule_AddObject(m, "FormattedValue", state->FormattedValue_type) < 
+        0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->FormattedValue_type); 
+    if (PyModule_AddObject(m, "JoinedStr", state->JoinedStr_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->JoinedStr_type); 
+    if (PyModule_AddObject(m, "Constant", state->Constant_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Constant_type); 
+    if (PyModule_AddObject(m, "Attribute", state->Attribute_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Attribute_type); 
+    if (PyModule_AddObject(m, "Subscript", state->Subscript_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Subscript_type); 
+    if (PyModule_AddObject(m, "Starred", state->Starred_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Starred_type); 
+    if (PyModule_AddObject(m, "Name", state->Name_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Name_type); 
+    if (PyModule_AddObject(m, "List", state->List_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->List_type); 
+    if (PyModule_AddObject(m, "Tuple", state->Tuple_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Tuple_type); 
+    if (PyModule_AddObject(m, "Slice", state->Slice_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Slice_type); 
+    if (PyModule_AddObject(m, "expr_context", state->expr_context_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->expr_context_type); 
+    if (PyModule_AddObject(m, "Load", state->Load_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Load_type); 
+    if (PyModule_AddObject(m, "Store", state->Store_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Store_type); 
+    if (PyModule_AddObject(m, "Del", state->Del_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Del_type); 
+    if (PyModule_AddObject(m, "boolop", state->boolop_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->boolop_type); 
+    if (PyModule_AddObject(m, "And", state->And_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->And_type); 
+    if (PyModule_AddObject(m, "Or", state->Or_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Or_type); 
+    if (PyModule_AddObject(m, "operator", state->operator_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->operator_type); 
+    if (PyModule_AddObject(m, "Add", state->Add_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Add_type); 
+    if (PyModule_AddObject(m, "Sub", state->Sub_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Sub_type); 
+    if (PyModule_AddObject(m, "Mult", state->Mult_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Mult_type); 
+    if (PyModule_AddObject(m, "MatMult", state->MatMult_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->MatMult_type); 
+    if (PyModule_AddObject(m, "Div", state->Div_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Div_type); 
+    if (PyModule_AddObject(m, "Mod", state->Mod_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Mod_type); 
+    if (PyModule_AddObject(m, "Pow", state->Pow_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Pow_type); 
+    if (PyModule_AddObject(m, "LShift", state->LShift_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->LShift_type); 
+    if (PyModule_AddObject(m, "RShift", state->RShift_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->RShift_type); 
+    if (PyModule_AddObject(m, "BitOr", state->BitOr_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->BitOr_type); 
+    if (PyModule_AddObject(m, "BitXor", state->BitXor_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->BitXor_type); 
+    if (PyModule_AddObject(m, "BitAnd", state->BitAnd_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->BitAnd_type); 
+    if (PyModule_AddObject(m, "FloorDiv", state->FloorDiv_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->FloorDiv_type); 
+    if (PyModule_AddObject(m, "unaryop", state->unaryop_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->unaryop_type); 
+    if (PyModule_AddObject(m, "Invert", state->Invert_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Invert_type); 
+    if (PyModule_AddObject(m, "Not", state->Not_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Not_type); 
+    if (PyModule_AddObject(m, "UAdd", state->UAdd_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->UAdd_type); 
+    if (PyModule_AddObject(m, "USub", state->USub_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->USub_type); 
+    if (PyModule_AddObject(m, "cmpop", state->cmpop_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->cmpop_type); 
+    if (PyModule_AddObject(m, "Eq", state->Eq_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Eq_type); 
+    if (PyModule_AddObject(m, "NotEq", state->NotEq_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->NotEq_type); 
+    if (PyModule_AddObject(m, "Lt", state->Lt_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Lt_type); 
+    if (PyModule_AddObject(m, "LtE", state->LtE_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->LtE_type); 
+    if (PyModule_AddObject(m, "Gt", state->Gt_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Gt_type); 
+    if (PyModule_AddObject(m, "GtE", state->GtE_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->GtE_type); 
+    if (PyModule_AddObject(m, "Is", state->Is_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->Is_type); 
+    if (PyModule_AddObject(m, "IsNot", state->IsNot_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->IsNot_type); 
+    if (PyModule_AddObject(m, "In", state->In_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->In_type); 
+    if (PyModule_AddObject(m, "NotIn", state->NotIn_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->NotIn_type); 
+    if (PyModule_AddObject(m, "comprehension", state->comprehension_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->comprehension_type); 
+    if (PyModule_AddObject(m, "excepthandler", state->excepthandler_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->excepthandler_type); 
+    if (PyModule_AddObject(m, "ExceptHandler", state->ExceptHandler_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->ExceptHandler_type); 
+    if (PyModule_AddObject(m, "arguments", state->arguments_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->arguments_type); 
+    if (PyModule_AddObject(m, "arg", state->arg_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->arg_type); 
+    if (PyModule_AddObject(m, "keyword", state->keyword_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->keyword_type); 
+    if (PyModule_AddObject(m, "alias", state->alias_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->alias_type); 
+    if (PyModule_AddObject(m, "withitem", state->withitem_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->withitem_type); 
+    if (PyModule_AddObject(m, "type_ignore", state->type_ignore_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->type_ignore_type); 
+    if (PyModule_AddObject(m, "TypeIgnore", state->TypeIgnore_type) < 0) { 
+        return -1; 
+    } 
+    Py_INCREF(state->TypeIgnore_type); 
+    return 0; 
+} 
+ 
+static PyModuleDef_Slot astmodule_slots[] = { 
+    {Py_mod_exec, astmodule_exec}, 
+    {0, NULL} 
+}; 
+ 
 static struct PyModuleDef _astmodule = {
-    PyModuleDef_HEAD_INIT,
-    .m_name = "_ast",
-    // The _ast module uses a global state (global_ast_state).
-    .m_size = 0,
-    .m_slots = astmodule_slots,
+    PyModuleDef_HEAD_INIT, 
+    .m_name = "_ast", 
+    // The _ast module uses a global state (global_ast_state). 
+    .m_size = 0, 
+    .m_slots = astmodule_slots, 
 };
-
+ 
 PyMODINIT_FUNC
 PyInit__ast(void)
 {
-    return PyModuleDef_Init(&_astmodule);
+    return PyModuleDef_Init(&_astmodule); 
 }
 
 
 PyObject* PyAST_mod2obj(mod_ty t)
 {
-    astmodulestate *state = get_global_ast_state();
-    if (state == NULL) {
+    astmodulestate *state = get_global_ast_state(); 
+    if (state == NULL) { 
         return NULL;
-    }
-    return ast2obj_mod(state, t);
+    } 
+    return ast2obj_mod(state, t); 
 }
 
 /* mode is 0 for "exec", 1 for "eval" and 2 for "single" input */
 mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
 {
-    const char * const req_name[] = {"Module", "Expression", "Interactive"};
+    const char * const req_name[] = {"Module", "Expression", "Interactive"}; 
     int isinstance;
 
-    if (PySys_Audit("compile", "OO", ast, Py_None) < 0) {
-        return NULL;
-    }
-
-    astmodulestate *state = get_global_ast_state();
-    PyObject *req_type[3];
-    req_type[0] = state->Module_type;
-    req_type[1] = state->Expression_type;
-    req_type[2] = state->Interactive_type;
+    if (PySys_Audit("compile", "OO", ast, Py_None) < 0) { 
+        return NULL; 
+    } 
+ 
+    astmodulestate *state = get_global_ast_state(); 
+    PyObject *req_type[3]; 
+    req_type[0] = state->Module_type; 
+    req_type[1] = state->Expression_type; 
+    req_type[2] = state->Interactive_type; 
 
     assert(0 <= mode && mode <= 2);
 
@@ -10831,12 +10831,12 @@ mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
         return NULL;
     if (!isinstance) {
         PyErr_Format(PyExc_TypeError, "expected %s node, got %.400s",
-                     req_name[mode], _PyType_Name(Py_TYPE(ast)));
+                     req_name[mode], _PyType_Name(Py_TYPE(ast))); 
         return NULL;
     }
-
-    mod_ty res = NULL;
-    if (obj2ast_mod(state, ast, &res, arena) != 0)
+ 
+    mod_ty res = NULL; 
+    if (obj2ast_mod(state, ast, &res, arena) != 0) 
         return NULL;
     else
         return res;
@@ -10844,11 +10844,11 @@ mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode)
 
 int PyAST_Check(PyObject* obj)
 {
-    astmodulestate *state = get_global_ast_state();
-    if (state == NULL) {
+    astmodulestate *state = get_global_ast_state(); 
+    if (state == NULL) { 
         return -1;
-    }
-    return PyObject_IsInstance(obj, state->AST_type);
+    } 
+    return PyObject_IsInstance(obj, state->AST_type); 
 }