#include <string.h>
#include "cdefs.h"
extern cptr identifier_methods[meth_max];
extern cptr idstring_methods[meth_max];
extern cptr integer_methods[meth_max];
extern cptr sstring_methods[meth_max];
extern int Start_col;
extern int Curr_line_num;

cptr Saved_start_col;
cptr Saved_curr_line_num;

cptr Coutdent;
cptr Cendif;
cptr CList_range;
cptr CSet_srange;
cptr Crepeat_until;
cptr Cprecondition;
cptr Cminus_assign;
cptr Celsif;
cptr Cexponentiate;
cptr Csc_or;
cptr CDeclare_typed_params;
cptr Cmake_elist;
cptr Ctoken;
cptr CPutcol_expression;
cptr Cminus;
cptr Cwhile_loop;
cptr Cget;
cptr CMap_constructor;
cptr Cmulti_exit;
cptr CCall_c_func;
cptr Cstart_list;
cptr Cnew;
cptr Ccodomain;
cptr Cmake_nested_iterator;
cptr Ctransitive;
cptr Cmake_set;
cptr Cnot;
cptr CCurr_line_num;
cptr CSet_constructor;
cptr Cevaluate;
cptr Cdivide_assign;
cptr Cadd_statement;
cptr Cmake_selector;
cptr Cfor_loop;
cptr CLength;
cptr Cmultiply_assign;
cptr Cfunction;
cptr Cmake_iterator;
cptr Csc_and;
cptr Cconstant;
cptr Citerator;
cptr Cnegate;
cptr Cdivide;
cptr CString;
cptr Cappend;
cptr Cpowerset;
cptr CSet_literal;
cptr CList_srange;
cptr Cdomain;
cptr Cset_attribute;
cptr Cmultiply;
cptr CResult;
cptr CExport;
cptr Cindent;
cptr Cmake_filter;
cptr Cassign;
cptr Cadd_to_list;
cptr Cmodule;
cptr CPair;
cptr Cpostcondition;
cptr Cforany;
cptr Cassert;
cptr Csc_if_def;
cptr CDeclare_params;
cptr Cend_parlist;
cptr Csubset;
cptr CSet_range;
cptr Crepeat_loop;
cptr Cimport;
cptr Ccall;
cptr CMake_type;
cptr Creturn;
cptr CPut_space;
cptr CPut_comma;
cptr Cwhile_until;
cptr Cplus_assign;
cptr Celse;
cptr CStart_col;
cptr Cdeclare_as_var;
cptr Cmake_eset;
cptr Cwhen;
cptr Cmake_name_list;
cptr Cexit;
cptr Cmake_list;
cptr Cmake_parameter;
cptr Clazy;
cptr Cresult_type;
cptr Ccond_expr;
cptr CList_constructor;
cptr Cplus;
cptr CTokstring;
cptr Cgenerator;
cptr Cdec_ref;
cptr CC_const;
cptr Cprocedure;
cptr Cinvariant;
cptr Cge;
cptr CTokname;
cptr Cif;
cptr Cle;
cptr Cfor_until;
cptr Cintersect;
cptr Ceq;
cptr Cin;
cptr CPut_eol;
cptr CQualify;
cptr Cgt;
cptr Cend_statements;
cptr Ccheck_indent;
cptr Clt;
cptr CFcall;
cptr CList_literal;
cptr CPut_expression;
cptr Clist_of;
cptr CStart_of_put;
cptr Cforsome;

void import_cbuilder(){}

