#include <stddef.h>

#include "Python.h"

#include "Python-ast.h"

#include "structmember.h"

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 *AugLoad_singleton;

PyObject *AugLoad_type;

PyObject *AugStore_singleton;

PyObject *AugStore_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 *ExtSlice_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 *Index_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 *Param_singleton;

PyObject *Param_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 *Suite_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 *__module__;

PyObject *_ast;

PyObject *_attributes;

PyObject *_fields;

PyObject *alias_type;

PyObject *annotation;

PyObject *arg;

PyObject *arg_type;

PyObject *args;

PyObject *argtypes;

PyObject *arguments_type;

PyObject *asname;

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 *dims;

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 *slice_type;

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;

#define astmodulestate(o) ((astmodulestate *)PyModule_GetState(o))

static int astmodule_clear(PyObject *module)

{

Py_CLEAR(astmodulestate(module)->AST_type);

Py_CLEAR(astmodulestate(module)->Add_singleton);

Py_CLEAR(astmodulestate(module)->Add_type);

Py_CLEAR(astmodulestate(module)->And_singleton);

Py_CLEAR(astmodulestate(module)->And_type);

Py_CLEAR(astmodulestate(module)->AnnAssign_type);

Py_CLEAR(astmodulestate(module)->Assert_type);

Py_CLEAR(astmodulestate(module)->Assign_type);

Py_CLEAR(astmodulestate(module)->AsyncFor_type);

Py_CLEAR(astmodulestate(module)->AsyncFunctionDef_type);

Py_CLEAR(astmodulestate(module)->AsyncWith_type);

Py_CLEAR(astmodulestate(module)->Attribute_type);

Py_CLEAR(astmodulestate(module)->AugAssign_type);

Py_CLEAR(astmodulestate(module)->AugLoad_singleton);

Py_CLEAR(astmodulestate(module)->AugLoad_type);

Py_CLEAR(astmodulestate(module)->AugStore_singleton);

Py_CLEAR(astmodulestate(module)->AugStore_type);

Py_CLEAR(astmodulestate(module)->Await_type);

Py_CLEAR(astmodulestate(module)->BinOp_type);

Py_CLEAR(astmodulestate(module)->BitAnd_singleton);

Py_CLEAR(astmodulestate(module)->BitAnd_type);

Py_CLEAR(astmodulestate(module)->BitOr_singleton);

Py_CLEAR(astmodulestate(module)->BitOr_type);

Py_CLEAR(astmodulestate(module)->BitXor_singleton);

Py_CLEAR(astmodulestate(module)->BitXor_type);

Py_CLEAR(astmodulestate(module)->BoolOp_type);

Py_CLEAR(astmodulestate(module)->Break_type);

Py_CLEAR(astmodulestate(module)->Call_type);

Py_CLEAR(astmodulestate(module)->ClassDef_type);

Py_CLEAR(astmodulestate(module)->Compare_type);

Py_CLEAR(astmodulestate(module)->Constant_type);

Py_CLEAR(astmodulestate(module)->Continue_type);

Py_CLEAR(astmodulestate(module)->Del_singleton);

Py_CLEAR(astmodulestate(module)->Del_type);

Py_CLEAR(astmodulestate(module)->Delete_type);

Py_CLEAR(astmodulestate(module)->DictComp_type);

Py_CLEAR(astmodulestate(module)->Dict_type);

Py_CLEAR(astmodulestate(module)->Div_singleton);

Py_CLEAR(astmodulestate(module)->Div_type);

Py_CLEAR(astmodulestate(module)->Eq_singleton);

Py_CLEAR(astmodulestate(module)->Eq_type);

Py_CLEAR(astmodulestate(module)->ExceptHandler_type);

Py_CLEAR(astmodulestate(module)->Expr_type);

Py_CLEAR(astmodulestate(module)->Expression_type);

Py_CLEAR(astmodulestate(module)->ExtSlice_type);

Py_CLEAR(astmodulestate(module)->FloorDiv_singleton);

Py_CLEAR(astmodulestate(module)->FloorDiv_type);

Py_CLEAR(astmodulestate(module)->For_type);

Py_CLEAR(astmodulestate(module)->FormattedValue_type);

Py_CLEAR(astmodulestate(module)->FunctionDef_type);

Py_CLEAR(astmodulestate(module)->FunctionType_type);

Py_CLEAR(astmodulestate(module)->GeneratorExp_type);

Py_CLEAR(astmodulestate(module)->Global_type);

Py_CLEAR(astmodulestate(module)->GtE_singleton);

Py_CLEAR(astmodulestate(module)->GtE_type);

Py_CLEAR(astmodulestate(module)->Gt_singleton);

Py_CLEAR(astmodulestate(module)->Gt_type);

Py_CLEAR(astmodulestate(module)->IfExp_type);

Py_CLEAR(astmodulestate(module)->If_type);

Py_CLEAR(astmodulestate(module)->ImportFrom_type);

Py_CLEAR(astmodulestate(module)->Import_type);

Py_CLEAR(astmodulestate(module)->In_singleton);

Py_CLEAR(astmodulestate(module)->In_type);

Py_CLEAR(astmodulestate(module)->Index_type);

Py_CLEAR(astmodulestate(module)->Interactive_type);

Py_CLEAR(astmodulestate(module)->Invert_singleton);

Py_CLEAR(astmodulestate(module)->Invert_type);

Py_CLEAR(astmodulestate(module)->IsNot_singleton);

Py_CLEAR(astmodulestate(module)->IsNot_type);

Py_CLEAR(astmodulestate(module)->Is_singleton);

Py_CLEAR(astmodulestate(module)->Is_type);

Py_CLEAR(astmodulestate(module)->JoinedStr_type);

Py_CLEAR(astmodulestate(module)->LShift_singleton);

Py_CLEAR(astmodulestate(module)->LShift_type);

Py_CLEAR(astmodulestate(module)->Lambda_type);

Py_CLEAR(astmodulestate(module)->ListComp_type);

Py_CLEAR(astmodulestate(module)->List_type);

Py_CLEAR(astmodulestate(module)->Load_singleton);

Py_CLEAR(astmodulestate(module)->Load_type);

Py_CLEAR(astmodulestate(module)->LtE_singleton);

Py_CLEAR(astmodulestate(module)->LtE_type);

Py_CLEAR(astmodulestate(module)->Lt_singleton);

Py_CLEAR(astmodulestate(module)->Lt_type);

Py_CLEAR(astmodulestate(module)->MatMult_singleton);

Py_CLEAR(astmodulestate(module)->MatMult_type);

Py_CLEAR(astmodulestate(module)->Mod_singleton);

Py_CLEAR(astmodulestate(module)->Mod_type);

Py_CLEAR(astmodulestate(module)->Module_type);

Py_CLEAR(astmodulestate(module)->Mult_singleton);

Py_CLEAR(astmodulestate(module)->Mult_type);

Py_CLEAR(astmodulestate(module)->Name_type);

Py_CLEAR(astmodulestate(module)->NamedExpr_type);

Py_CLEAR(astmodulestate(module)->Nonlocal_type);

Py_CLEAR(astmodulestate(module)->NotEq_singleton);

Py_CLEAR(astmodulestate(module)->NotEq_type);

Py_CLEAR(astmodulestate(module)->NotIn_singleton);

Py_CLEAR(astmodulestate(module)->NotIn_type);

Py_CLEAR(astmodulestate(module)->Not_singleton);

Py_CLEAR(astmodulestate(module)->Not_type);

Py_CLEAR(astmodulestate(module)->Or_singleton);

Py_CLEAR(astmodulestate(module)->Or_type);

Py_CLEAR(astmodulestate(module)->Param_singleton);

Py_CLEAR(astmodulestate(module)->Param_type);

Py_CLEAR(astmodulestate(module)->Pass_type);

Py_CLEAR(astmodulestate(module)->Pow_singleton);

Py_CLEAR(astmodulestate(module)->Pow_type);

Py_CLEAR(astmodulestate(module)->RShift_singleton);

Py_CLEAR(astmodulestate(module)->RShift_type);

Py_CLEAR(astmodulestate(module)->Raise_type);

Py_CLEAR(astmodulestate(module)->Return_type);

Py_CLEAR(astmodulestate(module)->SetComp_type);

Py_CLEAR(astmodulestate(module)->Set_type);

Py_CLEAR(astmodulestate(module)->Slice_type);

Py_CLEAR(astmodulestate(module)->Starred_type);

Py_CLEAR(astmodulestate(module)->Store_singleton);

Py_CLEAR(astmodulestate(module)->Store_type);

Py_CLEAR(astmodulestate(module)->Sub_singleton);

Py_CLEAR(astmodulestate(module)->Sub_type);

Py_CLEAR(astmodulestate(module)->Subscript_type);

Py_CLEAR(astmodulestate(module)->Suite_type);

Py_CLEAR(astmodulestate(module)->Try_type);

Py_CLEAR(astmodulestate(module)->Tuple_type);

Py_CLEAR(astmodulestate(module)->TypeIgnore_type);

Py_CLEAR(astmodulestate(module)->UAdd_singleton);

Py_CLEAR(astmodulestate(module)->UAdd_type);

Py_CLEAR(astmodulestate(module)->USub_singleton);

Py_CLEAR(astmodulestate(module)->USub_type);

Py_CLEAR(astmodulestate(module)->UnaryOp_type);

Py_CLEAR(astmodulestate(module)->While_type);

Py_CLEAR(astmodulestate(module)->With_type);

Py_CLEAR(astmodulestate(module)->YieldFrom_type);

Py_CLEAR(astmodulestate(module)->Yield_type);

Py_CLEAR(astmodulestate(module)->__dict__);

Py_CLEAR(astmodulestate(module)->__module__);

Py_CLEAR(astmodulestate(module)->_ast);

Py_CLEAR(astmodulestate(module)->_attributes);

Py_CLEAR(astmodulestate(module)->_fields);

Py_CLEAR(astmodulestate(module)->alias_type);

Py_CLEAR(astmodulestate(module)->annotation);

Py_CLEAR(astmodulestate(module)->arg);

Py_CLEAR(astmodulestate(module)->arg_type);

Py_CLEAR(astmodulestate(module)->args);

Py_CLEAR(astmodulestate(module)->argtypes);

Py_CLEAR(astmodulestate(module)->arguments_type);

Py_CLEAR(astmodulestate(module)->asname);

Py_CLEAR(astmodulestate(module)->attr);

Py_CLEAR(astmodulestate(module)->bases);

Py_CLEAR(astmodulestate(module)->body);

Py_CLEAR(astmodulestate(module)->boolop_type);

Py_CLEAR(astmodulestate(module)->cause);

Py_CLEAR(astmodulestate(module)->cmpop_type);

Py_CLEAR(astmodulestate(module)->col_offset);

Py_CLEAR(astmodulestate(module)->comparators);

Py_CLEAR(astmodulestate(module)->comprehension_type);

Py_CLEAR(astmodulestate(module)->context_expr);

Py_CLEAR(astmodulestate(module)->conversion);

Py_CLEAR(astmodulestate(module)->ctx);

Py_CLEAR(astmodulestate(module)->decorator_list);

Py_CLEAR(astmodulestate(module)->defaults);

Py_CLEAR(astmodulestate(module)->dims);

Py_CLEAR(astmodulestate(module)->elt);

Py_CLEAR(astmodulestate(module)->elts);

Py_CLEAR(astmodulestate(module)->end_col_offset);

Py_CLEAR(astmodulestate(module)->end_lineno);

Py_CLEAR(astmodulestate(module)->exc);

Py_CLEAR(astmodulestate(module)->excepthandler_type);

Py_CLEAR(astmodulestate(module)->expr_context_type);

Py_CLEAR(astmodulestate(module)->expr_type);

Py_CLEAR(astmodulestate(module)->finalbody);

Py_CLEAR(astmodulestate(module)->format_spec);

Py_CLEAR(astmodulestate(module)->func);

Py_CLEAR(astmodulestate(module)->generators);

Py_CLEAR(astmodulestate(module)->handlers);

Py_CLEAR(astmodulestate(module)->id);

Py_CLEAR(astmodulestate(module)->ifs);

Py_CLEAR(astmodulestate(module)->is_async);

Py_CLEAR(astmodulestate(module)->items);

Py_CLEAR(astmodulestate(module)->iter);

Py_CLEAR(astmodulestate(module)->key);

Py_CLEAR(astmodulestate(module)->keys);

Py_CLEAR(astmodulestate(module)->keyword_type);

Py_CLEAR(astmodulestate(module)->keywords);

Py_CLEAR(astmodulestate(module)->kind);

Py_CLEAR(astmodulestate(module)->kw_defaults);

Py_CLEAR(astmodulestate(module)->kwarg);

Py_CLEAR(astmodulestate(module)->kwonlyargs);

Py_CLEAR(astmodulestate(module)->left);

Py_CLEAR(astmodulestate(module)->level);

Py_CLEAR(astmodulestate(module)->lineno);

Py_CLEAR(astmodulestate(module)->lower);

Py_CLEAR(astmodulestate(module)->mod_type);

Py_CLEAR(astmodulestate(module)->module);

Py_CLEAR(astmodulestate(module)->msg);

Py_CLEAR(astmodulestate(module)->name);

Py_CLEAR(astmodulestate(module)->names);

Py_CLEAR(astmodulestate(module)->op);

Py_CLEAR(astmodulestate(module)->operand);

Py_CLEAR(astmodulestate(module)->operator_type);

Py_CLEAR(astmodulestate(module)->ops);

Py_CLEAR(astmodulestate(module)->optional_vars);

Py_CLEAR(astmodulestate(module)->orelse);

Py_CLEAR(astmodulestate(module)->posonlyargs);

Py_CLEAR(astmodulestate(module)->returns);

Py_CLEAR(astmodulestate(module)->right);

Py_CLEAR(astmodulestate(module)->simple);

Py_CLEAR(astmodulestate(module)->slice);

Py_CLEAR(astmodulestate(module)->slice_type);

Py_CLEAR(astmodulestate(module)->step);

Py_CLEAR(astmodulestate(module)->stmt_type);

Py_CLEAR(astmodulestate(module)->tag);

Py_CLEAR(astmodulestate(module)->target);

Py_CLEAR(astmodulestate(module)->targets);

Py_CLEAR(astmodulestate(module)->test);

Py_CLEAR(astmodulestate(module)->type);

Py_CLEAR(astmodulestate(module)->type_comment);

Py_CLEAR(astmodulestate(module)->type_ignore_type);

Py_CLEAR(astmodulestate(module)->type_ignores);

Py_CLEAR(astmodulestate(module)->unaryop_type);

Py_CLEAR(astmodulestate(module)->upper);

Py_CLEAR(astmodulestate(module)->value);

Py_CLEAR(astmodulestate(module)->values);

Py_CLEAR(astmodulestate(module)->vararg);

Py_CLEAR(astmodulestate(module)->withitem_type);

return 0;

}

