decompiled_code:
__int64 __fastcall mul_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq(&asc_56C[1], 2LL, a1);
v1 = car(a1);
check_arg_type(&asc_56C[1], "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(&asc_56C[1], "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return mul();
}

canonical_decompiled_code:
__int64 __fastcall func9(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq(&asc_56C[1], 2LL, a1);
v1 = car(a1);
check_arg_type(&asc_56C[1], "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(&asc_56C[1], "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return mul();
}

original_code:
cellpoint mul_proc(cellpoint arglst)
{
 check_arglst_len_eq("*", 2, arglst);
 check_arg_type("*", "first", car(arglst), 3);
 check_arg_type("*", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return mul();
}

canonical_original_code:
unsigned int mul_proc(unsigned int arglst)
{
 check_arglst_len_eq("*", 2, arglst);
 check_arg_type("*", "first", car(arglst), 3);
 check_arg_type("*", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return mul();
}


decompiled_code:
__int64 __fastcall div_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq(&asc_56C[2], 2LL, a1);
v1 = car(a1);
check_arg_type(&asc_56C[2], "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(&asc_56C[2], "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return mdiv();
}

canonical_decompiled_code:
__int64 __fastcall func10(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq(&asc_56C[2], 2LL, a1);
v1 = car(a1);
check_arg_type(&asc_56C[2], "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(&asc_56C[2], "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return mdiv();
}

original_code:
cellpoint div_proc(cellpoint arglst)
{
 check_arglst_len_eq("/", 2, arglst);
 check_arg_type("/", "first", car(arglst), 3);
 check_arg_type("/", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return mdiv();
}

canonical_original_code:
unsigned int div_proc(unsigned int arglst)
{
 check_arglst_len_eq("/", 2, arglst);
 check_arg_type("/", "first", car(arglst), 3);
 check_arg_type("/", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return mdiv();
}

variable_types:
arglst
unsigned int

return_type: unsigned int


decompiled_code:
__int64 __fastcall remainder_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("remainder", 2LL, a1);
v1 = car(a1);
check_arg_type("remainder", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("remainder", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return mremainder();
}

canonical_decompiled_code:
__int64 __fastcall func11(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("remainder", 2LL, a1);
v1 = car(a1);
check_arg_type("remainder", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("remainder", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return mremainder();
}

original_code:
cellpoint remainder_proc(cellpoint arglst)
{
 check_arglst_len_eq("remainder", 2, arglst);
 check_arg_type("remainder", "first", car(arglst), 3);
 check_arg_type("remainder", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return mremainder();
}

canonical_original_code:
unsigned int remainder_proc(unsigned int arglst)
{
 check_arglst_len_eq("remainder", 2, arglst);
 check_arg_type("remainder", "first", car(arglst), 3);
 check_arg_type("remainder", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return mremainder();
}


decompiled_code:
__int64 __fastcall string_pred_proc(unsigned int a1)
{
unsigned int v1; // eax

check_arglst_len_eq("string?", 1LL, a1);
v1 = car(a1);
return is_string(v1);
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1)
{
unsigned int v1; // eax

check_arglst_len_eq("string?", 1LL, a1);
v1 = car(a1);
return is_string(v1);
}

original_code:
cellpoint string_pred_proc(cellpoint arglst)
{
    check_arglst_len_eq("string?", 1, arglst);
    return is_string(car(arglst));
}

canonical_original_code:
unsigned int string_pred_proc(unsigned int arglst)
{
    check_arglst_len_eq("string?", 1, arglst);
    return is_string(car(arglst));
}


decompiled_code:
__int64 __fastcall make_string_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v8; // eax

args_push();
v1 = list_len();
v2 = get_integer(v1);
if ( v2 == 1 )
{
reg = make_char(0LL);
}
else if ( v2 == 2 )
{
v8 = cdr(a1);
reg = car(v8);
}
else
{
printf("Error: procedure \"make-string\" expects one or two arguments, but given %d.\n", v2);
error_handler();
}
v3 = car(a1);
check_arg_type("make-string", "first", v3, 2LL);
check_arg_type("make-string", "second", reg, 1LL);
v4 = reg;
v5 = car(a1);
v6 = get_integer(v5);
return make_string(v6, v4);
}

canonical_decompiled_code:
__int64 __fastcall func1(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v8; // eax

args_push();
v1 = list_len();
v2 = get_integer(v1);
if ( v2 == 1 )
{
reg = make_char(0LL);
}
else if ( v2 == 2 )
{
v8 = cdr(a1);
reg = car(v8);
}
else
{
printf("Error: procedure \"make-string\" expects one or two arguments, but given %d.\n", v2);
error_handler();
}
v3 = car(a1);
check_arg_type("make-string", "first", v3, 2LL);
check_arg_type("make-string", "second", reg, 1LL);
v4 = reg;
v5 = car(a1);
v6 = get_integer(v5);
return make_string(v6, v4);
}

original_code:
cellpoint make_string_proc(cellpoint arglst)
{
 int len;
 args_push(arglst);
 len = get_integer(list_len());
 if (len == 1){
  reg = make_char('\0');
 }else if (len == 2){
  reg = car(cdr(arglst));
 }else {
  printf("Error: procedure \"make-string\" expects one or two arguments, but given %d.\n", len);
  error_handler();
 }
 check_arg_type("make-string", "first", car(arglst), 2);
 check_arg_type("make-string", "second", reg, 1);
 return make_string(get_integer(car(arglst)), reg);
}

canonical_original_code:
unsigned int make_string_proc(unsigned int arglst)
{
 int len;
 args_push(arglst);
 len = get_integer(list_len());
 if (len == 1){
  reg = make_char('\0');
 }else if (len == 2){
  reg = car(cdr(arglst));
 }else {
  printf("Error: procedure \"make-string\" expects one or two arguments, but given %d.\n", len);
  error_handler();
 }
 check_arg_type("make-string", "first", car(arglst), 2);
 check_arg_type("make-string", "second", reg, 1);
 return make_string(get_integer(car(arglst)), reg);
}

variable_types: len int


decompiled_code:
__int64 __fastcall string_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax

for ( reg = a1; ; reg = cdr(reg) )
{
v1 = is_null(reg);
if ( !(unsigned int)is_false(v1) )
break;
v2 = car(reg);
v3 = is_char(v2);
if ( (unsigned int)is_false(v3) )
{
puts("Error: procedure \"string\" requires its arguments must be a list of characters.");
error_handler();
}
}
args_push(a1);
return string();
}

canonical_decompiled_code:
__int64 __fastcall func2(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax

for ( reg = a1; ; reg = cdr(reg) )
{
v1 = is_null(reg);
if ( !(unsigned int)is_false(v1) )
break;
v2 = car(reg);
v3 = is_char(v2);
if ( (unsigned int)is_false(v3) )
{
puts("Error: procedure \"string\" requires its arguments must be a list of characters.");
error_handler();
}
}
args_push(a1);
return string();
}

original_code:
cellpoint string_proc(cellpoint arglst)
{
 reg = arglst;
 while (is_false(is_null(reg))){
  if (is_false(is_char(car(reg)))){
   printf("Error: procedure \"string\" requires its arguments must be a list of characters.\n");
   error_handler();
  }
  reg = cdr(reg);
 }
 args_push(arglst);
 return string();
}

canonical_original_code:
unsigned int string_proc(unsigned int arglst)
{
 reg = arglst;
 while (is_false(is_null(reg))){
  if (is_false(is_char(car(reg)))){
   printf("Error: procedure \"string\" requires its arguments must be a list of characters.\n");
   error_handler();
  }
  reg = cdr(reg);
 }
 args_push(arglst);
 return string();
}


decompiled_code:
__int64 __fastcall string_length_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax

check_arglst_len_eq("string-length", 1LL, a1);
v1 = car(a1);
check_arg_type("string-length", "first", v1, 5LL);
v2 = car(a1);
v3 = string_len(v2);
return make_integer(v3);
}

canonical_decompiled_code:
__int64 __fastcall func3(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax

check_arglst_len_eq("string-length", 1LL, a1);
v1 = car(a1);
check_arg_type("string-length", "first", v1, 5LL);
v2 = car(a1);
v3 = string_len(v2);
return make_integer(v3);
}

original_code:
cellpoint string_length_proc(cellpoint arglst)
{
    check_arglst_len_eq("string-length",1,arglst);
 check_arg_type("string-length", "first", car(arglst), 5);
    return make_integer(string_len(car(arglst)));
}

canonical_original_code:
unsigned int string_length_proc(unsigned int arglst)
{
    check_arglst_len_eq("string-length",1,arglst);
 check_arg_type("string-length", "first", car(arglst), 5);
    return make_integer(string_len(car(arglst)));
}


decompiled_code:
__int64 __fastcall string_ref_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // ebp
unsigned int v7; // eax

check_arglst_len_eq("string-ref", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ref", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ref", "second", v3, 2LL);
v4 = cdr(a1);
v5 = car(v4);
v6 = get_integer(v5);
v7 = car(a1);
return string_ref(v7, v6);
}

canonical_decompiled_code:
__int64 __fastcall func4(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // ebp
unsigned int v7; // eax

check_arglst_len_eq("string-ref", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ref", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ref", "second", v3, 2LL);
v4 = cdr(a1);
v5 = car(v4);
v6 = get_integer(v5);
v7 = car(a1);
return string_ref(v7, v6);
}

original_code:
cellpoint string_ref_proc(cellpoint arglst)
{
    check_arglst_len_eq("string-ref", 2, arglst);
 check_arg_type("string-ref", "first", car(arglst), 5);
 check_arg_type("string-ref", "second", car(cdr(arglst)), 2);
    return string_ref(car(arglst), get_integer(car(cdr(arglst))));
}

canonical_original_code:
unsigned int string_ref_proc(unsigned int arglst)
{
    check_arglst_len_eq("string-ref", 2, arglst);
 check_arg_type("string-ref", "first", car(arglst), 5);
 check_arg_type("string-ref", "second", car(cdr(arglst)), 2);
    return string_ref(car(arglst), get_integer(car(cdr(arglst))));
}


decompiled_code:
__int64 __fastcall string_set_proc(unsigned int a1)
{
unsigned int v1; // ebp
unsigned int v2; // eax
unsigned int v3; // er12
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // ebx
unsigned int v7; // eax

check_arglst_len_eq("string-set!", 3LL, a1);
v1 = car(a1);
v2 = cdr(a1);
v3 = car(v2);
v4 = cdr(a1);
v5 = cdr(v4);
v6 = car(v5);
check_arg_type("string-set!", "first", v1, 5LL);
check_arg_type("string-set!", "second", v3, 2LL);
check_arg_type("string-set!", "third", v6, 1LL);
v7 = get_integer(v3);
string_set(v1, v7, v6);
return make_symbol("ok");
}

canonical_decompiled_code:
__int64 __fastcall func5(unsigned int a1)
{
unsigned int v1; // ebp
unsigned int v2; // eax
unsigned int v3; // er12
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // ebx
unsigned int v7; // eax

check_arglst_len_eq("string-set!", 3LL, a1);
v1 = car(a1);
v2 = cdr(a1);
v3 = car(v2);
v4 = cdr(a1);
v5 = cdr(v4);
v6 = car(v5);
check_arg_type("string-set!", "first", v1, 5LL);
check_arg_type("string-set!", "second", v3, 2LL);
check_arg_type("string-set!", "third", v6, 1LL);
v7 = get_integer(v3);
string_set(v1, v7, v6);
return make_symbol("ok");
}

original_code:
cellpoint string_set_proc(cellpoint arglst)
{
    check_arglst_len_eq("string-set!", 3, arglst);
    cellpoint farg = car(arglst);
    cellpoint sarg = car(cdr(arglst));
    cellpoint targ = car(cdr(cdr(arglst)));
 check_arg_type("string-set!", "first", farg, 5);
 check_arg_type("string-set!", "second", sarg, 2);
 check_arg_type("string-set!", "third", targ, 1);
    string_set(farg, get_integer(sarg), targ);
 return make_symbol("ok");
}

canonical_original_code:
unsigned int string_set_proc(unsigned int arglst)
{
    check_arglst_len_eq("string-set!", 3, arglst);
    unsigned int farg = car(arglst);
    unsigned int sarg = car(cdr(arglst));
    unsigned int targ = car(cdr(cdr(arglst)));
 check_arg_type("string-set!", "first", farg, 5);
 check_arg_type("string-set!", "second", sarg, 2);
 check_arg_type("string-set!", "third", targ, 1);
    string_set(farg, get_integer(sarg), targ);
 return make_symbol("ok");
}

variable_types:
farg
unsigned int

variable_types:
sarg
unsigned int

variable_types:
targ
unsigned int


decompiled_code:
__int64 __fastcall string_eq_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_eq();
}

canonical_decompiled_code:
__int64 __fastcall func6(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_eq();
}

original_code:
cellpoint string_eq_proc(cellpoint arglst)
{
    check_arglst_len_eq("string=?", 2, arglst);
    check_arg_type("string=?", "first", car(arglst), 5);
 check_arg_type("string=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_eq();
}

canonical_original_code:
unsigned int string_eq_proc(unsigned int arglst)
{
    check_arglst_len_eq("string=?", 2, arglst);
    check_arg_type("string=?", "first", car(arglst), 5);
 check_arg_type("string=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_eq();
}


decompiled_code:
__int64 __fastcall string_eq_ci_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_eq_ci();
}

canonical_decompiled_code:
__int64 __fastcall func7(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_eq_ci();
}

original_code:
cellpoint string_eq_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-ci=?", 2, arglst);
 check_arg_type("string-ci=?", "first", car(arglst), 5);
 check_arg_type("string-ci=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_eq_ci();
}

canonical_original_code:
unsigned int string_eq_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-ci=?", 2, arglst);
 check_arg_type("string-ci=?", "first", car(arglst), 5);
 check_arg_type("string-ci=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_eq_ci();
}


decompiled_code:
__int64 __fastcall string_less_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string<?", 2LL, a1);
v1 = car(a1);
check_arg_type("string<?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string<?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less();
}

canonical_decompiled_code:
__int64 __fastcall func8(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string<?", 2LL, a1);
v1 = car(a1);
check_arg_type("string<?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string<?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less();
}

original_code:
cellpoint string_less_proc(cellpoint arglst)
{
 check_arglst_len_eq("string<?", 2, arglst);
 check_arg_type("string<?", "first", car(arglst), 5);
 check_arg_type("string<?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less();
}

canonical_original_code:
unsigned int string_less_proc(unsigned int arglst)
{
 check_arglst_len_eq("string<?", 2, arglst);
 check_arg_type("string<?", "first", car(arglst), 5);
 check_arg_type("string<?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less();
}


decompiled_code:
__int64 __fastcall string_greater_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string>?", 2LL, a1);
v1 = car(a1);
check_arg_type("string>?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string>?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater();
}

canonical_decompiled_code:
__int64 __fastcall func9(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string>?", 2LL, a1);
v1 = car(a1);
check_arg_type("string>?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string>?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater();
}

original_code:
cellpoint string_greater_proc(cellpoint arglst)
{
 check_arglst_len_eq("string>?", 2, arglst);
 check_arg_type("string>?", "first", car(arglst), 5);
 check_arg_type("string>?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater();
}

canonical_original_code:
unsigned int string_greater_proc(unsigned int arglst)
{
 check_arglst_len_eq("string>?", 2, arglst);
 check_arg_type("string>?", "first", car(arglst), 5);
 check_arg_type("string>?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater();
}


decompiled_code:
__int64 __fastcall string_less_eq_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string<=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string<=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string<=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less_eq();
}

canonical_decompiled_code:
__int64 __fastcall func10(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string<=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string<=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string<=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less_eq();
}

original_code:
cellpoint string_less_eq_proc(cellpoint arglst)
{
 check_arglst_len_eq("string<=?", 2, arglst);
 check_arg_type("string<=?", "first", car(arglst), 5);
 check_arg_type("string<=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less_eq();
}

canonical_original_code:
unsigned int string_less_eq_proc(unsigned int arglst)
{
 check_arglst_len_eq("string<=?", 2, arglst);
 check_arg_type("string<=?", "first", car(arglst), 5);
 check_arg_type("string<=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less_eq();
}


decompiled_code:
__int64 __fastcall string_greater_eq_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string>=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string>=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string>=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater_eq();
}

canonical_decompiled_code:
__int64 __fastcall func11(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string>=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string>=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string>=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater_eq();
}

original_code:
cellpoint string_greater_eq_proc(cellpoint arglst)
{
 check_arglst_len_eq("string>=?", 2, arglst);
 check_arg_type("string>=?", "first", car(arglst), 5);
 check_arg_type("string>=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater_eq();
}

canonical_original_code:
unsigned int string_greater_eq_proc(unsigned int arglst)
{
 check_arglst_len_eq("string>=?", 2, arglst);
 check_arg_type("string>=?", "first", car(arglst), 5);
 check_arg_type("string>=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater_eq();
}


decompiled_code:
__int64 __fastcall string_less_ci_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci<?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci<?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci<?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less_ci();
}

canonical_decompiled_code:
__int64 __fastcall func12(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci<?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci<?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci<?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less_ci();
}

original_code:
cellpoint string_less_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-ci<?", 2, arglst);
 check_arg_type("string-ci<?", "first", car(arglst), 5);
 check_arg_type("string-ci<?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less_ci();
}

canonical_original_code:
unsigned int string_less_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-ci<?", 2, arglst);
 check_arg_type("string-ci<?", "first", car(arglst), 5);
 check_arg_type("string-ci<?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less_ci();
}


decompiled_code:
__int64 __fastcall string_greater_ci_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci>?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci>?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci>?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater_ci();
}

canonical_decompiled_code:
__int64 __fastcall func13(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci>?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci>?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci>?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater_ci();
}

original_code:
cellpoint string_greater_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-ci>?", 2, arglst);
 check_arg_type("string-ci>?", "first", car(arglst), 5);
 check_arg_type("string-ci>?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater_ci();
}

canonical_original_code:
unsigned int string_greater_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-ci>?", 2, arglst);
 check_arg_type("string-ci>?", "first", car(arglst), 5);
 check_arg_type("string-ci>?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater_ci();
}


decompiled_code:
__int64 __fastcall string_less_eq_ci_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci<=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci<=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci<=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less_eq_ci();
}

canonical_decompiled_code:
__int64 __fastcall func14(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci<=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci<=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci<=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_less_eq_ci();
}

original_code:
cellpoint string_less_eq_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-ci<=?", 2, arglst);
 check_arg_type("string-ci<=?", "first", car(arglst), 5);
 check_arg_type("string-ci<=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less_eq_ci();
}

canonical_original_code:
unsigned int string_less_eq_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-ci<=?", 2, arglst);
 check_arg_type("string-ci<=?", "first", car(arglst), 5);
 check_arg_type("string-ci<=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_less_eq_ci();
}


decompiled_code:
__int64 __fastcall string_greater_eq_ci_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci>=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci>=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci>=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater_eq_ci();
}

canonical_decompiled_code:
__int64 __fastcall func15(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-ci>=?", 2LL, a1);
v1 = car(a1);
check_arg_type("string-ci>=?", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-ci>=?", "second", v3, 5LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return string_greater_eq_ci();
}

original_code:
cellpoint string_greater_eq_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-ci>=?", 2, arglst);
 check_arg_type("string-ci>=?", "first", car(arglst), 5);
 check_arg_type("string-ci>=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater_eq_ci();
}

canonical_original_code:
unsigned int string_greater_eq_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-ci>=?", 2, arglst);
 check_arg_type("string-ci>=?", "first", car(arglst), 5);
 check_arg_type("string-ci>=?", "second", car(cdr(arglst)), 5);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return string_greater_eq_ci();
}


decompiled_code:
__int64 __fastcall substring_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
__int64 v12; // rdi

check_arglst_len_eq("substring", 3LL, a1);
v1 = car(a1);
check_arg_type("substring", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("substring", "second", v3, 2LL);
v4 = cdr(a1);
v5 = cdr(v4);
v6 = car(v5);
check_arg_type("substring", "third", v6, 2LL);
v7 = cdr(a1);
v8 = cdr(v7);
v9 = car(v8);
args_push(v9);
v10 = cdr(a1);
v11 = car(v10);
args_push(v11);
v12 = (unsigned int)car(a1);
args_push(v12);
return substring();
}

canonical_decompiled_code:
__int64 __fastcall func16(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
__int64 v12; // rdi

check_arglst_len_eq("substring", 3LL, a1);
v1 = car(a1);
check_arg_type("substring", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("substring", "second", v3, 2LL);
v4 = cdr(a1);
v5 = cdr(v4);
v6 = car(v5);
check_arg_type("substring", "third", v6, 2LL);
v7 = cdr(a1);
v8 = cdr(v7);
v9 = car(v8);
args_push(v9);
v10 = cdr(a1);
v11 = car(v10);
args_push(v11);
v12 = (unsigned int)car(a1);
args_push(v12);
return substring();
}

original_code:
cellpoint substring_proc(cellpoint arglst)
{
 check_arglst_len_eq("substring", 3, arglst);
 check_arg_type("substring", "first", car(arglst), 5);
 check_arg_type("substring", "second", car(cdr(arglst)), 2);
 check_arg_type("substring", "third", car(cdr(cdr(arglst))), 2);
 args_push(car(cdr(cdr(arglst))));
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return substring();
}

canonical_original_code:
unsigned int substring_proc(unsigned int arglst)
{
 check_arglst_len_eq("substring", 3, arglst);
 check_arg_type("substring", "first", car(arglst), 5);
 check_arg_type("substring", "second", car(cdr(arglst)), 2);
 check_arg_type("substring", "third", car(cdr(cdr(arglst))), 2);
 args_push(car(cdr(cdr(arglst))));
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return substring();
}


decompiled_code:
__int64 __fastcall string_append_proc(__int64 a1)
{
args_push(a1);
return string_append();
}

canonical_decompiled_code:
__int64 __fastcall func17(__int64 a1)
{
args_push(a1);
return string_append();
}

original_code:
cellpoint string_append_proc(cellpoint arglst)
{
 args_push(arglst);
 return string_append();
}

canonical_original_code:
unsigned int string_append_proc(unsigned int arglst)
{
 args_push(arglst);
 return string_append();
}


decompiled_code:
__int64 __fastcall string_2_list_proc(unsigned int a1)
{
unsigned int v1; // eax
__int64 v2; // rdi

check_arglst_len_eq("string->list", 1LL, a1);
v1 = car(a1);
check_arg_type("string->list", "first", v1, 5LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return string_2_list();
}

canonical_decompiled_code:
__int64 __fastcall func18(unsigned int a1)
{
unsigned int v1; // eax
__int64 v2; // rdi

check_arglst_len_eq("string->list", 1LL, a1);
v1 = car(a1);
check_arg_type("string->list", "first", v1, 5LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return string_2_list();
}

original_code:
cellpoint string_2_list_proc(cellpoint arglst)
{
 check_arglst_len_eq("string->list", 1, arglst);
 check_arg_type("string->list", "first", car(arglst), 5);
 args_push(car(arglst));
 return string_2_list();
}

canonical_original_code:
unsigned int string_2_list_proc(unsigned int arglst)
{
 check_arglst_len_eq("string->list", 1, arglst);
 check_arg_type("string->list", "first", car(arglst), 5);
 args_push(car(arglst));
 return string_2_list();
}


decompiled_code:
__int64 __fastcall list_2_string_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
__int64 v4; // rdi

check_arglst_len_eq("list->string", 1LL, a1);
reg = car(a1);
check_arg_type("list->string", "first", reg, 8LL);
while ( 1 )
{
v1 = is_null(reg);
if ( !(unsigned int)is_false(v1) )
break;
v2 = car(reg);
v3 = is_char(v2);
if ( (unsigned int)is_false(v3) )
{
puts("Error: procedure \"list->string\" requires a list of characters.");
error_handler();
}
reg = cdr(reg);
}
v4 = (unsigned int)car(a1);
args_push(v4);
return list_2_string();
}

canonical_decompiled_code:
__int64 __fastcall func19(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
__int64 v4; // rdi

check_arglst_len_eq("list->string", 1LL, a1);
reg = car(a1);
check_arg_type("list->string", "first", reg, 8LL);
while ( 1 )
{
v1 = is_null(reg);
if ( !(unsigned int)is_false(v1) )
break;
v2 = car(reg);
v3 = is_char(v2);
if ( (unsigned int)is_false(v3) )
{
puts("Error: procedure \"list->string\" requires a list of characters.");
error_handler();
}
reg = cdr(reg);
}
v4 = (unsigned int)car(a1);
args_push(v4);
return list_2_string();
}

original_code:
cellpoint list_2_string_proc(cellpoint arglst)
{
 check_arglst_len_eq("list->string", 1 ,arglst);
 reg = car(arglst);
 check_arg_type("list->string", "first", reg, 8);
 while (is_false(is_null(reg))){
  if (is_false(is_char(car(reg)))){
   printf("Error: procedure \"list->string\" requires a list of characters.\n");
   error_handler();
  }
  reg = cdr(reg);
 }
 args_push(car(arglst));
 return list_2_string();
}

canonical_original_code:
unsigned int list_2_string_proc(unsigned int arglst)
{
 check_arglst_len_eq("list->string", 1 ,arglst);
 reg = car(arglst);
 check_arg_type("list->string", "first", reg, 8);
 while (is_false(is_null(reg))){
  if (is_false(is_char(car(reg)))){
   printf("Error: procedure \"list->string\" requires a list of characters.\n");
   error_handler();
  }
  reg = cdr(reg);
 }
 args_push(car(arglst));
 return list_2_string();
}


decompiled_code:
__int64 __fastcall string_copy_proc(unsigned int a1)
{
unsigned int v1; // eax
__int64 v2; // rdi

check_arglst_len_eq("string-copy", 1LL, a1);
v1 = car(a1);
check_arg_type("string-copy", "first", v1, 5LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return string_copy();
}

canonical_decompiled_code:
__int64 __fastcall func20(unsigned int a1)
{
unsigned int v1; // eax
__int64 v2; // rdi

check_arglst_len_eq("string-copy", 1LL, a1);
v1 = car(a1);
check_arg_type("string-copy", "first", v1, 5LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return string_copy();
}

original_code:
cellpoint string_copy_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-copy", 1, arglst);
 check_arg_type("string-copy", "first", car(arglst), 5);
 args_push(car(arglst));
 return string_copy();
}

canonical_original_code:
unsigned int string_copy_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-copy", 1, arglst);
 check_arg_type("string-copy", "first", car(arglst), 5);
 args_push(car(arglst));
 return string_copy();
}


decompiled_code:
__int64 __fastcall string_fill_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-fill", 2LL, a1);
v1 = car(a1);
check_arg_type("string-fill", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-fill", "second", v3, 1LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
string_fill();
return make_symbol("ok");
}

canonical_decompiled_code:
__int64 __fastcall func21(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

check_arglst_len_eq("string-fill", 2LL, a1);
v1 = car(a1);
check_arg_type("string-fill", "first", v1, 5LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("string-fill", "second", v3, 1LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
string_fill();
return make_symbol("ok");
}

original_code:
cellpoint string_fill_proc(cellpoint arglst)
{
 check_arglst_len_eq("string-fill", 2, arglst);
 check_arg_type("string-fill", "first", car(arglst), 5);
 check_arg_type("string-fill", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 string_fill();
 return make_symbol("ok");
}

canonical_original_code:
unsigned int string_fill_proc(unsigned int arglst)
{
 check_arglst_len_eq("string-fill", 2, arglst);
 check_arg_type("string-fill", "first", car(arglst), 5);
 check_arg_type("string-fill", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 string_fill();
 return make_symbol("ok");
}


decompiled_code:
__int64 __fastcall check_arglst_len_eq(const char *a1, int a2, unsigned int a3)
{
unsigned int v3; // eax
__int64 result; // rax
const char *v5; // rcx

args_push(a3);
v3 = list_len();
result = get_integer(v3);
if ( (_DWORD)result != a2 )
{
v5 = (const char *)&unk_306;
if ( a2 <= 1 )
v5 = (const char *)&unk_307;
printf(
"Error: procedure \"%s\" expects %d argument%s, but given %d\n",
a1,
(unsigned int)a2,
v5,
(unsigned int)result);
result = error_handler();
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(const char *a1, int a2, unsigned int a3)
{
unsigned int v3; // eax
__int64 result; // rax
const char *v5; // rcx

args_push(a3);
v3 = list_len();
result = get_integer(v3);
if ( (_DWORD)result != a2 )
{
v5 = (const char *)&unk_306;
if ( a2 <= 1 )
v5 = (const char *)&unk_307;
printf(
"Error: procedure \"%s\" expects %d argument%s, but given %d\n",
a1,
(unsigned int)a2,
v5,
(unsigned int)result);
result = error_handler();
}
return result;
}

original_code:
void check_arglst_len_eq(char *func, int req_len, cellpoint arglst)
{
    int len;
 args_push(arglst);
 len = get_integer(list_len());
    if (len != req_len){
        printf("Error: procedure \"%s\" expects %d argument%s, but given %d\n", func, req_len, (req_len > 1)?"":"s", len);
  error_handler();
    }
}

canonical_original_code:
void check_arglst_len_eq(char *func, int req_len, unsigned int arglst)
{
    int len;
 args_push(arglst);
 len = get_integer(list_len());
    if (len != req_len){
        printf("Error: procedure \"%s\" expects %d argument%s, but given %d\n", func, req_len, (req_len > 1)?"":"s", len);
  error_handler();
    }
}

variable_types:
func
char *

return_type: void


decompiled_code:
__int64 __fastcall check_arg_type(const char *a1, const char *a2, unsigned int a3, int a4)
{
unsigned int v5; // eax
__int64 result; // rax
size_t v7; // rdx
unsigned int v8; // eax
size_t v9; // rdx
unsigned int v10; // eax
size_t v11; // rdx
unsigned int v12; // eax
size_t v13; // rdx
unsigned int v14; // eax
size_t v15; // rdx
unsigned int v16; // eax
size_t v17; // rdx
unsigned int v18; // eax
size_t v19; // rdx
unsigned int v20; // eax
size_t v21; // rdx
unsigned int v22; // eax
size_t v23; // rdx
unsigned int v24; // eax
size_t v25; // rdx

switch ( a4 )
{
case 0:
v5 = is_boolean(a3);
result = is_false(v5);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a boolean, but given: ", a1, a2);
write(a3, a1, v7);
newline();
result = error_handler();
}
break;
case 1:
v8 = is_char(a3);
result = is_false(v8);
if ( (_DWORD)result )
{
printf("Errror: procedure \"%s\" expects the %s argument is a character, but given: ", a1, a2);
write(a3, a1, v9);
newline();
result = error_handler();
}
break;
case 2:
v10 = is_integer(a3);
result = is_false(v10);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a integer, but given: ", a1, a2);
write(a3, a1, v11);
newline();
result = error_handler();
}
break;
case 3:
v12 = is_number(a3);
result = is_false(v12);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a number, but given: ", a1, a2);
write(a3, a1, v13);
newline();
result = error_handler();
}
break;
case 4:
v14 = is_symbol(a3);
result = is_false(v14);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a symbol, but given: ", a1, a2);
write(a3, a1, v15);
newline();
result = error_handler();
}
break;
case 5:
v16 = is_string(a3);
result = is_false(v16);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a string, but given: ", a1, a2);
write(a3, a1, v17);
newline();
result = error_handler();
}
break;
case 6:
v18 = is_vector(a3);
result = is_false(v18);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a vector, but given: ", a1, a2);
write(a3, a1, v19);
newline();
result = error_handler();
}
break;
case 7:
v20 = is_pair(a3);
result = is_false(v20);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a pair, but given: ", a1, a2);
write(a3, a1, v21);
newline();
result = error_handler();
}
break;
case 8:
v22 = is_list(a3);
result = is_false(v22);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a list, but given: ", a1, a2);
write(a3, a1, v23);
newline();
result = error_handler();
}
break;
case 9:
v24 = is_procedure(a3);
result = is_false(v24);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a procedure, but given: ", a1, a2);
write(a3, a1, v25);
newline();
result = error_handler();
}
break;
default:
puts("Error: unknown check arg type. -- CHECK_ARG_TYPE.");
result = error_handler();
break;
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func1(const char *a1, const char *a2, unsigned int a3, int a4)
{
unsigned int v5; // eax
__int64 result; // rax
size_t v7; // rdx
unsigned int v8; // eax
size_t v9; // rdx
unsigned int v10; // eax
size_t v11; // rdx
unsigned int v12; // eax
size_t v13; // rdx
unsigned int v14; // eax
size_t v15; // rdx
unsigned int v16; // eax
size_t v17; // rdx
unsigned int v18; // eax
size_t v19; // rdx
unsigned int v20; // eax
size_t v21; // rdx
unsigned int v22; // eax
size_t v23; // rdx
unsigned int v24; // eax
size_t v25; // rdx

switch ( a4 )
{
case 0:
v5 = is_boolean(a3);
result = is_false(v5);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a boolean, but given: ", a1, a2);
write(a3, a1, v7);
newline();
result = error_handler();
}
break;
case 1:
v8 = is_char(a3);
result = is_false(v8);
if ( (_DWORD)result )
{
printf("Errror: procedure \"%s\" expects the %s argument is a character, but given: ", a1, a2);
write(a3, a1, v9);
newline();
result = error_handler();
}
break;
case 2:
v10 = is_integer(a3);
result = is_false(v10);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a integer, but given: ", a1, a2);
write(a3, a1, v11);
newline();
result = error_handler();
}
break;
case 3:
v12 = is_number(a3);
result = is_false(v12);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a number, but given: ", a1, a2);
write(a3, a1, v13);
newline();
result = error_handler();
}
break;
case 4:
v14 = is_symbol(a3);
result = is_false(v14);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a symbol, but given: ", a1, a2);
write(a3, a1, v15);
newline();
result = error_handler();
}
break;
case 5:
v16 = is_string(a3);
result = is_false(v16);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a string, but given: ", a1, a2);
write(a3, a1, v17);
newline();
result = error_handler();
}
break;
case 6:
v18 = is_vector(a3);
result = is_false(v18);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a vector, but given: ", a1, a2);
write(a3, a1, v19);
newline();
result = error_handler();
}
break;
case 7:
v20 = is_pair(a3);
result = is_false(v20);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a pair, but given: ", a1, a2);
write(a3, a1, v21);
newline();
result = error_handler();
}
break;
case 8:
v22 = is_list(a3);
result = is_false(v22);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a list, but given: ", a1, a2);
write(a3, a1, v23);
newline();
result = error_handler();
}
break;
case 9:
v24 = is_procedure(a3);
result = is_false(v24);
if ( (_DWORD)result )
{
printf("Error: procedure \"%s\" expects the %s argument is a procedure, but given: ", a1, a2);
write(a3, a1, v25);
newline();
result = error_handler();
}
break;
default:
puts("Error: unknown check arg type. -- CHECK_ARG_TYPE.");
result = error_handler();
break;
}
return result;
}

original_code:
void check_arg_type(char *func, char* loc, cellpoint arg, int type)
{
 switch (type){
 case 0:
  if (is_false(is_boolean(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a boolean, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 1:
  if (is_false(is_char(arg))){
   printf("Errror: procedure \"%s\" expects the %s argument is a character, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 2:
  if (is_false(is_integer(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a integer, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 3:
  if (is_false(is_number(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a number, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 4:
  if (is_false(is_symbol(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a symbol, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 5:
  if (is_false(is_string(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a string, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 6:
  if (is_false(is_vector(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a vector, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 7:
  if (is_false(is_pair(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a pair, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 8:
  if (is_false(is_list(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a list, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 9:
  if (is_false(is_procedure(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a procedure, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 default:
  printf("Error: unknown check arg type. -- CHECK_ARG_TYPE.\n");
  error_handler();
 }
}

canonical_original_code:
void check_arg_type(char *func, char *loc, unsigned int arg, int type)
{
 switch (type){
 case 0:
  if (is_false(is_boolean(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a boolean, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 1:
  if (is_false(is_char(arg))){
   printf("Errror: procedure \"%s\" expects the %s argument is a character, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 2:
  if (is_false(is_integer(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a integer, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 3:
  if (is_false(is_number(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a number, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 4:
  if (is_false(is_symbol(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a symbol, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 5:
  if (is_false(is_string(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a string, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 6:
  if (is_false(is_vector(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a vector, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 7:
  if (is_false(is_pair(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a pair, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 8:
  if (is_false(is_list(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a list, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 case 9:
  if (is_false(is_procedure(arg))){
   printf("Error: procedure \"%s\" expects the %s argument is a procedure, but given: ", func, loc);
   write(arg);
   newline();
   error_handler();
  }
  break;
 default:
  printf("Error: unknown check arg type. -- CHECK_ARG_TYPE.\n");
  error_handler();
 }
}

variable_types:
loc
char *

variable_types:
arg
unsigned int

variable_types: type int


decompiled_code:
__int64 __fastcall eq_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax

check_arglst_len_eq(&unk_BC, 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
args_push(v2);
v3 = car(a1);
args_push(v3);
return eq();
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax

check_arglst_len_eq(&unk_BC, 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
args_push(v2);
v3 = car(a1);
args_push(v3);
return eq();
}

original_code:
cellpoint eq_proc(cellpoint arglst)
{
 check_arglst_len_eq("eq?", 2, arglst);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return eq();
}

canonical_original_code:
unsigned int eq_proc(unsigned int arglst)
{
 check_arglst_len_eq("eq?", 2, arglst);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return eq();
}


decompiled_code:
__int64 __fastcall eqv_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
__int64 v3; // rdi

check_arglst_len_eq("eqv?", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
args_push(v2);
v3 = (unsigned int)car(a1);
args_push(v3);
return eqv();
}

canonical_decompiled_code:
__int64 __fastcall func1(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
__int64 v3; // rdi

check_arglst_len_eq("eqv?", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
args_push(v2);
v3 = (unsigned int)car(a1);
args_push(v3);
return eqv();
}

original_code:
cellpoint eqv_proc(cellpoint arglst)
{
 check_arglst_len_eq("eqv?", 2, arglst);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return eqv();
}

canonical_original_code:
unsigned int eqv_proc(unsigned int arglst)
{
 check_arglst_len_eq("eqv?", 2, arglst);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return eqv();
}


decompiled_code:
__int64 __fastcall equal_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
__int64 v3; // rdi

check_arglst_len_eq("equal?", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
args_push(v2);
v3 = (unsigned int)car(a1);
args_push(v3);
return equal();
}

canonical_decompiled_code:
__int64 __fastcall func2(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax
__int64 v3; // rdi

check_arglst_len_eq("equal?", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
args_push(v2);
v3 = (unsigned int)car(a1);
args_push(v3);
return equal();
}

original_code:
cellpoint equal_proc(cellpoint arglst)
{
 check_arglst_len_eq("equal?", 2, arglst);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return equal();
}

canonical_original_code:
unsigned int equal_proc(unsigned int arglst)
{
 check_arglst_len_eq("equal?", 2, arglst);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return equal();
}


vector

decompiled_code:
__int64 vector()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax

v0 = args_ref(1LL);
args_push(v0);
v1 = list_len();
v2 = get_integer(v1);
reg = make_vector(v2, 0LL);
v3 = args_ref(1LL);
stack_push(&vars_stack, v3);
v4 = 0;
while ( 1 )
{
v9 = stack_top(&vars_stack);
v10 = is_null(v9);
if ( !(unsigned int)is_false(v10) )
break;
v5 = stack_top(&vars_stack);
v6 = car(v5);
vector_set(reg, v4++, v6);
v7 = stack_pop(&vars_stack);
v8 = cdr(v7);
stack_push(&vars_stack, v8);
}
stack_pop(&vars_stack);
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func0()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax

v0 = args_ref(1LL);
args_push(v0);
v1 = list_len();
v2 = get_integer(v1);
reg = make_vector(v2, 0LL);
v3 = args_ref(1LL);
stack_push(&vars_stack, v3);
v4 = 0;
while ( 1 )
{
v9 = stack_top(&vars_stack);
v10 = is_null(v9);
if ( !(unsigned int)is_false(v10) )
break;
v5 = stack_top(&vars_stack);
v6 = car(v5);
vector_set(reg, v4++, v6);
v7 = stack_pop(&vars_stack);
v8 = cdr(v7);
stack_push(&vars_stack, v8);
}
stack_pop(&vars_stack);
args_pop(1LL);
return reg;
}

original_code:
cellpoint vector(void)
{
    int len, i=0;
 args_push(args_ref(1));
 len = get_integer(list_len());
    reg = make_vector(len, 0);
 stack_push(&vars_stack, args_ref(1));
    while (is_false(is_null(stack_top(&vars_stack)))){
  vector_set(reg, i, car(stack_top(&vars_stack)));
  ++i;
  stack_push(&vars_stack, cdr(stack_pop(&vars_stack)));
    }
 stack_pop(&vars_stack);
 args_pop(1);
    return reg;
}

canonical_original_code:
unsigned int vector()
{
    int len; int i = 0;
 args_push(args_ref(1));
 len = get_integer(list_len());
    reg = make_vector(len, 0);
 stack_push(&vars_stack, args_ref(1));
    while (is_false(is_null(stack_top(&vars_stack)))){
  vector_set(reg, i, car(stack_top(&vars_stack)));
  ++i;
  stack_push(&vars_stack, cdr(stack_pop(&vars_stack)));
    }
 stack_pop(&vars_stack);
 args_pop(1);
    return reg;
}

variable_types: i int


decompiled_code:
__int64 vector_eq()
{
unsigned int v0; // eax
int v1; // ebp
unsigned int v2; // eax
int v3; // er12
int v4; // ebx
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax

v0 = args_ref(1LL);
v1 = vector_len(v0);
v2 = args_ref(2LL);
v3 = vector_len(v2);
v4 = args_ref(1LL);
if ( v4 == (unsigned int)args_ref(2LL) )
goto LABEL_6;
if ( v1 == v3 )
{
v5 = 0;
if ( v1 > 0 )
{
do
{
v6 = args_ref(1LL);
reg = vector_ref(v6, v5);
v7 = args_ref(2LL);
v8 = vector_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = equal();
if ( (unsigned int)is_false(reg) )
goto LABEL_8;
}
while ( v1 != ++v5 );
}
LABEL_6:
args_pop(2LL);
return a_true;
}
LABEL_8:
args_pop(2LL);
return a_false;
}

canonical_decompiled_code:
__int64 func1()
{
unsigned int v0; // eax
int v1; // ebp
unsigned int v2; // eax
int v3; // er12
int v4; // ebx
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax

v0 = args_ref(1LL);
v1 = vector_len(v0);
v2 = args_ref(2LL);
v3 = vector_len(v2);
v4 = args_ref(1LL);
if ( v4 == (unsigned int)args_ref(2LL) )
goto LABEL_6;
if ( v1 == v3 )
{
v5 = 0;
if ( v1 > 0 )
{
do
{
v6 = args_ref(1LL);
reg = vector_ref(v6, v5);
v7 = args_ref(2LL);
v8 = vector_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = equal();
if ( (unsigned int)is_false(reg) )
goto LABEL_8;
}
while ( v1 != ++v5 );
}
LABEL_6:
args_pop(2LL);
return a_true;
}
LABEL_8:
args_pop(2LL);
return a_false;
}

original_code:
cellpoint vector_eq(void)
{
    int len1 = vector_len(args_ref(1));
    int len2 = vector_len(args_ref(2));
    int i;
    if (args_ref(1) == args_ref(2)){
  args_pop(2);
        return a_true;
    }
    if (len1 != len2){
  args_pop(2);
        return a_false;
    }
    for (i=0; i < len1; ++i){
  reg = vector_ref(args_ref(1), i);
  args_push(vector_ref(args_ref(2), i));
  args_push(reg);
  reg = equal();
        if (is_false(reg)){
            args_pop(2);
   return a_false;
        }
    }
 args_pop(2);
    return a_true;
}

canonical_original_code:
unsigned int vector_eq()
{
    int len1 = vector_len(args_ref(1));
    int len2 = vector_len(args_ref(2));
    int i;
    if (args_ref(1) == args_ref(2)){
  args_pop(2);
        return a_true;
    }
    if (len1 != len2){
  args_pop(2);
        return a_false;
    }
    for (i=0; i < len1; ++i){
  reg = vector_ref(args_ref(1), i);
  args_push(vector_ref(args_ref(2), i));
  args_push(reg);
  reg = equal();
        if (is_false(reg)){
            args_pop(2);
   return a_false;
        }
    }
 args_pop(2);
    return a_true;
}


decompiled_code:
__int64 vector_2_list()
{
unsigned int v0; // eax
int v1; // eax
unsigned int v2; // ebx
unsigned int v3; // ebp
unsigned int v4; // eax
unsigned int v5; // eax

v0 = args_ref(1LL);
v1 = vector_len(v0);
reg = 0;
v2 = v1 - 1;
if ( v1 - 1 >= 0 )
{
do
{
v3 = reg;
v4 = args_ref(1LL);
v5 = vector_ref(v4, v2);
reg = cons(v5, v3);
--v2;
}
while ( v2 != -1 );
}
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func2()
{
unsigned int v0; // eax
int v1; // eax
unsigned int v2; // ebx
unsigned int v3; // ebp
unsigned int v4; // eax
unsigned int v5; // eax

v0 = args_ref(1LL);
v1 = vector_len(v0);
reg = 0;
v2 = v1 - 1;
if ( v1 - 1 >= 0 )
{
do
{
v3 = reg;
v4 = args_ref(1LL);
v5 = vector_ref(v4, v2);
reg = cons(v5, v3);
--v2;
}
while ( v2 != -1 );
}
args_pop(1LL);
return reg;
}

original_code:
cellpoint vector_2_list(void)
{
 int i, len = vector_len(args_ref(1));
 reg = 0;
 for (i=len-1; i >= 0; --i){
  reg = cons(vector_ref(args_ref(1), i), reg);
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int vector_2_list()
{
 int i; int len = vector_len(args_ref(1));
 reg = 0;
 for (i=len-1; i >= 0; --i){
  reg = cons(vector_ref(args_ref(1), i), reg);
 }
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 list_2_vector()
{
__int64 v0; // rdi

v0 = (unsigned int)args_ref(1LL);
args_push(v0);
reg = vector();
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func3()
{
__int64 v0; // rdi

v0 = (unsigned int)args_ref(1LL);
args_push(v0);
reg = func0();
args_pop(1LL);
return reg;
}

original_code:
cellpoint list_2_vector(void)
{
 args_push(args_ref(1));
 reg = vector();
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int list_2_vector()
{
 args_push(args_ref(1));
 reg = vector();
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 vector_fill()
{
int v0; // eax
int v1; // ebp
unsigned int i; // ebx
unsigned int v3; // eax

reg = args_ref(1LL);
v0 = vector_len(reg);
if ( v0 > 0 )
{
v1 = v0;
for ( i = 0; i != v1; ++i )
{
v3 = args_ref(2LL);
vector_set(reg, i, v3);
}
}
return args_pop(1LL);
}

canonical_decompiled_code:
__int64 func4()
{
int v0; // eax
int v1; // ebp
unsigned int i; // ebx
unsigned int v3; // eax

reg = args_ref(1LL);
v0 = vector_len(reg);
if ( v0 > 0 )
{
v1 = v0;
for ( i = 0; i != v1; ++i )
{
v3 = args_ref(2LL);
vector_set(reg, i, v3);
}
}
return args_pop(1LL);
}

original_code:
void vector_fill(void)
{
 int i, len;
 reg = args_ref(1);
 len = vector_len(reg);
 for (i=0; i < len; ++i){
  vector_set(reg, i, args_ref(2));
 }
 args_pop(1);
}

canonical_original_code:
void vector_fill()
{
 int i; int len;
 reg = args_ref(1);
 len = vector_len(reg);
 for (i=0; i < len; ++i){
  vector_set(reg, i, args_ref(2));
 }
 args_pop(1);
}


decompiled_code:
__int64 vars_init()
{
__int64 result; // rax

allocons = cons(0LL, 0LL);
reg = 0;
stack_init(&env_stack);
stack_init(&vars_stack);
stack_init(&args_stack);
stack_init(&parser_stack);
stack_init(&state_stack);
result = (unsigned int)the_global_env;
current_env = the_global_env;
return result;
}

canonical_decompiled_code:
__int64 func0()
{
__int64 result; // rax

allocons = cons(0LL, 0LL);
reg = 0;
stack_init(&env_stack);
stack_init(&vars_stack);
stack_init(&args_stack);
stack_init(&parser_stack);
stack_init(&state_stack);
result = (unsigned int)the_global_env;
current_env = the_global_env;
return result;
}

original_code:
void vars_init(void)
{
 allocons = cons(0, 0);
 reg = 0;
 stack_init(&env_stack);
 stack_init(&vars_stack);
 stack_init(&args_stack);
 stack_init(&parser_stack);
 stack_init(&state_stack);
 current_env = the_global_env;
}

canonical_original_code:
void vars_init()
{
 allocons = cons(0, 0);
 reg = 0;
 stack_init(&env_stack);
 stack_init(&vars_stack);
 stack_init(&args_stack);
 stack_init(&parser_stack);
 stack_init(&state_stack);
 current_env = the_global_env;
}


initial

decompiled_code:
__int64 initial()
{
memory_init();
bool_init();
parser_init();
init_obarray();
the_global_env = setup_environment();
vars_init();
return gc_init();
}

canonical_decompiled_code:
__int64 func1()
{
memory_init();
bool_init();
parser_init();
init_obarray();
the_global_env = setup_environment();
func0();
return gc_init();
}

original_code:
void initial(void)
{
 memory_init();
 bool_init();
 parser_init();
 init_obarray();
 the_global_env = setup_environment();
 vars_init();
 gc_init();
}

canonical_original_code:
void initial()
{
 memory_init();
 bool_init();
 parser_init();
 init_obarray();
 the_global_env = setup_environment();
 vars_init();
 gc_init();
}


decompiled_code:
__int64 __fastcall args_ref(int a1)
{
__int64 v2; // rdi

v2 = (unsigned int)args_stack;
if ( a1 > 1 )
{
do
{
v2 = (unsigned int)cdr(v2);
--a1;
}
while ( a1 != 1 );
}
return car(v2);
}

canonical_decompiled_code:
__int64 __fastcall func2(int a1)
{
__int64 v2; // rdi

v2 = (unsigned int)args_stack;
if ( a1 > 1 )
{
do
{
v2 = (unsigned int)cdr(v2);
--a1;
}
while ( a1 != 1 );
}
return car(v2);
}

original_code:
cellpoint args_ref(int n)
{
 cellpoint args = args_stack;
 while (n > 1){
  args = cdr(args);
  --n;
 }
  return car(args);
}

canonical_original_code:
unsigned int args_ref(int n)
{
 unsigned int args = args_stack;
 while (n > 1){
  args = cdr(args);
  --n;
 }
  return car(args);
}

variable_types: n int

variable_types:
args
unsigned int


decompiled_code:
__int64 __fastcall args_push(unsigned int a1)
{
return stack_push(&args_stack, a1);
}

canonical_decompiled_code:
__int64 __fastcall func3(unsigned int a1)
{
return stack_push(&args_stack, a1);
}

original_code:
void args_push(cellpoint arg)
{
 stack_push(&args_stack, arg);
}

canonical_original_code:
void args_push(unsigned int arg)
{
 stack_push(&args_stack, arg);
}


decompiled_code:
__int64 __fastcall args_pop(int a1)
{
int v1; // ebx
__int64 result; // rax

v1 = a1;
if ( a1 > 0 )
{
do
{
result = stack_pop(&args_stack);
--v1;
}
while ( v1 );
}
return result;
}

canonical_decompiled_code:
__int64 __fastcall func4(int a1)
{
int v1; // ebx
__int64 result; // rax

v1 = a1;
if ( a1 > 0 )
{
do
{
result = stack_pop(&args_stack);
--v1;
}
while ( v1 );
}
return result;
}

original_code:
void args_pop(int n)
{
 while (n > 0){
  stack_pop(&args_stack);
  --n;
 }
}


decompiled_code:
void __noreturn error_handler()
{
longjmp(jump_buffer, 1);
}

canonical_decompiled_code:
void __noreturn func5()
{
longjmp(jump_buffer, 1);
}

original_code:
void error_handler(void)
{
 longjmp(jump_buffer, 1);
}

canonical_original_code:
void error_handler()
{
 longjmp(jump_buffer, 1);
}


eq

decompiled_code:
__int64 eq()
{
int v0; // ebx
bool v1; // zf
int v2; // eax

v0 = args_ref(1LL);
v1 = v0 == (unsigned int)args_ref(2LL);
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func0()
{
int v0; // ebx
bool v1; // zf
int v2; // eax

v0 = args_ref(1LL);
v1 = v0 == (unsigned int)args_ref(2LL);
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(2LL);
return reg;
}

original_code:
cellpoint eq(void)
{
 if (args_ref(1) == args_ref(2)){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int eq()
{
 if (args_ref(1) == args_ref(2)){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


eqv

decompiled_code:
__int64 eqv()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // eax
unsigned int v14; // eax
unsigned int v15; // eax
unsigned int v16; // eax
unsigned int v17; // eax
unsigned int v18; // eax
unsigned int v19; // eax
int v20; // ebx
bool v21; // zf
int v22; // eax
int v23; // ebx
int v24; // eax
unsigned int v25; // eax
unsigned int v26; // eax
unsigned int v27; // eax
unsigned int v28; // eax
unsigned int v29; // eax
unsigned int v30; // eax
unsigned int v31; // eax
unsigned int v32; // eax
unsigned int v33; // eax
unsigned int v34; // eax
unsigned int v35; // eax
unsigned int v36; // eax
unsigned int v37; // eax
unsigned int v38; // eax
unsigned int v39; // eax
unsigned int v40; // eax
int v42; // ebx
int v43; // eax
int v44; // ebx
int v45; // eax
int v46; // ebx
int v47; // eax
unsigned int v48; // eax
unsigned int v49; // eax
int v50; // ebx
int v51; // eax

v0 = args_ref(1LL);
v1 = is_boolean(v0);
if ( (unsigned int)is_true(v1) && (v2 = args_ref(2LL), v3 = is_boolean(v2), (unsigned int)is_true(v3)) )
{
v20 = args_ref(1LL);
v21 = v20 == (unsigned int)args_ref(2LL);
v22 = a_true;
if ( !v21 )
v22 = a_false;
reg = v22;
}
else
{
v4 = args_ref(1LL);
v5 = is_symbol(v4);
if ( (unsigned int)is_true(v5) && (v6 = args_ref(2LL), v7 = is_symbol(v6), (unsigned int)is_true(v7)) )
{
v23 = args_ref(1LL);
v21 = v23 == (unsigned int)args_ref(2LL);
v24 = a_true;
if ( !v21 )
v24 = a_false;
reg = v24;
}
else
{
v8 = args_ref(1LL);
v9 = is_number(v8);
if ( (unsigned int)is_true(v9) && (v10 = args_ref(2LL), v11 = is_number(v10), (unsigned int)is_true(v11)) )
{
reg = args_ref(1LL);
v25 = args_ref(2LL);
args_push(v25);
args_push(reg);
reg = number_eq();
}
else
{
v12 = args_ref(1LL);
v13 = is_char(v12);
if ( (unsigned int)is_true(v13) && (v14 = args_ref(2LL), v15 = is_char(v14), (unsigned int)is_true(v15)) )
{
reg = args_ref(1LL);
v26 = args_ref(2LL);
args_push(v26);
args_push(reg);
reg = char_eq();
}
else
{
v16 = args_ref(1LL);
v17 = is_null(v16);
if ( (unsigned int)is_true(v17) && (v18 = args_ref(2LL), v19 = is_null(v18), (unsigned int)is_true(v19)) )
{
reg = a_true;
}
else
{
v27 = args_ref(1LL);
v28 = is_pair(v27);
if ( (unsigned int)is_true(v28) && (v29 = args_ref(2LL), v30 = is_pair(v29), (unsigned int)is_true(v30)) )
{
v42 = args_ref(1LL);
v21 = v42 == (unsigned int)args_ref(2LL);
v43 = a_true;
if ( !v21 )
v43 = a_false;
reg = v43;
}
else
{
v31 = args_ref(1LL);
v32 = is_string(v31);
if ( (unsigned int)is_true(v32) && (v33 = args_ref(2LL), v34 = is_string(v33), (unsigned int)is_true(v34)) )
{
v44 = args_ref(1LL);
v21 = v44 == (unsigned int)args_ref(2LL);
v45 = a_true;
if ( !v21 )
v45 = a_false;
reg = v45;
}
else
{
v35 = args_ref(1LL);
v36 = is_vector(v35);
if ( (unsigned int)is_true(v36)
&& (v37 = args_ref(2LL), v38 = is_vector(v37), (unsigned int)is_true(v38)) )
{
v46 = args_ref(1LL);
v21 = v46 == (unsigned int)args_ref(2LL);
v47 = a_true;
if ( !v21 )
v47 = a_false;
reg = v47;
}
else
{
v39 = args_ref(1LL);
v40 = is_procedure(v39);
if ( (unsigned int)is_true(v40)
&& (v48 = args_ref(2LL), v49 = is_procedure(v48), (unsigned int)is_true(v49)) )
{
v50 = args_ref(1LL);
v21 = v50 == (unsigned int)args_ref(2LL);
v51 = a_true;
if ( !v21 )
v51 = a_false;
reg = v51;
}
else
{
reg = a_false;
}
}
}
}
}
}
}
}
}
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func1()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // eax
unsigned int v14; // eax
unsigned int v15; // eax
unsigned int v16; // eax
unsigned int v17; // eax
unsigned int v18; // eax
unsigned int v19; // eax
int v20; // ebx
bool v21; // zf
int v22; // eax
int v23; // ebx
int v24; // eax
unsigned int v25; // eax
unsigned int v26; // eax
unsigned int v27; // eax
unsigned int v28; // eax
unsigned int v29; // eax
unsigned int v30; // eax
unsigned int v31; // eax
unsigned int v32; // eax
unsigned int v33; // eax
unsigned int v34; // eax
unsigned int v35; // eax
unsigned int v36; // eax
unsigned int v37; // eax
unsigned int v38; // eax
unsigned int v39; // eax
unsigned int v40; // eax
int v42; // ebx
int v43; // eax
int v44; // ebx
int v45; // eax
int v46; // ebx
int v47; // eax
unsigned int v48; // eax
unsigned int v49; // eax
int v50; // ebx
int v51; // eax

v0 = args_ref(1LL);
v1 = is_boolean(v0);
if ( (unsigned int)is_true(v1) && (v2 = args_ref(2LL), v3 = is_boolean(v2), (unsigned int)is_true(v3)) )
{
v20 = args_ref(1LL);
v21 = v20 == (unsigned int)args_ref(2LL);
v22 = a_true;
if ( !v21 )
v22 = a_false;
reg = v22;
}
else
{
v4 = args_ref(1LL);
v5 = is_symbol(v4);
if ( (unsigned int)is_true(v5) && (v6 = args_ref(2LL), v7 = is_symbol(v6), (unsigned int)is_true(v7)) )
{
v23 = args_ref(1LL);
v21 = v23 == (unsigned int)args_ref(2LL);
v24 = a_true;
if ( !v21 )
v24 = a_false;
reg = v24;
}
else
{
v8 = args_ref(1LL);
v9 = is_number(v8);
if ( (unsigned int)is_true(v9) && (v10 = args_ref(2LL), v11 = is_number(v10), (unsigned int)is_true(v11)) )
{
reg = args_ref(1LL);
v25 = args_ref(2LL);
args_push(v25);
args_push(reg);
reg = number_eq();
}
else
{
v12 = args_ref(1LL);
v13 = is_char(v12);
if ( (unsigned int)is_true(v13) && (v14 = args_ref(2LL), v15 = is_char(v14), (unsigned int)is_true(v15)) )
{
reg = args_ref(1LL);
v26 = args_ref(2LL);
args_push(v26);
args_push(reg);
reg = char_eq();
}
else
{
v16 = args_ref(1LL);
v17 = is_null(v16);
if ( (unsigned int)is_true(v17) && (v18 = args_ref(2LL), v19 = is_null(v18), (unsigned int)is_true(v19)) )
{
reg = a_true;
}
else
{
v27 = args_ref(1LL);
v28 = is_pair(v27);
if ( (unsigned int)is_true(v28) && (v29 = args_ref(2LL), v30 = is_pair(v29), (unsigned int)is_true(v30)) )
{
v42 = args_ref(1LL);
v21 = v42 == (unsigned int)args_ref(2LL);
v43 = a_true;
if ( !v21 )
v43 = a_false;
reg = v43;
}
else
{
v31 = args_ref(1LL);
v32 = is_string(v31);
if ( (unsigned int)is_true(v32) && (v33 = args_ref(2LL), v34 = is_string(v33), (unsigned int)is_true(v34)) )
{
v44 = args_ref(1LL);
v21 = v44 == (unsigned int)args_ref(2LL);
v45 = a_true;
if ( !v21 )
v45 = a_false;
reg = v45;
}
else
{
v35 = args_ref(1LL);
v36 = is_vector(v35);
if ( (unsigned int)is_true(v36)
&& (v37 = args_ref(2LL), v38 = is_vector(v37), (unsigned int)is_true(v38)) )
{
v46 = args_ref(1LL);
v21 = v46 == (unsigned int)args_ref(2LL);
v47 = a_true;
if ( !v21 )
v47 = a_false;
reg = v47;
}
else
{
v39 = args_ref(1LL);
v40 = is_procedure(v39);
if ( (unsigned int)is_true(v40)
&& (v48 = args_ref(2LL), v49 = is_procedure(v48), (unsigned int)is_true(v49)) )
{
v50 = args_ref(1LL);
v21 = v50 == (unsigned int)args_ref(2LL);
v51 = a_true;
if ( !v21 )
v51 = a_false;
reg = v51;
}
else
{
reg = a_false;
}
}
}
}
}
}
}
}
}
args_pop(2LL);
return reg;
}

original_code:
cellpoint eqv(void)
{
    if (is_true(is_boolean(args_ref(1))) &&
  is_true(is_boolean(args_ref(2)))){
        reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_symbol(args_ref(1))) &&
     is_true(is_symbol(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_number(args_ref(1))) &&
     is_true(is_number(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = number_eq();
    }else if (is_true(is_char(args_ref(1))) &&
     is_true(is_char(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = char_eq();
    }else if (is_true(is_null(args_ref(1))) &&
     is_true(is_null(args_ref(2)))){
        reg = a_true;
    }else if (is_true(is_pair(args_ref(1))) &&
     is_true(is_pair(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_string(args_ref(1))) &&
     is_true(is_string(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_vector(args_ref(1))) &&
     is_true(is_vector(args_ref(2)))){
        reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_procedure(args_ref(1))) &&
     is_true(is_procedure(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int eqv()
{
    if (is_true(is_boolean(args_ref(1))) &&
  is_true(is_boolean(args_ref(2)))){
        reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_symbol(args_ref(1))) &&
     is_true(is_symbol(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_number(args_ref(1))) &&
     is_true(is_number(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = number_eq();
    }else if (is_true(is_char(args_ref(1))) &&
     is_true(is_char(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = char_eq();
    }else if (is_true(is_null(args_ref(1))) &&
     is_true(is_null(args_ref(2)))){
        reg = a_true;
    }else if (is_true(is_pair(args_ref(1))) &&
     is_true(is_pair(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_string(args_ref(1))) &&
     is_true(is_string(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_vector(args_ref(1))) &&
     is_true(is_vector(args_ref(2)))){
        reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
    }else if (is_true(is_procedure(args_ref(1))) &&
     is_true(is_procedure(args_ref(2)))){
  reg = (args_ref(1) == args_ref(2)) ? a_true : a_false;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


equal

decompiled_code:
__int64 equal()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v14; // eax
unsigned int v15; // eax
unsigned int v16; // eax

v0 = args_ref(1LL);
v1 = is_string(v0);
if ( (unsigned int)is_true(v1) && (v2 = args_ref(2LL), v3 = is_string(v2), (unsigned int)is_true(v3)) )
{
reg = args_ref(1LL);
v14 = args_ref(2LL);
args_push(v14);
args_push(reg);
reg = string_eq();
}
else
{
v4 = args_ref(1LL);
v5 = is_vector(v4);
if ( (unsigned int)is_true(v5) && (v6 = args_ref(2LL), v7 = is_vector(v6), (unsigned int)is_true(v7)) )
{
reg = args_ref(1LL);
v15 = args_ref(2LL);
args_push(v15);
args_push(reg);
reg = vector_eq();
}
else
{
v8 = args_ref(1LL);
v9 = is_list(v8);
if ( (unsigned int)is_true(v9) && (v10 = args_ref(2LL), v11 = is_list(v10), (unsigned int)is_true(v11)) )
{
reg = args_ref(1LL);
v16 = args_ref(2LL);
args_push(v16);
args_push(reg);
reg = list_eq();
}
else
{
reg = args_ref(1LL);
v12 = args_ref(2LL);
args_push(v12);
args_push(reg);
reg = eqv();
}
}
}
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func2()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v14; // eax
unsigned int v15; // eax
unsigned int v16; // eax

v0 = args_ref(1LL);
v1 = is_string(v0);
if ( (unsigned int)is_true(v1) && (v2 = args_ref(2LL), v3 = is_string(v2), (unsigned int)is_true(v3)) )
{
reg = args_ref(1LL);
v14 = args_ref(2LL);
args_push(v14);
args_push(reg);
reg = string_eq();
}
else
{
v4 = args_ref(1LL);
v5 = is_vector(v4);
if ( (unsigned int)is_true(v5) && (v6 = args_ref(2LL), v7 = is_vector(v6), (unsigned int)is_true(v7)) )
{
reg = args_ref(1LL);
v15 = args_ref(2LL);
args_push(v15);
args_push(reg);
reg = vector_eq();
}
else
{
v8 = args_ref(1LL);
v9 = is_list(v8);
if ( (unsigned int)is_true(v9) && (v10 = args_ref(2LL), v11 = is_list(v10), (unsigned int)is_true(v11)) )
{
reg = args_ref(1LL);
v16 = args_ref(2LL);
args_push(v16);
args_push(reg);
reg = list_eq();
}
else
{
reg = args_ref(1LL);
v12 = args_ref(2LL);
args_push(v12);
args_push(reg);
reg = func1();
}
}
}
args_pop(2LL);
return reg;
}

original_code:
cellpoint equal(void)
{
    if (is_true(is_string(args_ref(1))) &&
  is_true(is_string(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = string_eq();
    }else if (is_true(is_vector(args_ref(1))) &&
     is_true(is_vector(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = vector_eq();
    }else if (is_true(is_list(args_ref(1))) &&
     is_true(is_list(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = list_eq();
 }else {
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = eqv();
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int equal()
{
    if (is_true(is_string(args_ref(1))) &&
  is_true(is_string(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = string_eq();
    }else if (is_true(is_vector(args_ref(1))) &&
     is_true(is_vector(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = vector_eq();
    }else if (is_true(is_list(args_ref(1))) &&
     is_true(is_list(args_ref(2)))){
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = list_eq();
 }else {
  reg = args_ref(1);
  args_push(args_ref(2));
  args_push(reg);
  reg = eqv();
 }
 args_pop(2);
 return reg;
}


decompiled_code:
_BOOL8 __fastcall stack_is_empty(_DWORD *a1)
{
return *a1 == 0;
}

canonical_decompiled_code:
_BOOL8 __fastcall func1(_DWORD *a1)
{
return *a1 == 0;
}

original_code:
int stack_is_empty(t_stack *st)
{
    return *st == 0;
}

canonical_original_code:
int stack_is_empty(unsigned int *st)
{
    return *st == 0;
}

variable_types:
st
unsigned int *

return_type: int


decompiled_code:
__int64 __fastcall stack_push(_DWORD *a1, unsigned int a2)
{
__int64 result; // rax

result = cons(a2, (unsigned int)*a1);
*a1 = result;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func2(_DWORD *a1, unsigned int a2)
{
__int64 result; // rax

result = cons(a2, (unsigned int)*a1);
*a1 = result;
return result;
}

original_code:
void stack_push(t_stack *st, cellpoint ele)
{
    *st = cons(ele, *st);
}

canonical_original_code:
void stack_push(unsigned int *st, unsigned int ele)
{
    *st = cons(ele, *st);
}

variable_types:
ele
unsigned int


decompiled_code:
__int64 __fastcall stack_pop(_DWORD *a1)
{
unsigned int v1; // ebp

if ( stack_is_empty(a1) )
{
perror("Error: the stack is empty. --STACK_POP\n");
error_handler();
}
v1 = car((unsigned int)*a1);
*a1 = cdr((unsigned int)*a1);
return v1;
}

canonical_decompiled_code:
__int64 __fastcall func3(_DWORD *a1)
{
unsigned int v1; // ebp

if ( func1(a1) )
{
perror("Error: the stack is empty. --STACK_POP\n");
error_handler();
}
v1 = car((unsigned int)*a1);
*a1 = cdr((unsigned int)*a1);
return v1;
}

original_code:
cellpoint stack_pop(t_stack *st)
{
    if (stack_is_empty(st)){
        perror("Error: the stack is empty. --STACK_POP\n");
  error_handler();
    }
    cellpoint top = car(*st);
    *st = cdr(*st);
    return top;
}

canonical_original_code:
unsigned int stack_pop(unsigned int *st)
{
    if (stack_is_empty(st)){
        perror("Error: the stack is empty. --STACK_POP\n");
  error_handler();
    }
    unsigned int top = car(*st);
    *st = cdr(*st);
    return top;
}

variable_types:
top
unsigned int


decompiled_code:
__int64 __fastcall stack_top(_DWORD *a1)
{
if ( stack_is_empty(a1) )
{
perror("Error: the stack is empty. --STACK_TOP\n");
error_handler();
}
return car((unsigned int)*a1);
}

canonical_decompiled_code:
__int64 __fastcall func4(_DWORD *a1)
{
if ( func1(a1) )
{
perror("Error: the stack is empty. --STACK_TOP\n");
error_handler();
}
return car((unsigned int)*a1);
}

original_code:
cellpoint stack_top(t_stack *st)
{
    if (stack_is_empty(st)){
        perror("Error: the stack is empty. --STACK_TOP\n");
  error_handler();
    }
    return car(*st);
}

canonical_original_code:
unsigned int stack_top(unsigned int *st)
{
    if (stack_is_empty(st)){
        perror("Error: the stack is empty. --STACK_TOP\n");
  error_handler();
    }
    return car(*st);
}


decompiled_code:
__int64 symbol_2_string()
{
unsigned int v0; // eax
__int64 v1; // rax

v0 = args_ref(1LL);
v1 = get_symbol(v0);
reg = chars_2_string(v1);
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func0()
{
unsigned int v0; // eax
__int64 v1; // rax

v0 = args_ref(1LL);
v1 = get_symbol(v0);
reg = chars_2_string(v1);
args_pop(1LL);
return reg;
}

original_code:
cellpoint symbol_2_string(void)
{
 reg = chars_2_string(get_symbol(args_ref(1)));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int symbol_2_string()
{
 reg = chars_2_string(get_symbol(args_ref(1)));
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 string_2_symbol()
{
unsigned int v0; // eax
void *v1; // rbx

v0 = args_ref(1LL);
v1 = (void *)get_string(v0);
reg = make_symbol(v1);
free(v1);
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func1()
{
unsigned int v0; // eax
void *v1; // rbx

v0 = args_ref(1LL);
v1 = (void *)get_string(v0);
reg = make_symbol(v1);
free(v1);
args_pop(1LL);
return reg;
}

original_code:
cellpoint string_2_symbol(void)
{
 char *s = get_string(args_ref(1));
 reg = make_symbol(s);
 free(s);
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int string_2_symbol()
{
 char *s = get_string(args_ref(1));
 reg = make_symbol(s);
 free(s);
 args_pop(1);
 return reg;
}

variable_types:
s
char *


decompiled_code:
__int64 number_eq()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // zf
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 == (unsigned int)get_integer(v2);
v4 = a_true;
if ( !v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func0()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // zf
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 == (unsigned int)get_integer(v2);
v4 = a_true;
if ( !v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

original_code:
cellpoint number_eq(void)
{
 if (get_integer(args_ref(1)) == get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int number_eq()
{
 if (get_integer(args_ref(1)) == get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 number_less()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 < (int)get_integer(v2);
v4 = a_true;
if ( !v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func1()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 < (int)get_integer(v2);
v4 = a_true;
if ( !v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

original_code:
cellpoint number_less(void)
{
 if (get_integer(args_ref(1)) < get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int number_less()
{
 if (get_integer(args_ref(1)) < get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 number_greater()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 <= (int)get_integer(v2);
v4 = a_true;
if ( v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func2()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 <= (int)get_integer(v2);
v4 = a_true;
if ( v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

original_code:
cellpoint number_greater(void)
{
 if (get_integer(args_ref(1)) > get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int number_greater()
{
 if (get_integer(args_ref(1)) > get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 number_less_eq()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 <= (int)get_integer(v2);
v4 = a_true;
if ( !v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func3()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 <= (int)get_integer(v2);
v4 = a_true;
if ( !v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

original_code:
cellpoint number_less_eq(void)
{
 if (get_integer(args_ref(1)) <= get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int number_less_eq()
{
 if (get_integer(args_ref(1)) <= get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 number_greater_eq()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 < (int)get_integer(v2);
v4 = a_true;
if ( v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func4()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = v1 < (int)get_integer(v2);
v4 = a_true;
if ( v3 )
v4 = a_false;
reg = v4;
args_pop(2LL);
return reg;
}

original_code:
cellpoint number_greater_eq(void)
{
 if (get_integer(args_ref(1)) >= get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int number_greater_eq()
{
 if (get_integer(args_ref(1)) >= get_integer(args_ref(2))){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


add

decompiled_code:
__int64 add()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 + v3));
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func5()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 + v3));
args_pop(2LL);
return reg;
}

original_code:
cellpoint add(void)
{
 reg = make_integer(get_integer(args_ref(1)) + get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int add()
{
 reg = make_integer(get_integer(args_ref(1)) + get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}


sub

decompiled_code:
__int64 sub()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 - v3));
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func6()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 - v3));
args_pop(2LL);
return reg;
}

original_code:
cellpoint sub(void)
{
 reg = make_integer(get_integer(args_ref(1)) - get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int sub()
{
 reg = make_integer(get_integer(args_ref(1)) - get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}


mul

decompiled_code:
__int64 mul()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v3 * v1));
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func7()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v3 * v1));
args_pop(2LL);
return reg;
}

original_code:
cellpoint mul(void)
{
 reg = make_integer(get_integer(args_ref(1)) * get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int mul()
{
 reg = make_integer(get_integer(args_ref(1)) * get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}


mdiv

decompiled_code:
__int64 mdiv()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 / v3));
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func8()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 / v3));
args_pop(2LL);
return reg;
}

original_code:
cellpoint mdiv(void)
{
 reg = make_integer(get_integer(args_ref(1)) / get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int mdiv()
{
 reg = make_integer(get_integer(args_ref(1)) / get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}


mremainder

decompiled_code:
__int64 mremainder()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 % v3));
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func9()
{
unsigned int v0; // eax
int v1; // ebx
unsigned int v2; // eax
int v3; // eax

v0 = args_ref(1LL);
v1 = get_integer(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
reg = make_integer((unsigned int)(v1 % v3));
args_pop(2LL);
return reg;
}

original_code:
cellpoint mremainder(void)
{
 reg = make_integer(get_integer(args_ref(1)) % get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int mremainder()
{
 reg = make_integer(get_integer(args_ref(1)) % get_integer(args_ref(2)));
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 __fastcall write_proc(unsigned int a1)
{
int v1; // eax
size_t v2; // rdx

check_arglst_len_eq("write", 1LL, a1);
v1 = car(a1);
write(v1, &loc_1, v2);
return make_symbol("ok");
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1)
{
int v1; // eax
size_t v2; // rdx

check_arglst_len_eq("write", 1LL, a1);
v1 = car(a1);
write(v1, &loc_1, v2);
return make_symbol("ok");
}

original_code:
cellpoint write_proc(cellpoint arglst)
{
 check_arglst_len_eq("write", 1, arglst);
 write(car(arglst));
 return make_symbol("ok");
}

canonical_original_code:
unsigned int write_proc(unsigned int arglst)
{
 check_arglst_len_eq("write", 1, arglst);
 write(car(arglst));
 return make_symbol("ok");
}


decompiled_code:
__int64 __fastcall display_proc(unsigned int a1)
{
unsigned int v1; // eax

check_arglst_len_eq("display", 1LL, a1);
v1 = car(a1);
display(v1);
return make_symbol("ok");
}

canonical_decompiled_code:
__int64 __fastcall func1(unsigned int a1)
{
unsigned int v1; // eax

check_arglst_len_eq("display", 1LL, a1);
v1 = car(a1);
display(v1);
return make_symbol("ok");
}

original_code:
cellpoint display_proc(cellpoint arglst)
{
 check_arglst_len_eq("display", 1, arglst);
 display(car(arglst));
 return make_symbol("ok");
}

canonical_original_code:
unsigned int display_proc(unsigned int arglst)
{
 check_arglst_len_eq("display", 1, arglst);
 display(car(arglst));
 return make_symbol("ok");
}


decompiled_code:
__int64 __fastcall newline_proc(unsigned int a1)
{
check_arglst_len_eq("newline", 0LL, a1);
newline();
return make_symbol("ok");
}

canonical_decompiled_code:
__int64 __fastcall func2(unsigned int a1)
{
check_arglst_len_eq("newline", 0LL, a1);
newline();
return make_symbol("ok");
}

original_code:
cellpoint newline_proc(cellpoint arglst)
{
 check_arglst_len_eq("newline", 0, arglst);
 newline();
 return make_symbol("ok");
}

canonical_original_code:
unsigned int newline_proc(unsigned int arglst)
{
 check_arglst_len_eq("newline", 0, arglst);
 newline();
 return make_symbol("ok");
}


decompiled_code:
__int64 __fastcall write_char_proc(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax

check_arglst_len_eq("write-char", 1LL, a1);
v1 = car(a1);
check_arg_type("write-char", "first", v1, 1LL);
v2 = car(a1);
display(v2);
return make_symbol("ok");
}

canonical_decompiled_code:
__int64 __fastcall func3(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // eax

check_arglst_len_eq("write-char", 1LL, a1);
v1 = car(a1);
check_arg_type("write-char", "first", v1, 1LL);
v2 = car(a1);
display(v2);
return make_symbol("ok");
}

original_code:
cellpoint write_char_proc(cellpoint arglst)
{
 check_arglst_len_eq("write-char", 1, arglst);
 check_arg_type("write-char", "first", car(arglst), 1);
 display(car(arglst));
 return make_symbol("ok");
}

canonical_original_code:
unsigned int write_char_proc(unsigned int arglst)
{
 check_arglst_len_eq("write-char", 1, arglst);
 check_arg_type("write-char", "first", car(arglst), 1);
 display(car(arglst));
 return make_symbol("ok");
}


decompiled_code:
__int64 boolean_not()
{
unsigned int v0; // eax
bool v1; // zf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned int)is_false(v0) == 0;
v2 = a_true;
if ( v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func0()
{
unsigned int v0; // eax
bool v1; // zf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned int)is_false(v0) == 0;
v2 = a_true;
if ( v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

original_code:
cellpoint boolean_not(void)
{
    if (is_false(args_ref(1))){
        reg = a_true;
    }else {
        reg = a_false;
    }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int boolean_not()
{
    if (is_false(args_ref(1))){
        reg = a_true;
    }else {
        reg = a_false;
    }
 args_pop(1);
 return reg;
}