#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 Cplus_op;
cptr Cnot_equal_op;
cptr Ctyped_params;
cptr Cparameterize;
cptr Crepeat_until;
cptr Cintersect_op;
cptr Cminus_assign;
cptr Cput_value_op;
cptr Cnew_iterator;
cptr Cin_op;
cptr Cnew_iterated_list;
cptr Cvalue;
cptr Cor_op;
cptr Cget_method;
cptr Ctoken;
cptr Cnew_stepped_range_list;
cptr Cnew_set_of;
cptr Cset_method;
cptr Cnew_filter;
cptr Cnew_target;
cptr Cnew_component_instance;
cptr Cwhile_loop;
cptr Cgreater_than_op;
cptr Cparameters;
cptr Cforsome_op;
cptr Cone;
cptr Cadd_to_front_of_list;
cptr Cmulti_exit;
cptr Cstart_list;
cptr Cadd_instruction;
cptr Cnew_target_list;
cptr Cwith_slots;
cptr CCurr_line_num;
cptr Cexponentiate_op;
cptr Cequal_op;
cptr Cindex_op;
cptr Cdivide_assign;
cptr Csave_pos;
cptr Cfor_loop;
cptr Clookup_lib_component;
cptr Cnew_range_set;
cptr Cmultiply_assign;
cptr Ccount_op;
cptr Cminus_op;
cptr Cand_op;
cptr Cslot_value_op;
cptr Cnew_component;
cptr Cnew_enumerated_set;
cptr Cadd_prototype;
cptr Cassign;
cptr Cadd_to_list;
cptr Cextend;
cptr Cnew_slot_type;
cptr Clazy_with_pos;
cptr Ccontinuations;
cptr Cnot_op;
cptr Cmaxint;
cptr Cinitial_expression;
cptr Cnew_list_of;
cptr Crepeat_loop;
cptr Cif_def_op;
cptr Cmark_as_external;
cptr Creturn;
cptr Cnew_iterated_set;
cptr Cplus_assign;
cptr CStart_col;
cptr Cwhen;
cptr Cdivide_op;
cptr Cnew_stepped_range_set;
cptr Cless_than_or_equal_op;
cptr Cnew_range;
cptr Creturn_with_result;
cptr Cexit;
cptr Cswap;
cptr Cforall_op;
cptr Cmultiply_op;
cptr Clazy;
cptr Ctype;
cptr Cstart_instructions;
cptr CTokstring;
cptr Cimplement;
cptr Clookup_component;
cptr CTokname;
cptr Cget_input;
cptr Cassert_op;
cptr Cnew_range_list;
cptr Csubset_op;
cptr Ccall_op;
cptr Cif_then;
cptr Csubscript;
cptr Cremove_prototype;
cptr Cif_then_else;
cptr Cgreater_than_or_equal_op;
cptr Cnew_enumerated_list;
cptr Cnew_nested_iterator;
cptr Ccall_as_procedure;
cptr Cunary_minus_op;
cptr Cqualify;
cptr Ccall_slot_op;
cptr Cless_than_op;

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");
  Cadd_prototype = mem_malloc(identifier_methods[0]);
  Cadd_prototype[0] = identifier_methods;
  identifier_alloc(Cadd_prototype, "Build_add_prototype");
  Cless_than_op = mem_malloc(identifier_methods[0]);
  Cless_than_op[0] = identifier_methods;
  identifier_alloc(Cless_than_op, "Build_less_than_op");
  Cplus_op = mem_malloc(identifier_methods[0]);
  Cplus_op[0] = identifier_methods;
  identifier_alloc(Cplus_op, "Build_plus_op");
  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");
  Cnot_equal_op = mem_malloc(identifier_methods[0]);
  Cnot_equal_op[0] = identifier_methods;
  identifier_alloc(Cnot_equal_op, "Build_not_equal_op");
  Cextend = mem_malloc(identifier_methods[0]);
  Cextend[0] = identifier_methods;
  identifier_alloc(Cextend, "Build_extend");
  Ctyped_params = mem_malloc(identifier_methods[0]);
  Ctyped_params[0] = identifier_methods;
  identifier_alloc(Ctyped_params, "Build_typed_params");
  Cparameterize = mem_malloc(identifier_methods[0]);
  Cparameterize[0] = identifier_methods;
  identifier_alloc(Cparameterize, "Build_parameterize");
  Cnew_slot_type = mem_malloc(identifier_methods[0]);
  Cnew_slot_type[0] = identifier_methods;
  identifier_alloc(Cnew_slot_type, "Build_new_slot_type");
  Clazy_with_pos = mem_malloc(identifier_methods[0]);
  Clazy_with_pos[0] = identifier_methods;
  identifier_alloc(Clazy_with_pos, "Build_lazy_with_pos");
  Ccontinuations = mem_malloc(identifier_methods[0]);
  Ccontinuations[0] = identifier_methods;
  identifier_alloc(Ccontinuations, "Build_continuations");
  Crepeat_until = mem_malloc(identifier_methods[0]);
  Crepeat_until[0] = identifier_methods;
  identifier_alloc(Crepeat_until, "Build_repeat_until");
  Cminus_assign = mem_malloc(identifier_methods[0]);
  Cminus_assign[0] = identifier_methods;
  identifier_alloc(Cminus_assign, "Build_minus_assign");
  Cnot_op = mem_malloc(identifier_methods[0]);
  Cnot_op[0] = identifier_methods;
  identifier_alloc(Cnot_op, "Build_not_op");
  Cintersect_op = mem_malloc(identifier_methods[0]);
  Cintersect_op[0] = identifier_methods;
  identifier_alloc(Cintersect_op, "Build_intersect_op");
  Cput_value_op = mem_malloc(identifier_methods[0]);
  Cput_value_op[0] = identifier_methods;
  identifier_alloc(Cput_value_op, "Build_put_value_op");
  Cmaxint = mem_malloc(identifier_methods[0]);
  Cmaxint[0] = identifier_methods;
  identifier_alloc(Cmaxint, "Build_maxint");
  Cin_op = mem_malloc(identifier_methods[0]);
  Cin_op[0] = identifier_methods;
  identifier_alloc(Cin_op, "Build_in_op");
  Cnew_iterated_list = mem_malloc(identifier_methods[0]);
  Cnew_iterated_list[0] = identifier_methods;
  identifier_alloc(Cnew_iterated_list, "Build_new_iterated_list");
  Cnew_iterator = mem_malloc(identifier_methods[0]);
  Cnew_iterator[0] = identifier_methods;
  identifier_alloc(Cnew_iterator, "Build_new_iterator");
  Cinitial_expression = mem_malloc(identifier_methods[0]);
  Cinitial_expression[0] = identifier_methods;
  identifier_alloc(Cinitial_expression, "Build_initial_expression");
  Cnew_list_of = mem_malloc(identifier_methods[0]);
  Cnew_list_of[0] = identifier_methods;
  identifier_alloc(Cnew_list_of, "Build_new_list_of");
  Crepeat_loop = mem_malloc(identifier_methods[0]);
  Crepeat_loop[0] = identifier_methods;
  identifier_alloc(Crepeat_loop, "Build_repeat_loop");
  Cif_def_op = mem_malloc(identifier_methods[0]);
  Cif_def_op[0] = identifier_methods;
  identifier_alloc(Cif_def_op, "Build_if_def_op");
  Cvalue = mem_malloc(identifier_methods[0]);
  Cvalue[0] = identifier_methods;
  identifier_alloc(Cvalue, "Build_value");
  Cor_op = mem_malloc(identifier_methods[0]);
  Cor_op[0] = identifier_methods;
  identifier_alloc(Cor_op, "Build_or_op");
  Cmark_as_external = mem_malloc(identifier_methods[0]);
  Cmark_as_external[0] = identifier_methods;
  identifier_alloc(Cmark_as_external, "Build_mark_as_external");
  Ctoken = mem_malloc(identifier_methods[0]);
  Ctoken[0] = identifier_methods;
  identifier_alloc(Ctoken, "Build_token");
  Cget_method = mem_malloc(identifier_methods[0]);
  Cget_method[0] = identifier_methods;
  identifier_alloc(Cget_method, "Build_get_method");
  Creturn = mem_malloc(identifier_methods[0]);
  Creturn[0] = identifier_methods;
  identifier_alloc(Creturn, "Build_return");
  Cnew_stepped_range_list = mem_malloc(identifier_methods[0]);
  Cnew_stepped_range_list[0] = identifier_methods;
  identifier_alloc(Cnew_stepped_range_list, "Build_new_stepped_range_list");
  Cnew_iterated_set = mem_malloc(identifier_methods[0]);
  Cnew_iterated_set[0] = identifier_methods;
  identifier_alloc(Cnew_iterated_set, "Build_new_iterated_set");
  Cplus_assign = mem_malloc(identifier_methods[0]);
  Cplus_assign[0] = identifier_methods;
  identifier_alloc(Cplus_assign, "Build_plus_assign");
  Cnew_set_of = mem_malloc(identifier_methods[0]);
  Cnew_set_of[0] = identifier_methods;
  identifier_alloc(Cnew_set_of, "Build_new_set_of");
  Cset_method = mem_malloc(identifier_methods[0]);
  Cset_method[0] = identifier_methods;
  identifier_alloc(Cset_method, "Build_set_method");
  Cnew_filter = mem_malloc(identifier_methods[0]);
  Cnew_filter[0] = identifier_methods;
  identifier_alloc(Cnew_filter, "Build_new_filter");
  Cnew_target = mem_malloc(identifier_methods[0]);
  Cnew_target[0] = identifier_methods;
  identifier_alloc(Cnew_target, "Build_new_target");
  Cnew_component_instance = mem_malloc(identifier_methods[0]);
  Cnew_component_instance[0] = identifier_methods;
  identifier_alloc(Cnew_component_instance, "Build_new_component_instance");
  Cwhen = mem_malloc(identifier_methods[0]);
  Cwhen[0] = identifier_methods;
  identifier_alloc(Cwhen, "Build_when");
  Cwhile_loop = mem_malloc(identifier_methods[0]);
  Cwhile_loop[0] = identifier_methods;
  identifier_alloc(Cwhile_loop, "Build_while_loop");
  Cparameters = mem_malloc(identifier_methods[0]);
  Cparameters[0] = identifier_methods;
  identifier_alloc(Cparameters, "Build_parameters");
  Cgreater_than_op = mem_malloc(identifier_methods[0]);
  Cgreater_than_op[0] = identifier_methods;
  identifier_alloc(Cgreater_than_op, "Build_greater_than_op");
  Cless_than_or_equal_op = mem_malloc(identifier_methods[0]);
  Cless_than_or_equal_op[0] = identifier_methods;
  identifier_alloc(Cless_than_or_equal_op, "Build_less_than_or_equal_op");
  Cdivide_op = mem_malloc(identifier_methods[0]);
  Cdivide_op[0] = identifier_methods;
  identifier_alloc(Cdivide_op, "Build_divide_op");
  Cnew_range = mem_malloc(identifier_methods[0]);
  Cnew_range[0] = identifier_methods;
  identifier_alloc(Cnew_range, "Build_new_range");
  Creturn_with_result = mem_malloc(identifier_methods[0]);
  Creturn_with_result[0] = identifier_methods;
  identifier_alloc(Creturn_with_result, "Build_return_with_result");
  Cexit = mem_malloc(identifier_methods[0]);
  Cexit[0] = identifier_methods;
  identifier_alloc(Cexit, "Build_exit");
  Cswap = mem_malloc(identifier_methods[0]);
  Cswap[0] = identifier_methods;
  identifier_alloc(Cswap, "Build_swap");
  Cforsome_op = mem_malloc(identifier_methods[0]);
  Cforsome_op[0] = identifier_methods;
  identifier_alloc(Cforsome_op, "Build_forsome_op");
  Cnew_stepped_range_set = mem_malloc(identifier_methods[0]);
  Cnew_stepped_range_set[0] = identifier_methods;
  identifier_alloc(Cnew_stepped_range_set, "Build_new_stepped_range_set");
  Cforall_op = mem_malloc(identifier_methods[0]);
  Cforall_op[0] = identifier_methods;
  identifier_alloc(Cforall_op, "Build_forall_op");
  Cmultiply_op = mem_malloc(identifier_methods[0]);
  Cmultiply_op[0] = identifier_methods;
  identifier_alloc(Cmultiply_op, "Build_multiply_op");
  Clazy = mem_malloc(identifier_methods[0]);
  Clazy[0] = identifier_methods;
  identifier_alloc(Clazy, "Build_lazy");
  Ctype = mem_malloc(identifier_methods[0]);
  Ctype[0] = identifier_methods;
  identifier_alloc(Ctype, "Build_type");
  Cstart_instructions = mem_malloc(identifier_methods[0]);
  Cstart_instructions[0] = identifier_methods;
  identifier_alloc(Cstart_instructions, "Build_start_instructions");
  Cmulti_exit = mem_malloc(identifier_methods[0]);
  Cmulti_exit[0] = identifier_methods;
  identifier_alloc(Cmulti_exit, "Build_multi_exit");
  Cone = mem_malloc(identifier_methods[0]);
  Cone[0] = identifier_methods;
  identifier_alloc(Cone, "Build_one");
  Cadd_to_front_of_list = mem_malloc(identifier_methods[0]);
  Cadd_to_front_of_list[0] = identifier_methods;
  identifier_alloc(Cadd_to_front_of_list, "Build_add_to_front_of_list");
  Cstart_list = mem_malloc(identifier_methods[0]);
  Cstart_list[0] = identifier_methods;
  identifier_alloc(Cstart_list, "Build_start_list");
  Cadd_instruction = mem_malloc(identifier_methods[0]);
  Cadd_instruction[0] = identifier_methods;
  identifier_alloc(Cadd_instruction, "Build_add_instruction");
  Cimplement = mem_malloc(identifier_methods[0]);
  Cimplement[0] = identifier_methods;
  identifier_alloc(Cimplement, "Build_implement");
  Clookup_component = mem_malloc(identifier_methods[0]);
  Clookup_component[0] = identifier_methods;
  identifier_alloc(Clookup_component, "Build_lookup_component");
  Cnew_target_list = mem_malloc(identifier_methods[0]);
  Cnew_target_list[0] = identifier_methods;
  identifier_alloc(Cnew_target_list, "Build_new_target_list");
  Cget_input = mem_malloc(identifier_methods[0]);
  Cget_input[0] = identifier_methods;
  identifier_alloc(Cget_input, "Build_get_input");
  Cwith_slots = mem_malloc(identifier_methods[0]);
  Cwith_slots[0] = identifier_methods;
  identifier_alloc(Cwith_slots, "Build_with_slots");
  Cassert_op = mem_malloc(identifier_methods[0]);
  Cassert_op[0] = identifier_methods;
  identifier_alloc(Cassert_op, "Build_assert_op");
  Cexponentiate_op = mem_malloc(identifier_methods[0]);
  Cexponentiate_op[0] = identifier_methods;
  identifier_alloc(Cexponentiate_op, "Build_exponentiate_op");
  Cnew_range_list = mem_malloc(identifier_methods[0]);
  Cnew_range_list[0] = identifier_methods;
  identifier_alloc(Cnew_range_list, "Build_new_range_list");
  Csubset_op = mem_malloc(identifier_methods[0]);
  Csubset_op[0] = identifier_methods;
  identifier_alloc(Csubset_op, "Build_subset_op");
  Cequal_op = mem_malloc(identifier_methods[0]);
  Cequal_op[0] = identifier_methods;
  identifier_alloc(Cequal_op, "Build_equal_op");
  Cindex_op = mem_malloc(identifier_methods[0]);
  Cindex_op[0] = identifier_methods;
  identifier_alloc(Cindex_op, "Build_index_op");
  Cdivide_assign = mem_malloc(identifier_methods[0]);
  Cdivide_assign[0] = identifier_methods;
  identifier_alloc(Cdivide_assign, "Build_divide_assign");
  Ccall_op = mem_malloc(identifier_methods[0]);
  Ccall_op[0] = identifier_methods;
  identifier_alloc(Ccall_op, "Build_call_op");
  Cif_then = mem_malloc(identifier_methods[0]);
  Cif_then[0] = identifier_methods;
  identifier_alloc(Cif_then, "Build_if_then");
  Csubscript = mem_malloc(identifier_methods[0]);
  Csubscript[0] = identifier_methods;
  identifier_alloc(Csubscript, "Build_subscript");
  Csave_pos = mem_malloc(identifier_methods[0]);
  Csave_pos[0] = identifier_methods;
  identifier_alloc(Csave_pos, "Build_save_pos");
  Cfor_loop = mem_malloc(identifier_methods[0]);
  Cfor_loop[0] = identifier_methods;
  identifier_alloc(Cfor_loop, "Build_for_loop");
  Clookup_lib_component = mem_malloc(identifier_methods[0]);
  Clookup_lib_component[0] = identifier_methods;
  identifier_alloc(Clookup_lib_component, "Build_lookup_lib_component");
  Cremove_prototype = mem_malloc(identifier_methods[0]);
  Cremove_prototype[0] = identifier_methods;
  identifier_alloc(Cremove_prototype, "Build_remove_prototype");
  Cmultiply_assign = mem_malloc(identifier_methods[0]);
  Cmultiply_assign[0] = identifier_methods;
  identifier_alloc(Cmultiply_assign, "Build_multiply_assign");
  Cif_then_else = mem_malloc(identifier_methods[0]);
  Cif_then_else[0] = identifier_methods;
  identifier_alloc(Cif_then_else, "Build_if_then_else");
  Cnew_range_set = mem_malloc(identifier_methods[0]);
  Cnew_range_set[0] = identifier_methods;
  identifier_alloc(Cnew_range_set, "Build_new_range_set");
  Ccount_op = mem_malloc(identifier_methods[0]);
  Ccount_op[0] = identifier_methods;
  identifier_alloc(Ccount_op, "Build_count_op");
  Cgreater_than_or_equal_op = mem_malloc(identifier_methods[0]);
  Cgreater_than_or_equal_op[0] = identifier_methods;
  identifier_alloc(Cgreater_than_or_equal_op, "Build_greater_than_or_equal_op");
  Cminus_op = mem_malloc(identifier_methods[0]);
  Cminus_op[0] = identifier_methods;
  identifier_alloc(Cminus_op, "Build_minus_op");
  Cnew_enumerated_list = mem_malloc(identifier_methods[0]);
  Cnew_enumerated_list[0] = identifier_methods;
  identifier_alloc(Cnew_enumerated_list, "Build_new_enumerated_list");
  Cand_op = mem_malloc(identifier_methods[0]);
  Cand_op[0] = identifier_methods;
  identifier_alloc(Cand_op, "Build_and_op");
  Cnew_nested_iterator = mem_malloc(identifier_methods[0]);
  Cnew_nested_iterator[0] = identifier_methods;
  identifier_alloc(Cnew_nested_iterator, "Build_new_nested_iterator");
  Ccall_as_procedure = mem_malloc(identifier_methods[0]);
  Ccall_as_procedure[0] = identifier_methods;
  identifier_alloc(Ccall_as_procedure, "Build_call_as_procedure");
  Cunary_minus_op = mem_malloc(identifier_methods[0]);
  Cunary_minus_op[0] = identifier_methods;
  identifier_alloc(Cunary_minus_op, "Build_unary_minus_op");
  Cqualify = mem_malloc(identifier_methods[0]);
  Cqualify[0] = identifier_methods;
  identifier_alloc(Cqualify, "Build_qualify");
  Cslot_value_op = mem_malloc(identifier_methods[0]);
  Cslot_value_op[0] = identifier_methods;
  identifier_alloc(Cslot_value_op, "Build_slot_value_op");
  Cnew_component = mem_malloc(identifier_methods[0]);
  Cnew_component[0] = identifier_methods;
  identifier_alloc(Cnew_component, "Build_new_component");
  Cnew_enumerated_set = mem_malloc(identifier_methods[0]);
  Cnew_enumerated_set[0] = identifier_methods;
  identifier_alloc(Cnew_enumerated_set, "Build_new_enumerated_set");
  Ccall_slot_op = mem_malloc(identifier_methods[0]);
  Ccall_slot_op[0] = identifier_methods;
  identifier_alloc(Ccall_slot_op, "Build_call_slot_op");
  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_instruction(){
  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_instruction[1] += 1;
  identifier_Call(Cadd_instruction);
};