static int astmodule_traverse(PyObject *module, visitproc visit, void* arg)

{

Py_VISIT(astmodulestate(module)->AST_type);

Py_VISIT(astmodulestate(module)->Add_singleton);

Py_VISIT(astmodulestate(module)->Add_type);

Py_VISIT(astmodulestate(module)->And_singleton);

Py_VISIT(astmodulestate(module)->And_type);

Py_VISIT(astmodulestate(module)->AnnAssign_type);

Py_VISIT(astmodulestate(module)->Assert_type);

Py_VISIT(astmodulestate(module)->Assign_type);

Py_VISIT(astmodulestate(module)->AsyncFor_type);

Py_VISIT(astmodulestate(module)->AsyncFunctionDef_type);

Py_VISIT(astmodulestate(module)->AsyncWith_type);

Py_VISIT(astmodulestate(module)->Attribute_type);

Py_VISIT(astmodulestate(module)->AugAssign_type);

Py_VISIT(astmodulestate(module)->AugLoad_singleton);

Py_VISIT(astmodulestate(module)->AugLoad_type);

Py_VISIT(astmodulestate(module)->AugStore_singleton);

Py_VISIT(astmodulestate(module)->AugStore_type);

Py_VISIT(astmodulestate(module)->Await_type);

Py_VISIT(astmodulestate(module)->BinOp_type);

Py_VISIT(astmodulestate(module)->BitAnd_singleton);

Py_VISIT(astmodulestate(module)->BitAnd_type);

Py_VISIT(astmodulestate(module)->BitOr_singleton);

Py_VISIT(astmodulestate(module)->BitOr_type);

Py_VISIT(astmodulestate(module)->BitXor_singleton);

Py_VISIT(astmodulestate(module)->BitXor_type);

Py_VISIT(astmodulestate(module)->BoolOp_type);

Py_VISIT(astmodulestate(module)->Break_type);

Py_VISIT(astmodulestate(module)->Call_type);

Py_VISIT(astmodulestate(module)->ClassDef_type);

Py_VISIT(astmodulestate(module)->Compare_type);

Py_VISIT(astmodulestate(module)->Constant_type);

Py_VISIT(astmodulestate(module)->Continue_type);

Py_VISIT(astmodulestate(module)->Del_singleton);

Py_VISIT(astmodulestate(module)->Del_type);

Py_VISIT(astmodulestate(module)->Delete_type);

Py_VISIT(astmodulestate(module)->DictComp_type);

Py_VISIT(astmodulestate(module)->Dict_type);

Py_VISIT(astmodulestate(module)->Div_singleton);

Py_VISIT(astmodulestate(module)->Div_type);

Py_VISIT(astmodulestate(module)->Eq_singleton);

Py_VISIT(astmodulestate(module)->Eq_type);

Py_VISIT(astmodulestate(module)->ExceptHandler_type);

Py_VISIT(astmodulestate(module)->Expr_type);

Py_VISIT(astmodulestate(module)->Expression_type);

Py_VISIT(astmodulestate(module)->ExtSlice_type);

Py_VISIT(astmodulestate(module)->FloorDiv_singleton);

Py_VISIT(astmodulestate(module)->FloorDiv_type);

Py_VISIT(astmodulestate(module)->For_type);

Py_VISIT(astmodulestate(module)->FormattedValue_type);

Py_VISIT(astmodulestate(module)->FunctionDef_type);

Py_VISIT(astmodulestate(module)->FunctionType_type);

Py_VISIT(astmodulestate(module)->GeneratorExp_type);

Py_VISIT(astmodulestate(module)->Global_type);

Py_VISIT(astmodulestate(module)->GtE_singleton);

Py_VISIT(astmodulestate(module)->GtE_type);

Py_VISIT(astmodulestate(module)->Gt_singleton);

Py_VISIT(astmodulestate(module)->Gt_type);

Py_VISIT(astmodulestate(module)->IfExp_type);

Py_VISIT(astmodulestate(module)->If_type);

Py_VISIT(astmodulestate(module)->ImportFrom_type);

Py_VISIT(astmodulestate(module)->Import_type);

Py_VISIT(astmodulestate(module)->In_singleton);

Py_VISIT(astmodulestate(module)->In_type);

Py_VISIT(astmodulestate(module)->Index_type);

Py_VISIT(astmodulestate(module)->Interactive_type);

Py_VISIT(astmodulestate(module)->Invert_singleton);

Py_VISIT(astmodulestate(module)->Invert_type);

Py_VISIT(astmodulestate(module)->IsNot_singleton);

Py_VISIT(astmodulestate(module)->IsNot_type);

Py_VISIT(astmodulestate(module)->Is_singleton);

Py_VISIT(astmodulestate(module)->Is_type);

Py_VISIT(astmodulestate(module)->JoinedStr_type);

Py_VISIT(astmodulestate(module)->LShift_singleton);

Py_VISIT(astmodulestate(module)->LShift_type);

Py_VISIT(astmodulestate(module)->Lambda_type);

Py_VISIT(astmodulestate(module)->ListComp_type);

Py_VISIT(astmodulestate(module)->List_type);

Py_VISIT(astmodulestate(module)->Load_singleton);

Py_VISIT(astmodulestate(module)->Load_type);

Py_VISIT(astmodulestate(module)->LtE_singleton);

Py_VISIT(astmodulestate(module)->LtE_type);

Py_VISIT(astmodulestate(module)->Lt_singleton);

Py_VISIT(astmodulestate(module)->Lt_type);

Py_VISIT(astmodulestate(module)->MatMult_singleton);

Py_VISIT(astmodulestate(module)->MatMult_type);

Py_VISIT(astmodulestate(module)->Mod_singleton);

Py_VISIT(astmodulestate(module)->Mod_type);

Py_VISIT(astmodulestate(module)->Module_type);

Py_VISIT(astmodulestate(module)->Mult_singleton);

Py_VISIT(astmodulestate(module)->Mult_type);

Py_VISIT(astmodulestate(module)->Name_type);

Py_VISIT(astmodulestate(module)->NamedExpr_type);

Py_VISIT(astmodulestate(module)->Nonlocal_type);

Py_VISIT(astmodulestate(module)->NotEq_singleton);

Py_VISIT(astmodulestate(module)->NotEq_type);

Py_VISIT(astmodulestate(module)->NotIn_singleton);

Py_VISIT(astmodulestate(module)->NotIn_type);

Py_VISIT(astmodulestate(module)->Not_singleton);

Py_VISIT(astmodulestate(module)->Not_type);

Py_VISIT(astmodulestate(module)->Or_singleton);

Py_VISIT(astmodulestate(module)->Or_type);

Py_VISIT(astmodulestate(module)->Param_singleton);

Py_VISIT(astmodulestate(module)->Param_type);

Py_VISIT(astmodulestate(module)->Pass_type);

Py_VISIT(astmodulestate(module)->Pow_singleton);

Py_VISIT(astmodulestate(module)->Pow_type);

Py_VISIT(astmodulestate(module)->RShift_singleton);

Py_VISIT(astmodulestate(module)->RShift_type);

Py_VISIT(astmodulestate(module)->Raise_type);

Py_VISIT(astmodulestate(module)->Return_type);

Py_VISIT(astmodulestate(module)->SetComp_type);

Py_VISIT(astmodulestate(module)->Set_type);

Py_VISIT(astmodulestate(module)->Slice_type);

Py_VISIT(astmodulestate(module)->Starred_type);

Py_VISIT(astmodulestate(module)->Store_singleton);

Py_VISIT(astmodulestate(module)->Store_type);

Py_VISIT(astmodulestate(module)->Sub_singleton);

Py_VISIT(astmodulestate(module)->Sub_type);

Py_VISIT(astmodulestate(module)->Subscript_type);

Py_VISIT(astmodulestate(module)->Suite_type);

Py_VISIT(astmodulestate(module)->Try_type);

Py_VISIT(astmodulestate(module)->Tuple_type);

Py_VISIT(astmodulestate(module)->TypeIgnore_type);

Py_VISIT(astmodulestate(module)->UAdd_singleton);

Py_VISIT(astmodulestate(module)->UAdd_type);

Py_VISIT(astmodulestate(module)->USub_singleton);

Py_VISIT(astmodulestate(module)->USub_type);

Py_VISIT(astmodulestate(module)->UnaryOp_type);

Py_VISIT(astmodulestate(module)->While_type);

Py_VISIT(astmodulestate(module)->With_type);

Py_VISIT(astmodulestate(module)->YieldFrom_type);

Py_VISIT(astmodulestate(module)->Yield_type);

Py_VISIT(astmodulestate(module)->__dict__);

Py_VISIT(astmodulestate(module)->__module__);

Py_VISIT(astmodulestate(module)->_ast);

Py_VISIT(astmodulestate(module)->_attributes);

Py_VISIT(astmodulestate(module)->_fields);

Py_VISIT(astmodulestate(module)->alias_type);

Py_VISIT(astmodulestate(module)->annotation);

Py_VISIT(astmodulestate(module)->arg);

Py_VISIT(astmodulestate(module)->arg_type);

Py_VISIT(astmodulestate(module)->args);

Py_VISIT(astmodulestate(module)->argtypes);

Py_VISIT(astmodulestate(module)->arguments_type);

Py_VISIT(astmodulestate(module)->asname);

Py_VISIT(astmodulestate(module)->attr);

Py_VISIT(astmodulestate(module)->bases);

Py_VISIT(astmodulestate(module)->body);

Py_VISIT(astmodulestate(module)->boolop_type);

Py_VISIT(astmodulestate(module)->cause);

Py_VISIT(astmodulestate(module)->cmpop_type);

Py_VISIT(astmodulestate(module)->col_offset);

Py_VISIT(astmodulestate(module)->comparators);

Py_VISIT(astmodulestate(module)->comprehension_type);

Py_VISIT(astmodulestate(module)->context_expr);

Py_VISIT(astmodulestate(module)->conversion);

Py_VISIT(astmodulestate(module)->ctx);

Py_VISIT(astmodulestate(module)->decorator_list);

Py_VISIT(astmodulestate(module)->defaults);

Py_VISIT(astmodulestate(module)->dims);

Py_VISIT(astmodulestate(module)->elt);

Py_VISIT(astmodulestate(module)->elts);

Py_VISIT(astmodulestate(module)->end_col_offset);

Py_VISIT(astmodulestate(module)->end_lineno);

Py_VISIT(astmodulestate(module)->exc);

Py_VISIT(astmodulestate(module)->excepthandler_type);

Py_VISIT(astmodulestate(module)->expr_context_type);

Py_VISIT(astmodulestate(module)->expr_type);

Py_VISIT(astmodulestate(module)->finalbody);

Py_VISIT(astmodulestate(module)->format_spec);

Py_VISIT(astmodulestate(module)->func);

Py_VISIT(astmodulestate(module)->generators);

Py_VISIT(astmodulestate(module)->handlers);

Py_VISIT(astmodulestate(module)->id);

Py_VISIT(astmodulestate(module)->ifs);

Py_VISIT(astmodulestate(module)->is_async);

Py_VISIT(astmodulestate(module)->items);

Py_VISIT(astmodulestate(module)->iter);

Py_VISIT(astmodulestate(module)->key);

Py_VISIT(astmodulestate(module)->keys);

Py_VISIT(astmodulestate(module)->keyword_type);

Py_VISIT(astmodulestate(module)->keywords);

Py_VISIT(astmodulestate(module)->kind);

Py_VISIT(astmodulestate(module)->kw_defaults);

Py_VISIT(astmodulestate(module)->kwarg);

Py_VISIT(astmodulestate(module)->kwonlyargs);

Py_VISIT(astmodulestate(module)->left);

Py_VISIT(astmodulestate(module)->level);

Py_VISIT(astmodulestate(module)->lineno);

Py_VISIT(astmodulestate(module)->lower);

Py_VISIT(astmodulestate(module)->mod_type);

Py_VISIT(astmodulestate(module)->module);

Py_VISIT(astmodulestate(module)->msg);

Py_VISIT(astmodulestate(module)->name);

Py_VISIT(astmodulestate(module)->names);

Py_VISIT(astmodulestate(module)->op);

Py_VISIT(astmodulestate(module)->operand);

Py_VISIT(astmodulestate(module)->operator_type);

Py_VISIT(astmodulestate(module)->ops);

Py_VISIT(astmodulestate(module)->optional_vars);

Py_VISIT(astmodulestate(module)->orelse);

Py_VISIT(astmodulestate(module)->posonlyargs);

Py_VISIT(astmodulestate(module)->returns);

Py_VISIT(astmodulestate(module)->right);

Py_VISIT(astmodulestate(module)->simple);

Py_VISIT(astmodulestate(module)->slice);

Py_VISIT(astmodulestate(module)->slice_type);

Py_VISIT(astmodulestate(module)->step);

Py_VISIT(astmodulestate(module)->stmt_type);

Py_VISIT(astmodulestate(module)->tag);

Py_VISIT(astmodulestate(module)->target);

Py_VISIT(astmodulestate(module)->targets);

Py_VISIT(astmodulestate(module)->test);

Py_VISIT(astmodulestate(module)->type);

Py_VISIT(astmodulestate(module)->type_comment);

Py_VISIT(astmodulestate(module)->type_ignore_type);

Py_VISIT(astmodulestate(module)->type_ignores);

Py_VISIT(astmodulestate(module)->unaryop_type);

Py_VISIT(astmodulestate(module)->upper);

Py_VISIT(astmodulestate(module)->value);

Py_VISIT(astmodulestate(module)->values);

Py_VISIT(astmodulestate(module)->vararg);

Py_VISIT(astmodulestate(module)->withitem_type);

return 0;

}