int Init_cbuilder(){
  CTokname = mem_malloc(identifier_methods[0]);
  CTokname[0] = identifier_methods;
  identifier_alloc(CTokname, "Tokname");
  CTokstring = mem_malloc(identifier_methods[0]);
  CTokstring[0] = identifier_methods;
  identifier_alloc(CTokstring, "Tokstring");
  CStart_col = mem_malloc(identifier_methods[0]);
  CStart_col[0] = identifier_methods;
  identifier_alloc(CStart_col, "Start_col");
  CCurr_line_num = mem_malloc(identifier_methods[0]);
  CCurr_line_num[0] = identifier_methods;
  identifier_alloc(CCurr_line_num, "Curr_line_num");
  Coutdent = mem_malloc(identifier_methods[0]);
  Coutdent[0] = identifier_methods;
  identifier_alloc(Coutdent, "Build_outdent");
  Cendif = mem_malloc(identifier_methods[0]);
  Cendif[0] = identifier_methods;
  identifier_alloc(Cendif, "Build_endif");
  CList_range = mem_malloc(identifier_methods[0]);
  CList_range[0] = identifier_methods;
  identifier_alloc(CList_range, "Build_list_range");
  CSet_srange = mem_malloc(identifier_methods[0]);
  CSet_srange[0] = identifier_methods;
  identifier_alloc(CSet_srange, "Build_set_srange");
  Crepeat_until = mem_malloc(identifier_methods[0]);
  Crepeat_until[0] = identifier_methods;
  identifier_alloc(Crepeat_until, "Build_repeat_until");
  Cprecondition = mem_malloc(identifier_methods[0]);
  Cprecondition[0] = identifier_methods;
  identifier_alloc(Cprecondition, "Build_precondition");
  Cminus_assign = mem_malloc(identifier_methods[0]);
  Cminus_assign[0] = identifier_methods;
  identifier_alloc(Cminus_assign, "Build_minus_assign");
  Celsif = mem_malloc(identifier_methods[0]);
  Celsif[0] = identifier_methods;
  identifier_alloc(Celsif, "Build_elsif");
  Cexponentiate = mem_malloc(identifier_methods[0]);
  Cexponentiate[0] = identifier_methods;
  identifier_alloc(Cexponentiate, "Build_exponentiate");
  Csc_or = mem_malloc(identifier_methods[0]);
  Csc_or[0] = identifier_methods;
  identifier_alloc(Csc_or, "Build_sc_or");
  CDeclare_typed_params = mem_malloc(identifier_methods[0]);
  CDeclare_typed_params[0] = identifier_methods;
  identifier_alloc(CDeclare_typed_params, "Build_declare_typed_params");
  Cmake_elist = mem_malloc(identifier_methods[0]);
  Cmake_elist[0] = identifier_methods;
  identifier_alloc(Cmake_elist, "Build_make_elist");
  Ctoken = mem_malloc(identifier_methods[0]);
  Ctoken[0] = identifier_methods;
  identifier_alloc(Ctoken, "Build_token");
  CPutcol_expression = mem_malloc(identifier_methods[0]);
  CPutcol_expression[0] = identifier_methods;
  identifier_alloc(CPutcol_expression, "Build_putcol_expression");
  Cminus = mem_malloc(identifier_methods[0]);
  Cminus[0] = identifier_methods;
  identifier_alloc(Cminus, "Build_minus");
  Cwhile_loop = mem_malloc(identifier_methods[0]);
  Cwhile_loop[0] = identifier_methods;
  identifier_alloc(Cwhile_loop, "Build_while_loop");
  Cget = mem_malloc(identifier_methods[0]);
  Cget[0] = identifier_methods;
  identifier_alloc(Cget, "Build_get");
  CMap_constructor = mem_malloc(identifier_methods[0]);
  CMap_constructor[0] = identifier_methods;
  identifier_alloc(CMap_constructor, "Build_map_constructor");
  Cmulti_exit = mem_malloc(identifier_methods[0]);
  Cmulti_exit[0] = identifier_methods;
  identifier_alloc(Cmulti_exit, "Build_multi_exit");
  CCall_c_func = mem_malloc(identifier_methods[0]);
  CCall_c_func[0] = identifier_methods;
  identifier_alloc(CCall_c_func, "Build_call_c_func");
  Cstart_list = mem_malloc(identifier_methods[0]);
  Cstart_list[0] = identifier_methods;
  identifier_alloc(Cstart_list, "Build_start_list");
  Cnew = mem_malloc(identifier_methods[0]);
  Cnew[0] = identifier_methods;
  identifier_alloc(Cnew, "Build_new");
  Ccodomain = mem_malloc(identifier_methods[0]);
  Ccodomain[0] = identifier_methods;
  identifier_alloc(Ccodomain, "Build_codomain");
  Cmake_nested_iterator = mem_malloc(identifier_methods[0]);
  Cmake_nested_iterator[0] = identifier_methods;
  identifier_alloc(Cmake_nested_iterator, "Build_make_nested_iterator");
  Ctransitive = mem_malloc(identifier_methods[0]);
  Ctransitive[0] = identifier_methods;
  identifier_alloc(Ctransitive, "Build_transitive");
  Cmake_set = mem_malloc(identifier_methods[0]);
  Cmake_set[0] = identifier_methods;
  identifier_alloc(Cmake_set, "Build_make_set");
  Cnot = mem_malloc(identifier_methods[0]);
  Cnot[0] = identifier_methods;
  identifier_alloc(Cnot, "Build_not");
  CSet_constructor = mem_malloc(identifier_methods[0]);
  CSet_constructor[0] = identifier_methods;
  identifier_alloc(CSet_constructor, "Build_set_constructor");
  Cevaluate = mem_malloc(identifier_methods[0]);
  Cevaluate[0] = identifier_methods;
  identifier_alloc(Cevaluate, "Build_evaluate");
  Cdivide_assign = mem_malloc(identifier_methods[0]);
  Cdivide_assign[0] = identifier_methods;
  identifier_alloc(Cdivide_assign, "Build_divide_assign");
  Cadd_statement = mem_malloc(identifier_methods[0]);
  Cadd_statement[0] = identifier_methods;
  identifier_alloc(Cadd_statement, "Build_add_statement");
  Cmake_selector = mem_malloc(identifier_methods[0]);
  Cmake_selector[0] = identifier_methods;
  identifier_alloc(Cmake_selector, "Build_make_selector");
  Cfor_loop = mem_malloc(identifier_methods[0]);
  Cfor_loop[0] = identifier_methods;
  identifier_alloc(Cfor_loop, "Build_for_loop");
  CLength = mem_malloc(identifier_methods[0]);
  CLength[0] = identifier_methods;
  identifier_alloc(CLength, "Build_length");
  Cmultiply_assign = mem_malloc(identifier_methods[0]);
  Cmultiply_assign[0] = identifier_methods;
  identifier_alloc(Cmultiply_assign, "Build_multiply_assign");
  Cfunction = mem_malloc(identifier_methods[0]);
  Cfunction[0] = identifier_methods;
  identifier_alloc(Cfunction, "Build_function");
  Cmake_iterator = mem_malloc(identifier_methods[0]);
  Cmake_iterator[0] = identifier_methods;
  identifier_alloc(Cmake_iterator, "Build_make_iterator");
  Csc_and = mem_malloc(identifier_methods[0]);
  Csc_and[0] = identifier_methods;
  identifier_alloc(Csc_and, "Build_sc_and");
  Cconstant = mem_malloc(identifier_methods[0]);
  Cconstant[0] = identifier_methods;
  identifier_alloc(Cconstant, "Build_constant");
  Citerator = mem_malloc(identifier_methods[0]);
  Citerator[0] = identifier_methods;
  identifier_alloc(Citerator, "Build_iterator");
  Cnegate = mem_malloc(identifier_methods[0]);
  Cnegate[0] = identifier_methods;
  identifier_alloc(Cnegate, "Build_negate");
  Cdivide = mem_malloc(identifier_methods[0]);
  Cdivide[0] = identifier_methods;
  identifier_alloc(Cdivide, "Build_divide");
  CString = mem_malloc(identifier_methods[0]);
  CString[0] = identifier_methods;
  identifier_alloc(CString, "Build_string");
  Cappend = mem_malloc(identifier_methods[0]);
  Cappend[0] = identifier_methods;
  identifier_alloc(Cappend, "Build_append");
  Cpowerset = mem_malloc(identifier_methods[0]);
  Cpowerset[0] = identifier_methods;
  identifier_alloc(Cpowerset, "Build_powerset");
  CSet_literal = mem_malloc(identifier_methods[0]);
  CSet_literal[0] = identifier_methods;
  identifier_alloc(CSet_literal, "Build_set_literal");
  CList_srange = mem_malloc(identifier_methods[0]);
  CList_srange[0] = identifier_methods;
  identifier_alloc(CList_srange, "Build_list_srange");
  Cdomain = mem_malloc(identifier_methods[0]);
  Cdomain[0] = identifier_methods;
  identifier_alloc(Cdomain, "Build_domain");
  Cset_attribute = mem_malloc(identifier_methods[0]);
  Cset_attribute[0] = identifier_methods;
  identifier_alloc(Cset_attribute, "Build_set_attribute");
  Cmultiply = mem_malloc(identifier_methods[0]);
  Cmultiply[0] = identifier_methods;
  identifier_alloc(Cmultiply, "Build_multiply");
  CResult = mem_malloc(identifier_methods[0]);
  CResult[0] = identifier_methods;
  identifier_alloc(CResult, "Build_result");
  CExport = mem_malloc(identifier_methods[0]);
  CExport[0] = identifier_methods;
  identifier_alloc(CExport, "Build_export");
  Cindent = mem_malloc(identifier_methods[0]);
  Cindent[0] = identifier_methods;
  identifier_alloc(Cindent, "Build_indent");
  Cmake_filter = mem_malloc(identifier_methods[0]);
  Cmake_filter[0] = identifier_methods;
  identifier_alloc(Cmake_filter, "Build_make_filter");
  Cassign = mem_malloc(identifier_methods[0]);
  Cassign[0] = identifier_methods;
  identifier_alloc(Cassign, "Build_assign");
  Cadd_to_list = mem_malloc(identifier_methods[0]);
  Cadd_to_list[0] = identifier_methods;
  identifier_alloc(Cadd_to_list, "Build_add_to_list");
  Cmodule = mem_malloc(identifier_methods[0]);
  Cmodule[0] = identifier_methods;
  identifier_alloc(Cmodule, "Build_module");
  CPair = mem_malloc(identifier_methods[0]);
  CPair[0] = identifier_methods;
  identifier_alloc(CPair, "Build_pair");
  Cpostcondition = mem_malloc(identifier_methods[0]);
  Cpostcondition[0] = identifier_methods;
  identifier_alloc(Cpostcondition, "Build_postcondition");
  Cforany = mem_malloc(identifier_methods[0]);
  Cforany[0] = identifier_methods;
  identifier_alloc(Cforany, "Build_forany");
  Cassert = mem_malloc(identifier_methods[0]);
  Cassert[0] = identifier_methods;
  identifier_alloc(Cassert, "Build_assert");
  Csc_if_def = mem_malloc(identifier_methods[0]);
  Csc_if_def[0] = identifier_methods;
  identifier_alloc(Csc_if_def, "Build_sc_if_def");
  CDeclare_params = mem_malloc(identifier_methods[0]);
  CDeclare_params[0] = identifier_methods;
  identifier_alloc(CDeclare_params, "Build_declare_params");
  Cend_parlist = mem_malloc(identifier_methods[0]);
  Cend_parlist[0] = identifier_methods;
  identifier_alloc(Cend_parlist, "Build_end_parlist");
  Csubset = mem_malloc(identifier_methods[0]);
  Csubset[0] = identifier_methods;
  identifier_alloc(Csubset, "Build_subset");
  CSet_range = mem_malloc(identifier_methods[0]);
  CSet_range[0] = identifier_methods;
  identifier_alloc(CSet_range, "Build_set_range");
  Crepeat_loop = mem_malloc(identifier_methods[0]);
  Crepeat_loop[0] = identifier_methods;
  identifier_alloc(Crepeat_loop, "Build_repeat_loop");
  Cimport = mem_malloc(identifier_methods[0]);
  Cimport[0] = identifier_methods;
  identifier_alloc(Cimport, "Build_import");
  Ccall = mem_malloc(identifier_methods[0]);
  Ccall[0] = identifier_methods;
  identifier_alloc(Ccall, "Build_call");
  CMake_type = mem_malloc(identifier_methods[0]);
  CMake_type[0] = identifier_methods;
  identifier_alloc(CMake_type, "Build_make_type");
  Creturn = mem_malloc(identifier_methods[0]);
  Creturn[0] = identifier_methods;
  identifier_alloc(Creturn, "Build_return");
  CPut_space = mem_malloc(identifier_methods[0]);
  CPut_space[0] = identifier_methods;
  identifier_alloc(CPut_space, "Build_put_space");
  CPut_comma = mem_malloc(identifier_methods[0]);
  CPut_comma[0] = identifier_methods;
  identifier_alloc(CPut_comma, "Build_put_comma");
  Cwhile_until = mem_malloc(identifier_methods[0]);
  Cwhile_until[0] = identifier_methods;
  identifier_alloc(Cwhile_until, "Build_while_until");
  Cplus_assign = mem_malloc(identifier_methods[0]);
  Cplus_assign[0] = identifier_methods;
  identifier_alloc(Cplus_assign, "Build_plus_assign");
  Celse = mem_malloc(identifier_methods[0]);
  Celse[0] = identifier_methods;
  identifier_alloc(Celse, "Build_else");
  Cdeclare_as_var = mem_malloc(identifier_methods[0]);
  Cdeclare_as_var[0] = identifier_methods;
  identifier_alloc(Cdeclare_as_var, "Build_declare_as_var");
  Cmake_eset = mem_malloc(identifier_methods[0]);
  Cmake_eset[0] = identifier_methods;
  identifier_alloc(Cmake_eset, "Build_make_eset");
  Cwhen = mem_malloc(identifier_methods[0]);
  Cwhen[0] = identifier_methods;
  identifier_alloc(Cwhen, "Build_when");
  Cmake_name_list = mem_malloc(identifier_methods[0]);
  Cmake_name_list[0] = identifier_methods;
  identifier_alloc(Cmake_name_list, "Build_make_name_list");
  Cexit = mem_malloc(identifier_methods[0]);
  Cexit[0] = identifier_methods;
  identifier_alloc(Cexit, "Build_exit");
  Cmake_list = mem_malloc(identifier_methods[0]);
  Cmake_list[0] = identifier_methods;
  identifier_alloc(Cmake_list, "Build_make_list");
  Cmake_parameter = mem_malloc(identifier_methods[0]);
  Cmake_parameter[0] = identifier_methods;
  identifier_alloc(Cmake_parameter, "Build_make_parameter");
  Clazy = mem_malloc(identifier_methods[0]);
  Clazy[0] = identifier_methods;
  identifier_alloc(Clazy, "Build_lazy");
  Cresult_type = mem_malloc(identifier_methods[0]);
  Cresult_type[0] = identifier_methods;
  identifier_alloc(Cresult_type, "Build_result_type");
  Ccond_expr = mem_malloc(identifier_methods[0]);
  Ccond_expr[0] = identifier_methods;
  identifier_alloc(Ccond_expr, "Build_cond_expr");
  CList_constructor = mem_malloc(identifier_methods[0]);
  CList_constructor[0] = identifier_methods;
  identifier_alloc(CList_constructor, "Build_list_constructor");
  Cplus = mem_malloc(identifier_methods[0]);
  Cplus[0] = identifier_methods;
  identifier_alloc(Cplus, "Build_plus");
  Cgenerator = mem_malloc(identifier_methods[0]);
  Cgenerator[0] = identifier_methods;
  identifier_alloc(Cgenerator, "Build_generator");
  Cdec_ref = mem_malloc(identifier_methods[0]);
  Cdec_ref[0] = identifier_methods;
  identifier_alloc(Cdec_ref, "Build_dec_ref");
  CC_const = mem_malloc(identifier_methods[0]);
  CC_const[0] = identifier_methods;
  identifier_alloc(CC_const, "Build_c_const");
  Cprocedure = mem_malloc(identifier_methods[0]);
  Cprocedure[0] = identifier_methods;
  identifier_alloc(Cprocedure, "Build_procedure");
  Cinvariant = mem_malloc(identifier_methods[0]);
  Cinvariant[0] = identifier_methods;
  identifier_alloc(Cinvariant, "Build_invariant");
  Cge = mem_malloc(identifier_methods[0]);
  Cge[0] = identifier_methods;
  identifier_alloc(Cge, "Build_ge");
  Cif = mem_malloc(identifier_methods[0]);
  Cif[0] = identifier_methods;
  identifier_alloc(Cif, "Build_if");
  Cle = mem_malloc(identifier_methods[0]);
  Cle[0] = identifier_methods;
  identifier_alloc(Cle, "Build_le");
  Cfor_until = mem_malloc(identifier_methods[0]);
  Cfor_until[0] = identifier_methods;
  identifier_alloc(Cfor_until, "Build_for_until");
  Cintersect = mem_malloc(identifier_methods[0]);
  Cintersect[0] = identifier_methods;
  identifier_alloc(Cintersect, "Build_intersect");
  Ceq = mem_malloc(identifier_methods[0]);
  Ceq[0] = identifier_methods;
  identifier_alloc(Ceq, "Build_eq");
  Cin = mem_malloc(identifier_methods[0]);
  Cin[0] = identifier_methods;
  identifier_alloc(Cin, "Build_in");
  CPut_eol = mem_malloc(identifier_methods[0]);
  CPut_eol[0] = identifier_methods;
  identifier_alloc(CPut_eol, "Build_put_eol");
  CQualify = mem_malloc(identifier_methods[0]);
  CQualify[0] = identifier_methods;
  identifier_alloc(CQualify, "Build_qualify");
  Cgt = mem_malloc(identifier_methods[0]);
  Cgt[0] = identifier_methods;
  identifier_alloc(Cgt, "Build_gt");
  Cend_statements = mem_malloc(identifier_methods[0]);
  Cend_statements[0] = identifier_methods;
  identifier_alloc(Cend_statements, "Build_end_statements");
  Ccheck_indent = mem_malloc(identifier_methods[0]);
  Ccheck_indent[0] = identifier_methods;
  identifier_alloc(Ccheck_indent, "Build_check_indent");
  Clt = mem_malloc(identifier_methods[0]);
  Clt[0] = identifier_methods;
  identifier_alloc(Clt, "Build_lt");
  CFcall = mem_malloc(identifier_methods[0]);
  CFcall[0] = identifier_methods;
  identifier_alloc(CFcall, "Build_fcall");
  CList_literal = mem_malloc(identifier_methods[0]);
  CList_literal[0] = identifier_methods;
  identifier_alloc(CList_literal, "Build_list_literal");
  CPut_expression = mem_malloc(identifier_methods[0]);
  CPut_expression[0] = identifier_methods;
  identifier_alloc(CPut_expression, "Build_put_expression");
  Clist_of = mem_malloc(identifier_methods[0]);
  Clist_of[0] = identifier_methods;
  identifier_alloc(Clist_of, "Build_list_of");
  CStart_of_put = mem_malloc(identifier_methods[0]);
  CStart_of_put[0] = identifier_methods;
  identifier_alloc(CStart_of_put, "Build_start_of_put");
  Cforsome = mem_malloc(identifier_methods[0]);
  Cforsome[0] = identifier_methods;
  identifier_alloc(Cforsome, "Build_forsome");
  Saved_start_col = mem_malloc(integer_methods[0]);
  Saved_start_col[0] = integer_methods;
  Saved_start_col = integer_ialloc(Saved_start_col, 1);
  Saved_curr_line_num = mem_malloc(integer_methods[0]);
  Saved_curr_line_num[0] = integer_methods;
  Saved_curr_line_num = integer_ialloc(Saved_curr_line_num, 1);
  CStart_col[1] += 1; Saved_start_col[1] += 1;
  identifier_OpAssign(CStart_col, Saved_start_col, 0);
  CCurr_line_num[1] += 1; Saved_curr_line_num[1] += 1;
  identifier_OpAssign(CCurr_line_num, Saved_curr_line_num, 0);
};