int Build_add_prototype(){
  Cadd_prototype[1] += 1;
  identifier_Call(Cadd_prototype);
};

int Build_less_than_op(){
  Cless_than_op[1] += 1;
  identifier_Call(Cless_than_op);
};

int Build_plus_op(){
  Cplus_op[1] += 1;
  identifier_Call(Cplus_op);
};

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_not_equal_op(){
  Cnot_equal_op[1] += 1;
  identifier_Call(Cnot_equal_op);
};

int Build_extend(){
  Cextend[1] += 1;
  identifier_Call(Cextend);
};

int Build_typed_params(){
  Ctyped_params[1] += 1;
  identifier_Call(Ctyped_params);
};

int Build_parameterize(){
  Cparameterize[1] += 1;
  identifier_Call(Cparameterize);
};

int Build_new_slot_type(){
  Cnew_slot_type[1] += 1;
  identifier_Call(Cnew_slot_type);
};

int Build_lazy_with_pos(){
  Clazy_with_pos[1] += 1;
  identifier_Call(Clazy_with_pos);
};

int Build_continuations(){
  Ccontinuations[1] += 1;
  identifier_Call(Ccontinuations);
};

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

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

int Build_not_op(){
  Cnot_op[1] += 1;
  identifier_Call(Cnot_op);
};