static void astmodule_free(void* module) {

astmodule_clear((PyObject*)module);

}

static struct PyModuleDef _astmodule = {

PyModuleDef_HEAD_INIT,

"_ast",

NULL,

sizeof(astmodulestate),

NULL,

NULL,

astmodule_traverse,

astmodule_clear,

astmodule_free,

};

#define astmodulestate_global ((astmodulestate *)PyModule_GetState(PyState_FindModule(&_astmodule)))

static int init_identifiers(void)

{

astmodulestate *state = astmodulestate_global;

if ((state->__dict__ = PyUnicode_InternFromString("__dict__")) == NULL) return 0;

if ((state->__module__ = PyUnicode_InternFromString("__module__")) == NULL) return 0;

if ((state->_ast = PyUnicode_InternFromString("_ast")) == 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->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->dims = PyUnicode_InternFromString("dims")) == 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(void*);

static const char * const Module_fields[]={

"body",

"type_ignores",

};

static const char * const Interactive_fields[]={

"body",

};

static const char * const Expression_fields[]={

"body",

};

static const char * const FunctionType_fields[]={

"argtypes",

"returns",

};

static const char * const Suite_fields[]={

"body",

};

static const char * const stmt_attributes[] = {

"lineno",

"col_offset",

"end_lineno",

"end_col_offset",

};

static PyObject* ast2obj_stmt(void*);

static const char * const FunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

"type_comment",

};