int Build_token(char* tokname, char* inpline, int i, int j){
  cptr tkn, tkstr; char* tok;
  tkn = mem_malloc(idstring_methods[0]);
  tkn[0] = idstring_methods;
  tkn = idstring_alloc(tkn, tokname);
  CTokname[1] += 1; identifier_OpAssign(CTokname, tkn, 0);
  tok = mem_malloc(j-i+1);
  strncpy(tok, inpline+i, j-i); tok[j-i] = 0;
  tkstr = mem_malloc(sstring_methods[0]);
  tkstr[0] = sstring_methods;
  tkstr = sstring_alloc(tkstr, tok);
  CTokstring[1] += 1; identifier_OpAssign(CTokstring, tkstr, 0);
  Ctoken[1] += 1; identifier_Call(Ctoken);
};

int Build_add_statement(){
  CStart_col[1] += 1; Saved_start_col[1] += 1;
  Saved_start_col = integer_update_hashval(Saved_start_col, Start_col+1);
  identifier_OpAssign(CStart_col, Saved_start_col, 0);
  CCurr_line_num[1] += 1; Saved_curr_line_num[1] += 1;
  Saved_curr_line_num = integer_update_hashval(Saved_curr_line_num, Curr_line_num);
  identifier_OpAssign(CCurr_line_num, Saved_curr_line_num, 0);
  Cadd_statement[1] += 1;
  identifier_Call(Cadd_statement);
};


