write

decompiled_code:
int __fastcall write(__int64 a1)
{
unsigned int v1; // 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

v1 = is_null(a1);
if ( (unsigned int)is_true(v1) )
return printf("()");
v3 = is_boolean((unsigned int)a1);
if ( (unsigned int)is_true(v3) )
return write_boolean();
v4 = is_number((unsigned int)a1);
if ( (unsigned int)is_true(v4) )
return write_number();
v5 = is_char((unsigned int)a1);
if ( (unsigned int)is_true(v5) )
return write_character();
v6 = is_symbol((unsigned int)a1);
if ( (unsigned int)is_true(v6) )
return write_symbol();
v7 = is_string((unsigned int)a1);
if ( (unsigned int)is_true(v7) )
return write_string(a1);
v8 = is_vector((unsigned int)a1);
if ( (unsigned int)is_true(v8) )
return write_vector((unsigned int)a1);
v9 = is_procedure((unsigned int)a1);
if ( (unsigned int)is_true(v9) )
return write_procedure((unsigned int)a1);
v10 = is_pair((unsigned int)a1);
if ( (unsigned int)is_true(v10) )
return write_pair((unsigned int)a1);
puts("write error.");
return error_handler();
}

canonical_decompiled_code:
int __fastcall func14(__int64 a1)
{
unsigned int v1; // 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

v1 = is_null(a1);
if ( (unsigned int)is_true(v1) )
return printf("()");
v3 = is_boolean((unsigned int)a1);
if ( (unsigned int)is_true(v3) )
return func1();
v4 = is_number((unsigned int)a1);
if ( (unsigned int)is_true(v4) )
return func3();
v5 = is_char((unsigned int)a1);
if ( (unsigned int)is_true(v5) )
return func4();
v6 = is_symbol((unsigned int)a1);
if ( (unsigned int)is_true(v6) )
return func7();
v7 = is_string((unsigned int)a1);
if ( (unsigned int)is_true(v7) )
return func9(a1);
v8 = is_vector((unsigned int)a1);
if ( (unsigned int)is_true(v8) )
return func15((unsigned int)a1);
v9 = is_procedure((unsigned int)a1);
if ( (unsigned int)is_true(v9) )
return func16((unsigned int)a1);
v10 = is_pair((unsigned int)a1);
if ( (unsigned int)is_true(v10) )
return func17((unsigned int)a1);
puts("write error.");
return error_handler();
}

original_code:
void write(cellpoint cp)
{
    if (is_true(is_null(cp))){
        printf("()");
    } else if (is_true(is_boolean(cp))){
        write_boolean(cp);
    } else if (is_true(is_number(cp))){
        write_number(cp);
    } else if (is_true(is_char(cp))){
        write_character(cp);
    } else if (is_true(is_symbol(cp))){
        write_symbol(cp);
    } else if (is_true(is_string(cp))){
        write_string(cp);
    } else if (is_true(is_vector(cp))){
        write_vector(cp);
    } else if (is_true(is_procedure(cp))){
  write_procedure(cp);
 }else if (is_true(is_pair(cp))){
        write_pair(cp);
    } else {
        printf("write error.\n");
  error_handler();
    }
}

canonical_original_code:
void write(unsigned int cp)
{
    if (is_true(is_null(cp))){
        printf("()");
    } else if (is_true(is_boolean(cp))){
        write_boolean(cp);
    } else if (is_true(is_number(cp))){
        write_number(cp);
    } else if (is_true(is_char(cp))){
        write_character(cp);
    } else if (is_true(is_symbol(cp))){
        write_symbol(cp);
    } else if (is_true(is_string(cp))){
        write_string(cp);
    } else if (is_true(is_vector(cp))){
        write_vector(cp);
    } else if (is_true(is_procedure(cp))){
  write_procedure(cp);
 }else if (is_true(is_pair(cp))){
        write_pair(cp);
    } else {
        printf("write error.\n");
  error_handler();
    }
}


decompiled_code:
int __fastcall write_vector(unsigned int a1)
{
int v1; // ebp
unsigned int i; // ebx
unsigned int v3; // eax

v1 = vector_len();
printf("#(");
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = vector_ref(a1, i);
write(v3);
putchar(32);
}
}
return putchar(41);
}

canonical_decompiled_code:
int __fastcall func15(unsigned int a1)
{
int v1; // ebp
unsigned int i; // ebx
unsigned int v3; // eax

v1 = vector_len();
printf("#(");
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = vector_ref(a1, i);
func14(v3);
putchar(32);
}
}
return putchar(41);
}

original_code:
static void write_vector(cellpoint cp)
{
    int i;
    int vlen = vector_len(cp);
    printf("#(");
    for (i=0; i < vlen; i++){
        write(vector_ref(cp, i));
        printf(" ");
    }
    printf(")");
}

canonical_original_code:
static void write_vector(unsigned int cp)
{
    int i;
    int vlen = vector_len(cp);
    printf("#(");
    for (i=0; i < vlen; i++){
        write(vector_ref(cp, i));
        printf(" ");
    }
    printf(")");
}

variable_types:
cp
unsigned int

variable_types: i int

variable_types: vlen int

return_type: void


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

printf("#<procedure:");
args_push(a1);
reg = procedure_name();
v1 = is_null(reg);
if ( (unsigned int)is_false(v1) )
write(reg);
return putchar(62);
}

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

printf("#<procedure:");
args_push(a1);
reg = procedure_name();
v1 = is_null(reg);
if ( (unsigned int)is_false(v1) )
func14(reg);
return putchar(62);
}

original_code:
static void write_procedure(cellpoint proc)
{
 printf("#<procedure:");
 args_push(proc);
 reg = procedure_name();
 if (is_false(is_null(reg))){
  write(reg);
 }
 printf(">");
}

canonical_original_code:
static void write_procedure(unsigned int proc)
{
 printf("#<procedure:");
 args_push(proc);
 reg = procedure_name();
 if (is_false(is_null(reg))){
  write(reg);
 }
 printf(">");
}

variable_types:
proc
unsigned int


decompiled_code:
int __fastcall write_pair(unsigned int a1)
{
unsigned int v1; // eax
unsigned int i; // ebx
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

putchar(40);
v1 = car(a1);
write(v1);
for ( i = cdr(a1); ; i = cdr(i) )
{
v4 = is_pair(i);
if ( !(unsigned int)is_true(v4) )
break;
putchar(32);
v3 = car(i);
write(v3);
}
v5 = is_null(i);
if ( (unsigned int)is_false(v5) )
{
printf(" . ");
write(i);
}
return putchar(41);
}

canonical_decompiled_code:
int __fastcall func17(unsigned int a1)
{
unsigned int v1; // eax
unsigned int i; // ebx
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

putchar(40);
v1 = car(a1);
func14(v1);
for ( i = cdr(a1); ; i = cdr(i) )
{
v4 = is_pair(i);
if ( !(unsigned int)is_true(v4) )
break;
putchar(32);
v3 = car(i);
func14(v3);
}
v5 = is_null(i);
if ( (unsigned int)is_false(v5) )
{
printf(" . ");
func14(i);
}
return putchar(41);
}