static const char * const AsyncFunctionDef_fields[]={

"name",

"args",

"body",

"decorator_list",

"returns",

"type_comment",

};

static const char * const ClassDef_fields[]={

"name",

"bases",

"keywords",

"body",

"decorator_list",

};

static const char * const Return_fields[]={

"value",

};

static const char * const Delete_fields[]={

"targets",

};

static const char * const Assign_fields[]={

"targets",

"value",

"type_comment",

};

static const char * const AugAssign_fields[]={

"target",

"op",

"value",

};

static const char * const AnnAssign_fields[]={

"target",

"annotation",

"value",

"simple",

};

static const char * const For_fields[]={

"target",

"iter",

"body",

"orelse",

"type_comment",

};

static const char * const AsyncFor_fields[]={

"target",

"iter",

"body",

"orelse",

"type_comment",

};

static const char * const While_fields[]={

"test",

"body",

"orelse",

};

static const char * const If_fields[]={

"test",

"body",

"orelse",

};

static const char * const With_fields[]={

"items",

"body",

"type_comment",

};

static const char * const AsyncWith_fields[]={

"items",

"body",

"type_comment",

};

static const char * const Raise_fields[]={

"exc",

"cause",

};

static const char * const Try_fields[]={

"body",

"handlers",

"orelse",

"finalbody",