int Build_intersect_op(){
  Cintersect_op[1] += 1;
  identifier_Call(Cintersect_op);
};

int Build_put_value_op(){
  Cput_value_op[1] += 1;
  identifier_Call(Cput_value_op);
};

int Build_maxint(){
  Cmaxint[1] += 1;
  identifier_Call(Cmaxint);
};

int Build_in_op(){
  Cin_op[1] += 1;
  identifier_Call(Cin_op);
};

int Build_new_iterated_list(){
  Cnew_iterated_list[1] += 1;
  identifier_Call(Cnew_iterated_list);
};

int Build_new_iterator(){
  Cnew_iterator[1] += 1;
  identifier_Call(Cnew_iterator);
};

int Build_initial_expression(){
  Cinitial_expression[1] += 1;
  identifier_Call(Cinitial_expression);
};

int Build_new_list_of(){
  Cnew_list_of[1] += 1;
  identifier_Call(Cnew_list_of);
};

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

int Build_if_def_op(){
  Cif_def_op[1] += 1;
  identifier_Call(Cif_def_op);
};

int Build_value(){
  Cvalue[1] += 1;
  identifier_Call(Cvalue);
};

int Build_or_op(){
  Cor_op[1] += 1;
  identifier_Call(Cor_op);
};

int Build_mark_as_external(){
  Cmark_as_external[1] += 1;
  identifier_Call(Cmark_as_external);
};