original_code:
static void write_pair(cellpoint cp)
{
    printf("(");
    write(car(cp));
 cp = cdr(cp);
 while (is_true(is_pair(cp))){
  printf(" ");
  write(car(cp));
  cp = cdr(cp);
 }
 if (is_false(is_null(cp))){
  printf(" . ");
  write(cp);
 }
 printf(")");
}

canonical_original_code:
static void write_pair(unsigned int cp)
{
    printf("(");
    write(car(cp));
 cp = cdr(cp);
 while (is_true(is_pair(cp))){
  printf(" ");
  write(car(cp));
  cp = cdr(cp);
 }
 if (is_false(is_null(cp))){
  printf(" . ");
  write(cp);
 }
 printf(")");
}


newline

decompiled_code:
int newline()
{
return putchar(10);
}

canonical_decompiled_code:
int func18()
{
return putchar(10);
}

original_code:
void newline(void)
{
    printf("\n");
}

canonical_original_code:
void newline()
{
    printf("\n");
}


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

check_arglst_len_eq("null?", 1LL, a1);
v1 = car(a1);
return is_null(v1);
}

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

check_arglst_len_eq("null?", 1LL, a1);
v1 = car(a1);
return is_null(v1);
}

original_code:
cellpoint null_proc(cellpoint arglst)
{
 check_arglst_len_eq("null?", 1, arglst);
 return is_null(car(arglst));
}

canonical_original_code:
unsigned int null_proc(unsigned int arglst)
{
 check_arglst_len_eq("null?", 1, arglst);
 return is_null(car(arglst));
}

variable_types:
arglst
unsigned int

return_type: unsigned int


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

check_arglst_len_eq("list?", 1LL, a1);
v1 = car(a1);
return is_list(v1);
}

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

check_arglst_len_eq("list?", 1LL, a1);
v1 = car(a1);
return is_list(v1);
}

original_code:
cellpoint list_pred_proc(cellpoint arglst)
{
 check_arglst_len_eq("list?", 1, arglst);
 return is_list(car(arglst));
}

canonical_original_code:
unsigned int list_pred_proc(unsigned int arglst)
{
 check_arglst_len_eq("list?", 1, arglst);
 return is_list(car(arglst));
}


decompiled_code:
__int64 list_proc()
{
args_push();
return list();
}

canonical_decompiled_code:
__int64 func2()
{
args_push();
return list();
}

original_code:
cellpoint list_proc(cellpoint arglst)
{
 args_push(arglst);
 return list();
}

canonical_original_code:
unsigned int list_proc(unsigned int arglst)
{
 args_push(arglst);
 return list();
}


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

check_arglst_len_eq("length", 1LL, a1);
v1 = car(a1);
check_arg_type("length", "first", v1, 8LL);
v2 = car(a1);
args_push(v2);
return list_len();
}

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

check_arglst_len_eq("length", 1LL, a1);
v1 = car(a1);
check_arg_type("length", "first", v1, 8LL);
v2 = car(a1);
args_push(v2);
return list_len();
}

original_code:
cellpoint length_proc(cellpoint arglst)
{
 check_arglst_len_eq("length", 1, arglst);
 check_arg_type("length", "first", car(arglst), 8);
 args_push(car(arglst));
 return list_len();
}

canonical_original_code:
unsigned int length_proc(unsigned int arglst)
{
 check_arglst_len_eq("length", 1, arglst);
 check_arg_type("length", "first", car(arglst), 8);
 args_push(car(arglst));
 return list_len();
}


decompiled_code:
__int64 __fastcall append_proc(__int64 a1)
{
args_push(a1);
return append();
}

canonical_decompiled_code:
__int64 __fastcall func4(__int64 a1)
{
args_push(a1);
return append();
}

original_code:
cellpoint append_proc(cellpoint arglst)
{
 args_push(arglst);
 return append();
}

canonical_original_code:
unsigned int append_proc(unsigned int arglst)
{
 args_push(arglst);
 return append();
}


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

check_arglst_len_eq("reverse", 1LL, a1);
v1 = car(a1);
check_arg_type("reverse", "first", v1, 8LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return reverse();
}

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

check_arglst_len_eq("reverse", 1LL, a1);
v1 = car(a1);
check_arg_type("reverse", "first", v1, 8LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return reverse();
}

original_code:
cellpoint reverse_proc(cellpoint arglst)
{
 check_arglst_len_eq("reverse", 1, arglst);
 check_arg_type("reverse", "first", car(arglst), 8);
 args_push(car(arglst));
 return reverse();
}

canonical_original_code:
unsigned int reverse_proc(unsigned int arglst)
{
 check_arglst_len_eq("reverse", 1, arglst);
 check_arg_type("reverse", "first", car(arglst), 8);
 args_push(car(arglst));
 return reverse();
}