int Build_endif(){
  Cendif[1] += 1;
  identifier_Call(Cendif);
};

int Build_list_range(){
  CList_range[1] += 1;
  identifier_Call(CList_range);
};

int Build_set_srange(){
  CSet_srange[1] += 1;
  identifier_Call(CSet_srange);
};

int Build_repeat_until(){
  Crepeat_until[1] += 1;
  identifier_Call(Crepeat_until);
};

int Build_precondition(){
  Cprecondition[1] += 1;
  identifier_Call(Cprecondition);
};

int Build_minus_assign(){
  Cminus_assign[1] += 1;
  identifier_Call(Cminus_assign);
};

int Build_elsif(){
  Celsif[1] += 1;
  identifier_Call(Celsif);
};

int Build_exponentiate(){
  Cexponentiate[1] += 1;
  identifier_Call(Cexponentiate);
};

int Build_sc_or(){
  Csc_or[1] += 1;
  identifier_Call(Csc_or);
};

int Build_declare_typed_params(){
  CDeclare_typed_params[1] += 1;
  identifier_Call(CDeclare_typed_params);
};

int Build_make_elist(){
  Cmake_elist[1] += 1;
  identifier_Call(Cmake_elist);
};

int Build_putcol_expression(){
  CPutcol_expression[1] += 1;
  identifier_Call(CPutcol_expression);
};