int Build_get_method(){
  Cget_method[1] += 1;
  identifier_Call(Cget_method);
};

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

int Build_new_stepped_range_list(){
  Cnew_stepped_range_list[1] += 1;
  identifier_Call(Cnew_stepped_range_list);
};

int Build_new_iterated_set(){
  Cnew_iterated_set[1] += 1;
  identifier_Call(Cnew_iterated_set);
};

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

int Build_new_set_of(){
  Cnew_set_of[1] += 1;
  identifier_Call(Cnew_set_of);
};

int Build_set_method(){
  Cset_method[1] += 1;
  identifier_Call(Cset_method);
};

int Build_new_filter(){
  Cnew_filter[1] += 1;
  identifier_Call(Cnew_filter);
};

int Build_new_target(){
  Cnew_target[1] += 1;
  identifier_Call(Cnew_target);
};

int Build_new_component_instance(){
  Cnew_component_instance[1] += 1;
  identifier_Call(Cnew_component_instance);
};

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

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

int Build_parameters(){
  Cparameters[1] += 1;
  identifier_Call(Cparameters);
};

int Build_greater_than_op(){
  Cgreater_than_op[1] += 1;
  identifier_Call(Cgreater_than_op);
};

int Build_less_than_or_equal_op(){
  Cless_than_or_equal_op[1] += 1;
  identifier_Call(Cless_than_or_equal_op);
};