decompiled_code:
__int64 __fastcall list_tail_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("list-tail", 2LL, a1);
v1 = car(a1);
check_arg_type("list-tail", "first", v1, 8LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("list-tail", "second", v3, 2LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return list_tail();
}

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("list-tail", 2LL, a1);
v1 = car(a1);
check_arg_type("list-tail", "first", v1, 8LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("list-tail", "second", v3, 2LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return list_tail();
}

original_code:
cellpoint list_tail_proc(cellpoint arglst)
{
 check_arglst_len_eq("list-tail", 2, arglst);
 check_arg_type("list-tail", "first", car(arglst), 8);
 check_arg_type("list-tail", "second", car(cdr(arglst)), 2);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return list_tail();
}

canonical_original_code:
unsigned int list_tail_proc(unsigned int arglst)
{
 check_arglst_len_eq("list-tail", 2, arglst);
 check_arg_type("list-tail", "first", car(arglst), 8);
 check_arg_type("list-tail", "second", car(cdr(arglst)), 2);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return list_tail();
}


decompiled_code:
__int64 __fastcall list_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
__int64 v6; // rdi

check_arglst_len_eq("list-ref", 2LL, a1);
v1 = car(a1);
check_arg_type("list-ref", "first", v1, 8LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("list-ref", "second", v3, 2LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return list_ref();
}

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("list-ref", 2LL, a1);
v1 = car(a1);
check_arg_type("list-ref", "first", v1, 8LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("list-ref", "second", v3, 2LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return list_ref();
}

original_code:
cellpoint list_ref_proc(cellpoint arglst)
{
 check_arglst_len_eq("list-ref", 2, arglst);
 check_arg_type("list-ref", "first", car(arglst), 8);
 check_arg_type("list-ref", "second", car(cdr(arglst)), 2);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return list_ref();
}

canonical_original_code:
unsigned int list_ref_proc(unsigned int arglst)
{
 check_arglst_len_eq("list-ref", 2, arglst);
 check_arg_type("list-ref", "first", car(arglst), 8);
 check_arg_type("list-ref", "second", car(cdr(arglst)), 2);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return list_ref();
}


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

check_arglst_len_eq("memq", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("memq", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return member(&eq);
}

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

check_arglst_len_eq("memq", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("memq", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return member(&eq);
}

original_code:
cellpoint memq_proc(cellpoint arglst)
{
 check_arglst_len_eq("memq", 2, arglst);
 check_arg_type("memq", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return member(eq);
}

canonical_original_code:
unsigned int memq_proc(unsigned int arglst)
{
 check_arglst_len_eq("memq", 2, arglst);
 check_arg_type("memq", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return member(eq);
}


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

check_arglst_len_eq("memv", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("memv", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return member(&eqv);
}

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

check_arglst_len_eq("memv", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("memv", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return member(&eqv);
}

original_code:
cellpoint memv_proc(cellpoint arglst)
{
 check_arglst_len_eq("memv", 2, arglst);
 check_arg_type("memv", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return member(eqv);
}

canonical_original_code:
unsigned int memv_proc(unsigned int arglst)
{
 check_arglst_len_eq("memv", 2, arglst);
 check_arg_type("memv", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return member(eqv);
}


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

check_arglst_len_eq("member", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("member", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return member(&equal);
}

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

check_arglst_len_eq("member", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("member", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return member(&equal);
}

original_code:
cellpoint member_proc(cellpoint arglst)
{
 check_arglst_len_eq("member", 2, arglst);
 check_arg_type("member", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return member(equal);
}

canonical_original_code:
unsigned int member_proc(unsigned int arglst)
{
 check_arglst_len_eq("member", 2, arglst);
 check_arg_type("member", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return member(equal);
}


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

check_arglst_len_eq("assq", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("assq", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return assoc(&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

check_arglst_len_eq("assq", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("assq", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return assoc(&eq);
}

original_code:
cellpoint assq_proc(cellpoint arglst)
{
 check_arglst_len_eq("assq", 2, arglst);
 check_arg_type("assq", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return assoc(eq);
}

canonical_original_code:
unsigned int assq_proc(unsigned int arglst)
{
 check_arglst_len_eq("assq", 2, arglst);
 check_arg_type("assq", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return assoc(eq);
}


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

check_arglst_len_eq("assv", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("assv", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return assoc(&eqv);
}

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

check_arglst_len_eq("assv", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("assv", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return assoc(&eqv);
}

original_code:
cellpoint assv_proc(cellpoint arglst)
{
 check_arglst_len_eq("assv", 2, arglst);
 check_arg_type("assv", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return assoc(eqv);
}

canonical_original_code:
unsigned int assv_proc(unsigned int arglst)
{
 check_arglst_len_eq("assv", 2, arglst);
 check_arg_type("assv", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return assoc(eqv);
}


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

check_arglst_len_eq("assoc", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("assoc", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return assoc(&equal);
}

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

check_arglst_len_eq("assoc", 2LL, a1);
v1 = cdr(a1);
v2 = car(v1);
check_arg_type("assoc", "second", v2, 8LL);
v3 = cdr(a1);
v4 = car(v3);
args_push(v4);
v5 = car(a1);
args_push(v5);
return assoc(&equal);
}

original_code:
cellpoint assoc_proc(cellpoint arglst)
{
 check_arglst_len_eq("assoc", 2, arglst);
 check_arg_type("assoc", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return assoc(equal);
}

canonical_original_code:
unsigned int assoc_proc(unsigned int arglst)
{
 check_arglst_len_eq("assoc", 2, arglst);
 check_arg_type("assoc", "second", car(cdr(arglst)), 8);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return assoc(equal);
}


string

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

v0 = args_ref(1LL);
args_push(v0);
v1 = list_len();
v2 = get_integer(v1);
v3 = args_ref(1LL);
stack_push(&vars_stack, v3);
reg = make_string((unsigned int)v2, 0LL);
stack_push(&vars_stack, reg);
if ( v2 > 0 )
{
for ( i = 0; i != v2; ++i )
{
reg = stack_pop(&vars_stack);
v5 = stack_top(&vars_stack);
v6 = car(v5);
string_set(reg, i, v6);
v7 = stack_pop(&vars_stack);
v8 = cdr(v7);
stack_push(&vars_stack, v8);
stack_push(&vars_stack, reg);
}
}
reg = stack_pop(&vars_stack);
stack_pop(&vars_stack);
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
args_push(v0);
v1 = list_len();
v2 = get_integer(v1);
v3 = args_ref(1LL);
stack_push(&vars_stack, v3);
reg = make_string((unsigned int)v2, 0LL);
stack_push(&vars_stack, reg);
if ( v2 > 0 )
{
for ( i = 0; i != v2; ++i )
{
reg = stack_pop(&vars_stack);
v5 = stack_top(&vars_stack);
v6 = car(v5);
string_set(reg, i, v6);
v7 = stack_pop(&vars_stack);
v8 = cdr(v7);
stack_push(&vars_stack, v8);
stack_push(&vars_stack, reg);
}
}
reg = stack_pop(&vars_stack);
stack_pop(&vars_stack);
args_pop(1LL);
return reg;
}

original_code:
cellpoint string(void)
{
 int len,i;
 args_push(args_ref(1));
 len = get_integer(list_len());
 stack_push(&vars_stack, args_ref(1));
 reg = make_string(len, 0);
 stack_push(&vars_stack, reg);
 for (i=0; i < len; ++i){
  reg = stack_pop(&vars_stack);
  string_set(reg, i, car(stack_top(&vars_stack)));
  stack_push(&vars_stack, cdr(stack_pop(&vars_stack)));
  stack_push(&vars_stack, reg);
 }
 reg = stack_pop(&vars_stack);
 stack_pop(&vars_stack);
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int string()
{
 int len; int i;
 args_push(args_ref(1));
 len = get_integer(list_len());
 stack_push(&vars_stack, args_ref(1));
 reg = make_string(len, 0);
 stack_push(&vars_stack, reg);
 for (i=0; i < len; ++i){
  reg = stack_pop(&vars_stack);
  string_set(reg, i, car(stack_top(&vars_stack)));
  stack_push(&vars_stack, cdr(stack_pop(&vars_stack)));
  stack_push(&vars_stack, reg);
 }
 reg = stack_pop(&vars_stack);
 stack_pop(&vars_stack);
 args_pop(1);
 return reg;
}

variable_types: len int


decompiled_code:
__int64 string_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 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_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 = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_eq();
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 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_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 = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_eq();
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 string_eq(void)
{
    int len1 = string_len(args_ref(1));
    int len2 = string_len(args_ref(2));
    if (args_ref(1) == args_ref(2)){
        args_pop(2);
  return a_true;
    }
    if (len1 != len2){
  args_pop(2);
        return a_false;
    }else {
        int i;
        for (i=0; i < len1; i++){
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_eq();
            if (is_false(reg)){
                args_pop(2);
    return a_false;
            }
        }
  args_pop(2);
        return a_true;
    }
}

canonical_original_code:
unsigned int string_eq()
{
    int len1 = string_len(args_ref(1));
    int len2 = string_len(args_ref(2));
    if (args_ref(1) == args_ref(2)){
        args_pop(2);
  return a_true;
    }
    if (len1 != len2){
  args_pop(2);
        return a_false;
    }else {
        int i;
        for (i=0; i < len1; i++){
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_eq();
            if (is_false(reg)){
                args_pop(2);
    return a_false;
            }
        }
  args_pop(2);
        return a_true;
    }
}


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

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

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

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

original_code:
cellpoint string_eq_ci(void)
{
 if (args_ref(1) == args_ref(2)){
  args_pop(2);
  return a_true;
 }
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i;
 if (len1 != len2){
  args_pop(2);
  return a_false;
 }
 for (i=0; i < len1; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_eq_ci();
  if (is_false(reg)){
   args_pop(2);
   return a_false;
  }
 }
 args_pop(2);
 return a_true;
}

canonical_original_code:
unsigned int string_eq_ci()
{
 if (args_ref(1) == args_ref(2)){
  args_pop(2);
  return a_true;
 }
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i;
 if (len1 != len2){
  args_pop(2);
  return a_false;
 }
 for (i=0; i < len1; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_eq_ci();
  if (is_false(reg)){
   args_pop(2);
   return a_false;
  }
 }
 args_pop(2);
 return a_true;
}


decompiled_code:
__int64 string_less()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 >= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_less();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_greater();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

canonical_decompiled_code:
__int64 func3()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 >= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_less();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_greater();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

original_code:
cellpoint string_less(void)
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i, len = len1;
 if (len1 >= len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_less();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_greater();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 < len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int string_less()
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i; int len = len1;
 if (len1 >= len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_less();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_greater();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 < len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 string_less_ci()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 >= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_less_ci();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_greater_ci();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

canonical_decompiled_code:
__int64 func4()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 >= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_less_ci();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_greater_ci();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

original_code:
cellpoint string_less_ci(void)
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i, len = len1;
 if (len1 > len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_less_ci();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_greater_ci();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 < len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int string_less_ci()
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i; int len = len1;
 if (len1 > len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_less_ci();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_greater_ci();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 < len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 string_greater()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 <= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_greater();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_less();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

canonical_decompiled_code:
__int64 func5()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 <= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_greater();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_less();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

original_code:
cellpoint string_greater(void)
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i, len = len1;
 if (len1 > len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_greater();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_less();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 > len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int string_greater()
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i; int len = len1;
 if (len1 > len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_greater();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_less();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 > len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 string_greater_ci()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 <= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_greater_ci();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_less_ci();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

canonical_decompiled_code:
__int64 func6()
{
unsigned int v0; // eax
int v1; // er13
unsigned int v2; // eax
int v3; // er12
int v4; // ebp
unsigned int v5; // ebx
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax
unsigned int v10; // eax
unsigned int v11; // eax
int v12; // eax
__int64 result; // rax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v4 = v1;
if ( v4 <= 0 )
{
LABEL_8:
v12 = a_true;
if ( v1 <= v3 )
v12 = a_false;
reg = v12;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
v6 = args_ref(1LL);
reg = string_ref(v6, v5);
v7 = args_ref(2LL);
v8 = string_ref(v7, v5);
args_push(v8);
args_push(reg);
reg = char_greater_ci();
if ( (unsigned int)is_true(reg) )
{
args_pop(2LL);
return a_true;
}
v9 = args_ref(1LL);
reg = string_ref(v9, v5);
v10 = args_ref(2LL);
v11 = string_ref(v10, v5);
args_push(v11);
args_push(reg);
reg = char_less_ci();
if ( (unsigned int)is_true(reg) )
break;
if ( v4 == ++v5 )
goto LABEL_8;
}
args_pop(2LL);
result = a_false;
}
return result;
}

original_code:
cellpoint string_greater_ci(void)
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i, len = len1;
 if (len1 > len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_greater_ci();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_less_ci();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 > len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int string_greater_ci()
{
 int len1 = string_len(args_ref(1));
 int len2 = string_len(args_ref(2));
 int i; int len = len1;
 if (len1 > len2){
  len = len2;
 }
 for (i=0; i < len; ++i){
  reg = string_ref(args_ref(1), i);
  args_push(string_ref(args_ref(2), i));
  args_push(reg);
  reg = char_greater_ci();
  if (is_true(reg)){
   args_pop(2);
   return a_true;
  }else {
   reg = string_ref(args_ref(1), i);
   args_push(string_ref(args_ref(2), i));
   args_push(reg);
   reg = char_less_ci();
   if (is_true(reg)){
    args_pop(2);
    return a_false;
   }
  }
 }
 if (len1 > len2){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(2);
 return reg;
}


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


substring

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

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
v4 = args_ref(3LL);
v5 = get_integer(v4);
if ( v3 < 0 || v3 > v5 || v1 < v5 )
{
printf(
"Error: the arguments must satisfy 0 <= start <= end <= (string-length string), but the string-length(%d), start(%d"
"), end(%d) don't satisfied.\n",
(unsigned int)v1,
(unsigned int)v3,
(unsigned int)v5);
error_handler();
}
reg = make_string((unsigned int)(v5 - v3), 0LL);
stack_push(&vars_stack, reg);
if ( v3 < v5 )
{
v6 = v5 - v3;
v7 = 0;
do
{
reg = stack_top(&vars_stack);
v8 = args_ref(1LL);
v9 = string_ref(v8, v7 + v3);
string_set(reg, v7++, v9);
}
while ( v7 != v6 );
}
reg = stack_pop(&vars_stack);
args_pop(3LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = get_integer(v2);
v4 = args_ref(3LL);
v5 = get_integer(v4);
if ( v3 < 0 || v3 > v5 || v1 < v5 )
{
printf(
"Error: the arguments must satisfy 0 <= start <= end <= (string-length string), but the string-length(%d), start(%d"
"), end(%d) don't satisfied.\n",
(unsigned int)v1,
(unsigned int)v3,
(unsigned int)v5);
error_handler();
}
reg = make_string((unsigned int)(v5 - v3), 0LL);
stack_push(&vars_stack, reg);
if ( v3 < v5 )
{
v6 = v5 - v3;
v7 = 0;
do
{
reg = stack_top(&vars_stack);
v8 = args_ref(1LL);
v9 = string_ref(v8, v7 + v3);
string_set(reg, v7++, v9);
}
while ( v7 != v6 );
}
reg = stack_pop(&vars_stack);
args_pop(3LL);
return reg;
}

original_code:
cellpoint substring(void)
{
 int len = string_len(args_ref(1));
 int start = get_integer(args_ref(2));
 int end = get_integer(args_ref(3));
 int i;
 if ( start < 0 || end < start || end > len){
  printf("Error: the arguments must satisfy 0 <= start <= end <= (string-length string), but the string-length(%d), start(%d), end(%d) don't satisfied.\n", len ,start, end);
  error_handler();
 }
 reg = make_string(end-start, 0);
 stack_push(&vars_stack, reg);
 for (i=start; i < end; ++i){
  reg = stack_top(&vars_stack);
  string_set(reg, i-start, string_ref(args_ref(1), i));
 }
 reg = stack_pop(&vars_stack);
 args_pop(3);
 return reg;
}

canonical_original_code:
unsigned int substring()
{
 int len = string_len(args_ref(1));
 int start = get_integer(args_ref(2));
 int end = get_integer(args_ref(3));
 int i;
 if ( start < 0 || end < start || end > len){
  printf("Error: the arguments must satisfy 0 <= start <= end <= (string-length string), but the string-length(%d), start(%d), end(%d) don't satisfied.\n", len ,start, end);
  error_handler();
 }
 reg = make_string(end-start, 0);
 stack_push(&vars_stack, reg);
 for (i=start; i < end; ++i){
  reg = stack_top(&vars_stack);
  string_set(reg, i-start, string_ref(args_ref(1), i));
 }
 reg = stack_pop(&vars_stack);
 args_pop(3);
 return reg;
}

variable_types: start int

variable_types: end int


decompiled_code:
__int64 string_append()
{
__int64 v0; // rsi
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
int v4; // ebp
unsigned int i; // ebx
unsigned int v6; // er12
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax

stack_push(&vars_stack, 0LL);
v0 = (unsigned int)args_ref(1LL);
stack_push(&vars_stack, v0);
while ( 1 )
{
v1 = stack_top(&vars_stack);
v2 = is_null(v1);
if ( !(unsigned int)is_false(v2) )
break;
reg = stack_pop(&vars_stack);
v3 = car(reg);
v4 = string_len(v3);
if ( v4 > 0 )
{
for ( i = 0; i != v4; ++i )
{
v6 = stack_pop(&vars_stack);
v7 = car(reg);
v8 = string_ref(v7, i);
v9 = cons(v8, v6);
stack_push(&vars_stack, v9);
}
}
reg = cdr(reg);
stack_push(&vars_stack, reg);
}
stack_pop(&vars_stack);
reg = stack_pop(&vars_stack);
args_push(reg);
reg = reverse();
args_push(reg);
reg = string();
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func12()
{
__int64 v0; // rsi
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
int v4; // ebp
unsigned int i; // ebx
unsigned int v6; // er12
unsigned int v7; // eax
unsigned int v8; // eax
unsigned int v9; // eax

stack_push(&vars_stack, 0LL);
v0 = (unsigned int)args_ref(1LL);
stack_push(&vars_stack, v0);
while ( 1 )
{
v1 = stack_top(&vars_stack);
v2 = is_null(v1);
if ( !(unsigned int)is_false(v2) )
break;
reg = stack_pop(&vars_stack);
v3 = car(reg);
v4 = string_len(v3);
if ( v4 > 0 )
{
for ( i = 0; i != v4; ++i )
{
v6 = stack_pop(&vars_stack);
v7 = car(reg);
v8 = string_ref(v7, i);
v9 = cons(v8, v6);
stack_push(&vars_stack, v9);
}
}
reg = cdr(reg);
stack_push(&vars_stack, reg);
}
stack_pop(&vars_stack);
reg = stack_pop(&vars_stack);
args_push(reg);
reg = reverse();
args_push(reg);
reg = func0();
args_pop(1LL);
return reg;
}

original_code:
cellpoint string_append(void)
{
 stack_push(&vars_stack, 0);
 stack_push(&vars_stack, args_ref(1));
 while (is_false(is_null(stack_top(&vars_stack)))){
  int len, i;
  reg = stack_pop(&vars_stack);
  len = string_len(car(reg));
  for (i=0; i < len; ++i){
   stack_push(&vars_stack,cons(string_ref(car(reg), i), stack_pop(&vars_stack)));
  }
  reg = cdr(reg);
  stack_push(&vars_stack, reg);
 }
 stack_pop(&vars_stack);
 reg = stack_pop(&vars_stack);
 args_push(reg);
 reg = reverse();
 args_push(reg);
 reg = string();
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int string_append()
{
 stack_push(&vars_stack, 0);
 stack_push(&vars_stack, args_ref(1));
 while (is_false(is_null(stack_top(&vars_stack)))){
  int len; int i;
  reg = stack_pop(&vars_stack);
  len = string_len(car(reg));
  for (i=0; i < len; ++i){
   stack_push(&vars_stack,cons(string_ref(car(reg), i), stack_pop(&vars_stack)));
  }
  reg = cdr(reg);
  stack_push(&vars_stack, reg);
 }
 stack_pop(&vars_stack);
 reg = stack_pop(&vars_stack);
 args_push(reg);
 reg = reverse();
 args_push(reg);
 reg = string();
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 string_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 = string_len(v0);
reg = 0;
v2 = v1 - 1;
if ( v1 - 1 >= 0 )
{
do
{
v3 = reg;
v4 = args_ref(1LL);
v5 = string_ref(v4, v2);
reg = cons(v5, v3);
--v2;
}
while ( v2 != -1 );
}
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func13()
{
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 = string_len(v0);
reg = 0;
v2 = v1 - 1;
if ( v1 - 1 >= 0 )
{
do
{
v3 = reg;
v4 = args_ref(1LL);
v5 = string_ref(v4, v2);
reg = cons(v5, v3);
--v2;
}
while ( v2 != -1 );
}
args_pop(1LL);
return reg;
}

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

canonical_original_code:
unsigned int string_2_list()
{
 int len = string_len(args_ref(1));
 int i;
 reg = 0;
 for (i=len-1; i >= 0; --i){
  reg = cons(string_ref(args_ref(1),i), reg);
 }
 args_pop(1);
 return reg;
}


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

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

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

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

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

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


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

v0 = args_ref(1LL);
v1 = string_len(v0);
reg = make_string((unsigned int)v1, 0LL);
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = args_ref(1LL);
v4 = string_ref(v3, i);
string_set(reg, i, v4);
}
}
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = string_len(v0);
reg = make_string((unsigned int)v1, 0LL);
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = args_ref(1LL);
v4 = string_ref(v3, i);
string_set(reg, i, v4);
}
}
args_pop(1LL);
return reg;
}

original_code:
cellpoint string_copy(void)
{
 int len = string_len(args_ref(1));
 int i;
 reg = make_string(len, 0);
 for (i=0; i < len; ++i){
  string_set(reg, i, string_ref(args_ref(1), i));
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int string_copy()
{
 int len = string_len(args_ref(1));
 int i;
 reg = make_string(len, 0);
 for (i=0; i < len; ++i){
  string_set(reg, i, string_ref(args_ref(1), i));
 }
 args_pop(1);
 return reg;
}


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

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

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

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

original_code:
void string_fill(void)
{
 int len = string_len(args_ref(1));
 int i;
 reg = args_ref(2);
 for (i=0; i < len; ++i){
  string_set(args_ref(1), i, reg);
 }
 args_pop(1);
}

canonical_original_code:
void string_fill()
{
 int len = string_len(args_ref(1));
 int i;
 reg = args_ref(2);
 for (i=0; i < len; ++i){
  string_set(args_ref(1), i, reg);
 }
 args_pop(1);
}


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

check_arglst_len_eq("pair?", 1LL, a1);
v1 = car(a1);
return is_pair(v1);
}

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

check_arglst_len_eq("pair?", 1LL, a1);
v1 = car(a1);
return is_pair(v1);
}

original_code:
cellpoint pair_pred_proc(cellpoint arglst)
{
 check_arglst_len_eq("pair?", 1, arglst);
 cellpoint arg = car(arglst);
 return is_pair(arg);
}

canonical_original_code:
unsigned int pair_pred_proc(unsigned int arglst)
{
 check_arglst_len_eq("pair?", 1, arglst);
 unsigned int arg = car(arglst);
 return is_pair(arg);
}

variable_types:
arg
unsigned int


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

check_arglst_len_eq("cons", 2LL, a1);
v1 = car(a1);
v2 = cdr(a1);
v3 = car(v2);
return cons(v1, v3);
}

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

check_arglst_len_eq("cons", 2LL, a1);
v1 = car(a1);
v2 = cdr(a1);
v3 = car(v2);
return cons(v1, v3);
}

original_code:
cellpoint cons_proc(cellpoint arglst)
{
 check_arglst_len_eq("cons", 2, arglst);
 cellpoint farg = car(arglst);
 cellpoint sarg = car(cdr(arglst));
 return cons(farg, sarg);
}

canonical_original_code:
unsigned int cons_proc(unsigned int arglst)
{
 check_arglst_len_eq("cons", 2, arglst);
 unsigned int farg = car(arglst);
 unsigned int sarg = car(cdr(arglst));
 return cons(farg, sarg);
}

variable_types:
farg
unsigned int

variable_types:
sarg
unsigned int


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

check_arglst_len_eq("car", 1LL, a1);
v1 = car(a1);
check_arg_type("car", "first", v1, 7LL);
v2 = car(a1);
return car(v2);
}

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

check_arglst_len_eq("car", 1LL, a1);
v1 = car(a1);
check_arg_type("car", "first", v1, 7LL);
v2 = car(a1);
return car(v2);
}

original_code:
cellpoint car_proc(cellpoint arglst)
{
 check_arglst_len_eq("car", 1, arglst);
 check_arg_type("car", "first", car(arglst), 7);
 return car(car(arglst));
}

canonical_original_code:
unsigned int car_proc(unsigned int arglst)
{
 check_arglst_len_eq("car", 1, arglst);
 check_arg_type("car", "first", car(arglst), 7);
 return car(car(arglst));
}


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

check_arglst_len_eq("cdr", 1LL, a1);
v1 = car(a1);
check_arg_type("cdr", "first", v1, 7LL);
v2 = car(a1);
return cdr(v2);
}

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

check_arglst_len_eq("cdr", 1LL, a1);
v1 = car(a1);
check_arg_type("cdr", "first", v1, 7LL);
v2 = car(a1);
return cdr(v2);
}

original_code:
cellpoint cdr_proc(cellpoint arglst)
{
 check_arglst_len_eq("cdr", 1, arglst);
 check_arg_type("cdr", "first", car(arglst), 7);
 return cdr(car(arglst));
}

canonical_original_code:
unsigned int cdr_proc(unsigned int arglst)
{
 check_arglst_len_eq("cdr", 1, arglst);
 check_arg_type("cdr", "first", car(arglst), 7);
 return cdr(car(arglst));
}


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

check_arglst_len_eq("car-set!", 2LL, a1);
v1 = car(a1);
check_arg_type("car-set!", "first", v1, 7LL);
v2 = cdr(a1);
v3 = car(v2);
v4 = car(a1);
car_set(v4, v3);
return make_symbol("ok");
}

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

check_arglst_len_eq("car-set!", 2LL, a1);
v1 = car(a1);
check_arg_type("car-set!", "first", v1, 7LL);
v2 = cdr(a1);
v3 = car(v2);
v4 = car(a1);
car_set(v4, v3);
return make_symbol("ok");
}

original_code:
cellpoint car_set_proc(cellpoint arglst)
{
 check_arglst_len_eq("car-set!", 2, arglst);
 check_arg_type("car-set!", "first", car(arglst), 7);
 car_set(car(arglst), car(cdr(arglst)));
 return make_symbol("ok");
}

canonical_original_code:
unsigned int car_set_proc(unsigned int arglst)
{
 check_arglst_len_eq("car-set!", 2, arglst);
 check_arg_type("car-set!", "first", car(arglst), 7);
 car_set(car(arglst), car(cdr(arglst)));
 return make_symbol("ok");
}


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

check_arglst_len_eq("cdr-set!", 2LL, a1);
v1 = car(a1);
check_arg_type("cdr-set!", "first", v1, 7LL);
v2 = cdr(a1);
v3 = car(v2);
v4 = car(a1);
cdr_set(v4, v3);
return make_symbol("ok");
}

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

check_arglst_len_eq("cdr-set!", 2LL, a1);
v1 = car(a1);
check_arg_type("cdr-set!", "first", v1, 7LL);
v2 = cdr(a1);
v3 = car(v2);
v4 = car(a1);
cdr_set(v4, v3);
return make_symbol("ok");
}

original_code:
cellpoint cdr_set_proc(cellpoint arglst)
{
 check_arglst_len_eq("cdr-set!", 2, arglst);
 check_arg_type("cdr-set!", "first", car(arglst), 7);
 cdr_set(car(arglst), car(cdr(arglst)));
 return make_symbol("ok");
}

canonical_original_code:
unsigned int cdr_set_proc(unsigned int arglst)
{
 check_arglst_len_eq("cdr-set!", 2, arglst);
 check_arg_type("cdr-set!", "first", car(arglst), 7);
 cdr_set(car(arglst), car(cdr(arglst)));
 return make_symbol("ok");
}


decompiled_code:
__int64 char_eq()
{
unsigned int v0; // eax
char v1; // bl
unsigned int v2; // eax
bool v3; // zf
int v4; // eax

v0 = args_ref(1LL);
v1 = get_char(v0);
v2 = args_ref(2LL);
v3 = v1 == (char)get_char(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
char v1; // bl
unsigned int v2; // eax
bool v3; // zf
int v4; // eax

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

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

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


decompiled_code:
__int64 char_less()
{
unsigned int v0; // eax
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_char(v0);
v2 = args_ref(2LL);
v3 = v1 < (signed __int8)get_char(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
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

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

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

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


decompiled_code:
__int64 char_greater()
{
unsigned int v0; // eax
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_char(v0);
v2 = args_ref(2LL);
v3 = v1 <= (signed __int8)get_char(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
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

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

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

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


decompiled_code:
__int64 char_less_eq()
{
unsigned int v0; // eax
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_char(v0);
v2 = args_ref(2LL);
v3 = v1 <= (signed __int8)get_char(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
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

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

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

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


decompiled_code:
__int64 char_greater_eq()
{
unsigned int v0; // eax
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

v0 = args_ref(1LL);
v1 = get_char(v0);
v2 = args_ref(2LL);
v3 = v1 < (signed __int8)get_char(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
signed __int8 v1; // bl
unsigned int v2; // eax
bool v3; // cc
int v4; // eax

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

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

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


decompiled_code:
__int64 char_is_upcase()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)(get_char(v0) - 65) < 0x1Au;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func5()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)(get_char(v0) - 65) < 0x1Au;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_is_upcase(void)
{
 char ch = get_char(args_ref(1));
 if (ch >= 'A' && ch <= 'Z'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_is_upcase()
{
 char ch = get_char(args_ref(1));
 if (ch >= 'A' && ch <= 'Z'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

variable_types: ch char


decompiled_code:
__int64 char_is_lowercase()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)(get_char(v0) - 97) < 0x1Au;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func6()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)(get_char(v0) - 97) < 0x1Au;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_is_lowercase(void)
{
 char ch = get_char(args_ref(1));
 if (ch >= 'a' && ch <= 'z'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_is_lowercase()
{
 char ch = get_char(args_ref(1));
 if (ch >= 'a' && ch <= 'z'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 char_is_alphabetic()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)((get_char(v0) & 0xDF) - 65) < 0x1Au;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func7()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)((get_char(v0) & 0xDF) - 65) < 0x1Au;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_is_alphabetic(void)
{
 char c = get_char(args_ref(1));
 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_is_alphabetic()
{
 char c = get_char(args_ref(1));
 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

variable_types: c char


decompiled_code:
__int64 char_is_numeric()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)(get_char(v0) - 48) < 0xAu;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func8()
{
unsigned int v0; // eax
bool v1; // cf
int v2; // eax

v0 = args_ref(1LL);
v1 = (unsigned __int8)(get_char(v0) - 48) < 0xAu;
v2 = a_true;
if ( !v1 )
v2 = a_false;
reg = v2;
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_is_numeric(void)
{
 char c = get_char(args_ref(1));
 if (c >= '0' && c <= '9'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_is_numeric()
{
 char c = get_char(args_ref(1));
 if (c >= '0' && c <= '9'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 char_is_whitespace()
{
unsigned int v0; // eax
unsigned __int64 v1; // rax
__int64 v2; // rdx
int v3; // eax

v0 = args_ref(1LL);
v1 = get_char(v0);
if ( (unsigned __int8)v1 <= 0x20u && (v2 = 0x100002600LL, _bittest64(&v2, v1)) )
v3 = a_true;
else
v3 = a_false;
reg = v3;
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = get_char(v0);
if ( (unsigned __int8)v1 <= 0x20u && (v2 = 0x100002600LL, _bittest64(&v2, v1)) )
v3 = a_true;
else
v3 = a_false;
reg = v3;
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_is_whitespace(void)
{
 char c = get_char(args_ref(1));
 if (c == ' ' || c == '\t' || c == '\n' || c == '\r'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_is_whitespace()
{
 char c = get_char(args_ref(1));
 if (c == ' ' || c == '\t' || c == '\n' || c == '\r'){
  reg = a_true;
 }else {
  reg = a_false;
 }
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 char_2_integer()
{
char v0; // al

reg = args_ref(1LL);
v0 = get_char(reg);
reg = make_integer((unsigned int)v0);
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func10()
{
char v0; // al

reg = args_ref(1LL);
v0 = get_char(reg);
reg = make_integer((unsigned int)v0);
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_2_integer(void)
{
 reg = args_ref(1);
 reg = make_integer((int)get_char(reg));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_2_integer()
{
 reg = args_ref(1);
 reg = make_integer((int)get_char(reg));
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 integer_2_char()
{
char v0; // al

reg = args_ref(1LL);
v0 = get_integer(reg);
reg = make_char((unsigned int)v0);
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func11()
{
char v0; // al

reg = args_ref(1LL);
v0 = get_integer(reg);
reg = make_char((unsigned int)v0);
args_pop(1LL);
return reg;
}

original_code:
cellpoint integer_2_char(void)
{
 reg = args_ref(1);
 reg = make_char((char)get_integer(reg));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int integer_2_char()
{
 reg = args_ref(1);
 reg = make_char((char)get_integer(reg));
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 char_upcase()
{
unsigned int v0; // eax
unsigned int v1; // eax
char v2; // al

v0 = args_ref(1LL);
args_push(v0);
reg = char_is_lowercase();
if ( (unsigned int)is_true(reg) )
{
v1 = args_ref(1LL);
v2 = get_char(v1);
reg = make_char((unsigned int)(char)(v2 - 32));
}
else
{
reg = args_ref(1LL);
}
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func12()
{
unsigned int v0; // eax
unsigned int v1; // eax
char v2; // al

v0 = args_ref(1LL);
args_push(v0);
reg = func6();
if ( (unsigned int)is_true(reg) )
{
v1 = args_ref(1LL);
v2 = get_char(v1);
reg = make_char((unsigned int)(char)(v2 - 32));
}
else
{
reg = args_ref(1LL);
}
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_upcase(void)
{
 args_push(args_ref(1));
 reg = char_is_lowercase();
 if (is_true(reg)){
  char c = get_char(args_ref(1));
  c = c - 'a' + 'A';
  reg = make_char(c);
 }else {
  reg = args_ref(1);
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_upcase()
{
 args_push(args_ref(1));
 reg = char_is_lowercase();
 if (is_true(reg)){
  char c = get_char(args_ref(1));
  c = c - 'a' + 'A';
  reg = make_char(c);
 }else {
  reg = args_ref(1);
 }
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 char_eq_ci()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = char_upcase();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = char_upcase();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = char_eq();
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func13()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = func12();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = func12();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = func0();
args_pop(2LL);
return reg;
}

original_code:
cellpoint char_eq_ci(void)
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_eq();
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int char_eq_ci()
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_eq();
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 char_less_ci()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = char_upcase();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = char_upcase();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = char_less();
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func14()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = func12();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = func12();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = func1();
args_pop(2LL);
return reg;
}

original_code:
cellpoint char_less_ci(void)
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_less();
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int char_less_ci()
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_less();
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 char_greater_ci()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = char_upcase();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = char_upcase();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = char_greater();
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func15()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = func12();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = func12();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = func2();
args_pop(2LL);
return reg;
}

original_code:
cellpoint char_greater_ci(void)
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_greater();
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int char_greater_ci()
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_greater();
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 char_less_eq_ci()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = char_upcase();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = char_upcase();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = char_less_eq();
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func16()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = func12();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = func12();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = func3();
args_pop(2LL);
return reg;
}

original_code:
cellpoint char_less_eq_ci(void)
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_less_eq();
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int char_less_eq_ci()
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_less_eq();
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 char_greater_eq_ci()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = char_upcase();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = char_upcase();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = char_greater_eq();
args_pop(2LL);
return reg;
}

canonical_decompiled_code:
__int64 func17()
{
unsigned int v0; // eax
unsigned int v1; // eax
__int64 v2; // rdi

v0 = args_ref(1LL);
args_push(v0);
reg = func12();
stack_push(&vars_stack, reg);
v1 = args_ref(2LL);
args_push(v1);
reg = func12();
args_push(reg);
v2 = (unsigned int)stack_pop(&vars_stack);
args_push(v2);
reg = func4();
args_pop(2LL);
return reg;
}

original_code:
cellpoint char_greater_eq_ci(void)
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_greater_eq();
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int char_greater_eq_ci()
{
 args_push(args_ref(1));
 reg = char_upcase();
 stack_push(&vars_stack, reg);
 args_push(args_ref(2));
 reg = char_upcase();
 args_push(reg);
 args_push(stack_pop(&vars_stack));
 reg = char_greater_eq();
 args_pop(2);
 return reg;
}


decompiled_code:
__int64 char_downcase()
{
__int64 v0; // rdi
unsigned int v1; // eax
char v2; // al

v0 = (unsigned int)args_ref(1LL);
args_push(v0);
reg = char_is_upcase();
if ( (unsigned int)is_true(reg) )
{
v1 = args_ref(1LL);
v2 = get_char(v1);
reg = make_char((unsigned int)(char)(v2 + 32));
}
else
{
reg = args_ref(1LL);
}
args_pop(1LL);
return reg;
}

canonical_decompiled_code:
__int64 func18()
{
__int64 v0; // rdi
unsigned int v1; // eax
char v2; // al

v0 = (unsigned int)args_ref(1LL);
args_push(v0);
reg = func5();
if ( (unsigned int)is_true(reg) )
{
v1 = args_ref(1LL);
v2 = get_char(v1);
reg = make_char((unsigned int)(char)(v2 + 32));
}
else
{
reg = args_ref(1LL);
}
args_pop(1LL);
return reg;
}

original_code:
cellpoint char_downcase(void)
{
 args_push(args_ref(1));
 reg = char_is_upcase();
 if (is_true(reg)){
  char c = get_char(args_ref(1));
  c = c - 'A' + 'a';
  reg = make_char(c);
 }else {
  reg = args_ref(1);
 }
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int char_downcase()
{
 args_push(args_ref(1));
 reg = char_is_upcase();
 if (is_true(reg)){
  char c = get_char(args_ref(1));
  c = c - 'A' + 'a';
  reg = make_char(c);
 }else {
  reg = args_ref(1);
 }
 args_pop(1);
 return reg;
}


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

check_arglst_len_eq("symbol?", 1LL, a1);
v1 = car(a1);
return is_symbol(v1);
}

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

check_arglst_len_eq("symbol?", 1LL, a1);
v1 = car(a1);
return is_symbol(v1);
}

original_code:
cellpoint symbol_pred_proc(cellpoint arglst)
{
    check_arglst_len_eq("symbol?", 1, arglst);
    return is_symbol(car(arglst));
}

canonical_original_code:
unsigned int symbol_pred_proc(unsigned int arglst)
{
    check_arglst_len_eq("symbol?", 1, arglst);
    return is_symbol(car(arglst));
}


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

check_arglst_len_eq("symbol->string", 1LL, a1);
v1 = car(a1);
check_arg_type("symbol->string", "first", v1, 4LL);
v2 = car(a1);
args_push(v2);
return symbol_2_string();
}

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

check_arglst_len_eq("symbol->string", 1LL, a1);
v1 = car(a1);
check_arg_type("symbol->string", "first", v1, 4LL);
v2 = car(a1);
args_push(v2);
return symbol_2_string();
}

original_code:
cellpoint symbol_2_string_proc(cellpoint arglst)
{
    check_arglst_len_eq("symbol->string",1,arglst);
 check_arg_type("symbol->string", "first", car(arglst), 4);
 args_push(car(arglst));
    return symbol_2_string();
}

canonical_original_code:
unsigned int symbol_2_string_proc(unsigned int arglst)
{
    check_arglst_len_eq("symbol->string",1,arglst);
 check_arg_type("symbol->string", "first", car(arglst), 4);
 args_push(car(arglst));
    return symbol_2_string();
}


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

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

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

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

original_code:
cellpoint string_2_symbol_proc(cellpoint arglst)
{
 check_arglst_len_eq("string->symbol", 1, arglst);
 check_arg_type("string->symbol", "first", car(arglst), 5);
 args_push(car(arglst));
 return string_2_symbol();
}

canonical_original_code:
unsigned int string_2_symbol_proc(unsigned int arglst)
{
 check_arglst_len_eq("string->symbol", 1, arglst);
 check_arg_type("string->symbol", "first", car(arglst), 5);
 args_push(car(arglst));
 return string_2_symbol();
}


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

check_arglst_len_eq("integer?", 1LL, a1);
v1 = car(a1);
return is_integer(v1);
}

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

check_arglst_len_eq("integer?", 1LL, a1);
v1 = car(a1);
return is_integer(v1);
}

original_code:
cellpoint integer_pred_proc(cellpoint arglst)
{
    check_arglst_len_eq("integer?", 1, arglst);
 return is_integer(car(arglst));
}

canonical_original_code:
unsigned int integer_pred_proc(unsigned int arglst)
{
    check_arglst_len_eq("integer?", 1, arglst);
 return is_integer(car(arglst));
}


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

check_arglst_len_eq("number?", 1LL, a1);
v1 = car(a1);
return is_number(v1);
}

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

check_arglst_len_eq("number?", 1LL, a1);
v1 = car(a1);
return is_number(v1);
}

original_code:
cellpoint number_pred_proc(cellpoint arglst)
{
    check_arglst_len_eq("number?", 1, arglst);
 return is_number(car(arglst));
}

canonical_original_code:
unsigned int number_pred_proc(unsigned int arglst)
{
    check_arglst_len_eq("number?", 1, arglst);
 return is_number(car(arglst));
}


decompiled_code:
__int64 __fastcall number_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
unsigned int v6; // eax

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

canonical_decompiled_code:
__int64 __fastcall func2(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

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

original_code:
cellpoint number_eq_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 number_eq();
}

canonical_original_code:
unsigned int number_eq_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 number_eq();
}


decompiled_code:
__int64 __fastcall number_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("<", 2LL, a1);
v1 = car(a1);
check_arg_type("<", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("<", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_less();
}

canonical_decompiled_code:
__int64 __fastcall func3(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("<", 2LL, a1);
v1 = car(a1);
check_arg_type("<", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("<", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_less();
}

original_code:
cellpoint number_less_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 number_less();
}

canonical_original_code:
unsigned int number_less_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 number_less();
}


decompiled_code:
__int64 __fastcall number_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(">", 2LL, a1);
v1 = car(a1);
check_arg_type(">", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(">", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_greater();
}

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
__int64 v6; // rdi

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

original_code:
cellpoint number_greater_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 number_greater();
}

canonical_original_code:
unsigned int number_greater_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 number_greater();
}


decompiled_code:
__int64 __fastcall number_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("<=", 2LL, a1);
v1 = car(a1);
check_arg_type("<=", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("<=", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_less_eq();
}

canonical_decompiled_code:
__int64 __fastcall func5(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("<=", 2LL, a1);
v1 = car(a1);
check_arg_type("<=", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("<=", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_less_eq();
}

original_code:
cellpoint number_less_eq_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 number_less_eq();
}

canonical_original_code:
unsigned int number_less_eq_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 number_less_eq();
}


decompiled_code:
__int64 __fastcall number_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(">=", 2LL, a1);
v1 = car(a1);
check_arg_type(">=", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(">=", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_greater_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(">=", 2LL, a1);
v1 = car(a1);
check_arg_type(">=", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(">=", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return number_greater_eq();
}

original_code:
cellpoint number_greater_eq_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 number_greater_eq();
}

canonical_original_code:
unsigned int number_greater_eq_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 number_greater_eq();
}


decompiled_code:
__int64 __fastcall add_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("+", 2LL, a1);
v1 = car(a1);
check_arg_type("+", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("+", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return add();
}

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("+", 2LL, a1);
v1 = car(a1);
check_arg_type("+", "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("+", "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return add();
}

original_code:
cellpoint add_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 add();
}

canonical_original_code:
unsigned int add_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 add();
}


decompiled_code:
__int64 __fastcall sub_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, 2LL, a1);
v1 = car(a1);
check_arg_type(asc_56C, "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(asc_56C, "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return sub();
}

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(asc_56C, 2LL, a1);
v1 = car(a1);
check_arg_type(asc_56C, "first", v1, 3LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type(asc_56C, "second", v3, 3LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = (unsigned int)car(a1);
args_push(v6);
return sub();
}

original_code:
cellpoint sub_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 sub();
}

canonical_original_code:
unsigned int sub_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 sub();
}