int Build_minus(){
  Cminus[1] += 1;
  identifier_Call(Cminus);
};

int Build_while_loop(){
  Cwhile_loop[1] += 1;
  identifier_Call(Cwhile_loop);
};

int Build_get(){
  Cget[1] += 1;
  identifier_Call(Cget);
};

int Build_map_constructor(){
  CMap_constructor[1] += 1;
  identifier_Call(CMap_constructor);
};

int Build_multi_exit(){
  Cmulti_exit[1] += 1;
  identifier_Call(Cmulti_exit);
};

int Build_call_c_func(){
  CCall_c_func[1] += 1;
  identifier_Call(CCall_c_func);
};

int Build_start_list(){
  Cstart_list[1] += 1;
  identifier_Call(Cstart_list);
};

int Build_new(){
  Cnew[1] += 1;
  identifier_Call(Cnew);
};

int Build_codomain(){
  Ccodomain[1] += 1;
  identifier_Call(Ccodomain);
};

int Build_make_nested_iterator(){
  Cmake_nested_iterator[1] += 1;
  identifier_Call(Cmake_nested_iterator);
};

int Build_transitive(){
  Ctransitive[1] += 1;
  identifier_Call(Ctransitive);
};

int Build_make_set(){
  Cmake_set[1] += 1;
  identifier_Call(Cmake_set);
};