int Build_divide_op(){
  Cdivide_op[1] += 1;
  identifier_Call(Cdivide_op);
};

int Build_new_range(){
  Cnew_range[1] += 1;
  identifier_Call(Cnew_range);
};

int Build_return_with_result(){
  Creturn_with_result[1] += 1;
  identifier_Call(Creturn_with_result);
};

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

int Build_swap(){
  Cswap[1] += 1;
  identifier_Call(Cswap);
};

int Build_forsome_op(){
  Cforsome_op[1] += 1;
  identifier_Call(Cforsome_op);
};

int Build_new_stepped_range_set(){
  Cnew_stepped_range_set[1] += 1;
  identifier_Call(Cnew_stepped_range_set);
};

int Build_forall_op(){
  Cforall_op[1] += 1;
  identifier_Call(Cforall_op);
};

int Build_multiply_op(){
  Cmultiply_op[1] += 1;
  identifier_Call(Cmultiply_op);
};

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

int Build_type(){
  Ctype[1] += 1;
  identifier_Call(Ctype);
};

int Build_start_instructions(){
  Cstart_instructions[1] += 1;
  identifier_Call(Cstart_instructions);
};

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

int Build_one(){
  Cone[1] += 1;
  identifier_Call(Cone);
};

int Build_add_to_front_of_list(){
  Cadd_to_front_of_list[1] += 1;
  identifier_Call(Cadd_to_front_of_list);
};

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

int Build_implement(){
  Cimplement[1] += 1;
  identifier_Call(Cimplement);
};

int Build_lookup_component(){
  Clookup_component[1] += 1;
  identifier_Call(Clookup_component);
};

int Build_new_target_list(){
  Cnew_target_list[1] += 1;
  identifier_Call(Cnew_target_list);
};

int Build_get_input(){
  Cget_input[1] += 1;
  identifier_Call(Cget_input);
};

int Build_with_slots(){
  Cwith_slots[1] += 1;
  identifier_Call(Cwith_slots);
};

int Build_assert_op(){
  Cassert_op[1] += 1;
  identifier_Call(Cassert_op);
};

int Build_exponentiate_op(){
  Cexponentiate_op[1] += 1;
  identifier_Call(Cexponentiate_op);
};

int Build_new_range_list(){
  Cnew_range_list[1] += 1;
  identifier_Call(Cnew_range_list);
};

int Build_subset_op(){
  Csubset_op[1] += 1;
  identifier_Call(Csubset_op);
};

int Build_equal_op(){
  Cequal_op[1] += 1;
  identifier_Call(Cequal_op);
};

int Build_index_op(){
  Cindex_op[1] += 1;
  identifier_Call(Cindex_op);
};

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

int Build_call_op(){
  Ccall_op[1] += 1;
  identifier_Call(Ccall_op);
};