int Build_not(){
  Cnot[1] += 1;
  identifier_Call(Cnot);
};

int Build_set_constructor(){
  CSet_constructor[1] += 1;
  identifier_Call(CSet_constructor);
};

int Build_evaluate(){
  Cevaluate[1] += 1;
  identifier_Call(Cevaluate);
};

int Build_divide_assign(){
  Cdivide_assign[1] += 1;
  identifier_Call(Cdivide_assign);
};

int Build_make_selector(){
  Cmake_selector[1] += 1;
  identifier_Call(Cmake_selector);
};

int Build_for_loop(){
  Cfor_loop[1] += 1;
  identifier_Call(Cfor_loop);
};

int Build_length(){
  CLength[1] += 1;
  identifier_Call(CLength);
};

int Build_multiply_assign(){
  Cmultiply_assign[1] += 1;
  identifier_Call(Cmultiply_assign);
};

int Build_function(){
  Cfunction[1] += 1;
  identifier_Call(Cfunction);
};

int Build_make_iterator(){
  Cmake_iterator[1] += 1;
  identifier_Call(Cmake_iterator);
};

int Build_sc_and(){
  Csc_and[1] += 1;
  identifier_Call(Csc_and);
};

int Build_constant(){
  Cconstant[1] += 1;
  identifier_Call(Cconstant);
};

int Build_iterator(){
  Citerator[1] += 1;
  identifier_Call(Citerator);
};

int Build_negate(){
  Cnegate[1] += 1;
  identifier_Call(Cnegate);
};

int Build_divide(){
  Cdivide[1] += 1;
  identifier_Call(Cdivide);
};

int Build_string(){
  CString[1] += 1;
  identifier_Call(CString);
};

int Build_append(){
  Cappend[1] += 1;
  identifier_Call(Cappend);
};

int Build_powerset(){
  Cpowerset[1] += 1;
  identifier_Call(Cpowerset);
};

int Build_set_literal(){
  CSet_literal[1] += 1;
  identifier_Call(CSet_literal);
};

int Build_list_srange(){
  CList_srange[1] += 1;
  identifier_Call(CList_srange);
};

int Build_domain(){
  Cdomain[1] += 1;
  identifier_Call(Cdomain);
};

int Build_result(){
  CResult[1] += 1;
  identifier_Call(CResult);
};

int Build_multiply(){
  Cmultiply[1] += 1;
  identifier_Call(Cmultiply);
};

int Build_set_attribute(){
  Cset_attribute[1] += 1;
  identifier_Call(Cset_attribute);
};

int Build_export(){
  CExport[1] += 1;
  identifier_Call(CExport);
};

int Build_make_filter(){
  Cmake_filter[1] += 1;
  identifier_Call(Cmake_filter);
};

int Build_assign(){
  Cassign[1] += 1;
  identifier_Call(Cassign);
};

int Build_add_to_list(){
  Cadd_to_list[1] += 1;
  identifier_Call(Cadd_to_list);
};

int Build_module(){
  Cmodule[1] += 1;
  identifier_Call(Cmodule);
};

int Build_pair(){
  CPair[1] += 1;
  identifier_Call(CPair);
};

int Build_postcondition(){
  Cpostcondition[1] += 1;
  identifier_Call(Cpostcondition);
};

int Build_forany(){
  Cforany[1] += 1;
  identifier_Call(Cforany);
};

int Build_assert(){
  Cassert[1] += 1;
  identifier_Call(Cassert);
};

int Build_sc_if_def(){
  Csc_if_def[1] += 1;
  identifier_Call(Csc_if_def);
};

int Build_declare_params(){
  CDeclare_params[1] += 1;
  identifier_Call(CDeclare_params);
};

int Build_end_parlist(){
  Cend_parlist[1] += 1;
  identifier_Call(Cend_parlist);
};

int Build_subset(){
  Csubset[1] += 1;
  identifier_Call(Csubset);
};

int Build_set_range(){
  CSet_range[1] += 1;
  identifier_Call(CSet_range);
};

int Build_repeat_loop(){
  Crepeat_loop[1] += 1;
  identifier_Call(Crepeat_loop);
};