int Build_if_then(){
  Cif_then[1] += 1;
  identifier_Call(Cif_then);
};

int Build_subscript(){
  Csubscript[1] += 1;
  identifier_Call(Csubscript);
};

int Build_save_pos(){
  Csave_pos[1] += 1;
  identifier_Call(Csave_pos);
};

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

int Build_lookup_lib_component(){
  Clookup_lib_component[1] += 1;
  identifier_Call(Clookup_lib_component);
};

int Build_remove_prototype(){
  Cremove_prototype[1] += 1;
  identifier_Call(Cremove_prototype);
};

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

int Build_if_then_else(){
  Cif_then_else[1] += 1;
  identifier_Call(Cif_then_else);
};

int Build_new_range_set(){
  Cnew_range_set[1] += 1;
  identifier_Call(Cnew_range_set);
};

int Build_count_op(){
  Ccount_op[1] += 1;
  identifier_Call(Ccount_op);
};

int Build_greater_than_or_equal_op(){
  Cgreater_than_or_equal_op[1] += 1;
  identifier_Call(Cgreater_than_or_equal_op);
};

int Build_minus_op(){
  Cminus_op[1] += 1;
  identifier_Call(Cminus_op);
};

int Build_new_enumerated_list(){
  Cnew_enumerated_list[1] += 1;
  identifier_Call(Cnew_enumerated_list);
};

int Build_and_op(){
  Cand_op[1] += 1;
  identifier_Call(Cand_op);
};

int Build_new_nested_iterator(){
  Cnew_nested_iterator[1] += 1;
  identifier_Call(Cnew_nested_iterator);
};

int Build_call_as_procedure(){
  Ccall_as_procedure[1] += 1;
  identifier_Call(Ccall_as_procedure);
};

int Build_unary_minus_op(){
  Cunary_minus_op[1] += 1;
  identifier_Call(Cunary_minus_op);
};

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

int Build_slot_value_op(){
  Cslot_value_op[1] += 1;
  identifier_Call(Cslot_value_op);
};

int Build_new_component(){
  Cnew_component[1] += 1;
  identifier_Call(Cnew_component);
};

int Build_new_enumerated_set(){
  Cnew_enumerated_set[1] += 1;
  identifier_Call(Cnew_enumerated_set);
};

int Build_call_slot_op(){
  Ccall_slot_op[1] += 1;
  identifier_Call(Ccall_slot_op);
};