int Build_import(){
  Cimport[1] += 1;
  identifier_Call(Cimport);
};

int Build_call(){
  Ccall[1] += 1;
  identifier_Call(Ccall);
};

int Build_make_type(){
  CMake_type[1] += 1;
  identifier_Call(CMake_type);
};

int Build_return(){
  Creturn[1] += 1;
  identifier_Call(Creturn);
};

int Build_put_space(){
  CPut_space[1] += 1;
  identifier_Call(CPut_space);
};

int Build_put_comma(){
  CPut_comma[1] += 1;
  identifier_Call(CPut_comma);
};

int Build_while_until(){
  Cwhile_until[1] += 1;
  identifier_Call(Cwhile_until);
};

int Build_plus_assign(){
  Cplus_assign[1] += 1;
  identifier_Call(Cplus_assign);
};

int Build_else(){
  Celse[1] += 1;
  identifier_Call(Celse);
};

int Build_declare_as_var(){
  Cdeclare_as_var[1] += 1;
  identifier_Call(Cdeclare_as_var);
};

int Build_make_eset(){
  Cmake_eset[1] += 1;
  identifier_Call(Cmake_eset);
};

int Build_when(){
  Cwhen[1] += 1;
  identifier_Call(Cwhen);
};

int Build_make_name_list(){
  Cmake_name_list[1] += 1;
  identifier_Call(Cmake_name_list);
};

int Build_exit(){
  Cexit[1] += 1;
  identifier_Call(Cexit);
};

int Build_make_list(){
  Cmake_list[1] += 1;
  identifier_Call(Cmake_list);
};

int Build_make_parameter(){
  Cmake_parameter[1] += 1;
  identifier_Call(Cmake_parameter);
};

int Build_lazy(){
  Clazy[1] += 1;
  identifier_Call(Clazy);
};

int Build_result_type(){
  Cresult_type[1] += 1;
  identifier_Call(Cresult_type);
};

int Build_cond_expr(){
  Ccond_expr[1] += 1;
  identifier_Call(Ccond_expr);
};

int Build_list_constructor(){
  CList_constructor[1] += 1;
  identifier_Call(CList_constructor);
};

int Build_plus(){
  Cplus[1] += 1;
  identifier_Call(Cplus);
};

int Build_generator(){
  Cgenerator[1] += 1;
  identifier_Call(Cgenerator);
};

int Build_dec_ref(){
  Cdec_ref[1] += 1;
  identifier_Call(Cdec_ref);
};

int Build_c_const(){
  CC_const[1] += 1;
  identifier_Call(CC_const);
};

int Build_procedure(){
  Cprocedure[1] += 1;
  identifier_Call(Cprocedure);
};

int Build_invariant(){
  Cinvariant[1] += 1;
  identifier_Call(Cinvariant);
};

int Build_ge(){
  Cge[1] += 1;
  identifier_Call(Cge);
};

int Build_if(){
  Cif[1] += 1;
  identifier_Call(Cif);
};

int Build_le(){
  Cle[1] += 1;
  identifier_Call(Cle);
};

int Build_for_until(){
  Cfor_until[1] += 1;
  identifier_Call(Cfor_until);
};

int Build_intersect(){
  Cintersect[1] += 1;
  identifier_Call(Cintersect);
};

int Build_eq(){
  Ceq[1] += 1;
  identifier_Call(Ceq);
};

int Build_in(){
  Cin[1] += 1;
  identifier_Call(Cin);
};

int Build_put_eol(){
  CPut_eol[1] += 1;
  identifier_Call(CPut_eol);
};

int Build_qualify(){
  CQualify[1] += 1;
  identifier_Call(CQualify);
};

int Build_gt(){
  Cgt[1] += 1;
  identifier_Call(Cgt);
};

int Build_end_statements(){
  Cend_statements[1] += 1;
  identifier_Call(Cend_statements);
};

int Build_lt(){
  Clt[1] += 1;
  identifier_Call(Clt);
};

int Build_fcall(){
  CFcall[1] += 1;
  identifier_Call(CFcall);
};

int Build_list_literal(){
  CList_literal[1] += 1;
  identifier_Call(CList_literal);
};

int Build_put_expression(){
  CPut_expression[1] += 1;
  identifier_Call(CPut_expression);
};

int Build_list_of(){
  Clist_of[1] += 1;
  identifier_Call(Clist_of);
};

int Build_start_of_put(){
  CStart_of_put[1] += 1;
  identifier_Call(CStart_of_put);
};

int Build_forsome(){
  Cforsome[1] += 1;
  identifier_Call(Cforsome);
};
