decompiled_code:
__int64 __fastcall relocate_procedure(__int64 a1)
{
int v1; // er12
int v2; // eax
unsigned int v3; // er12
unsigned int v4; // eax
int v5; // er13
unsigned int v6; // eax
int v7; // eax
int v8; // eax

v1 = cdr(a1);
v2 = car((unsigned int)a1);
v3 = cons_infree(v2, v1);
v4 = cdr((unsigned int)a1);
v5 = cdr(v4);
v6 = cdr((unsigned int)a1);
v7 = car(v6);
v8 = cons_infree(v7, v5);
cdr_set_infree(v3, v8);
car_set((unsigned int)a1, 0xFFFFFFFLL);
cdr_set((unsigned int)a1, v3);
return v3;
}

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

v1 = cdr(a1);
v2 = car((unsigned int)a1);
v3 = func0(v2, v1);
v4 = cdr((unsigned int)a1);
v5 = cdr(v4);
v6 = cdr((unsigned int)a1);
v7 = car(v6);
v8 = func0(v7, v5);
func4(v3, v8);
car_set((unsigned int)a1, 0xFFFFFFFLL);
cdr_set((unsigned int)a1, v3);
return v3;
}

original_code:
static cellpoint relocate_procedure(cellpoint old)
{
 cellpoint fp, p;
 fp = cons_infree(car(old), cdr(old));
 p = cons_infree(car(cdr(old)), cdr(cdr(old)));
 cdr_set_infree(fp, p);
 car_set(old, 0xFFFFFFF);
 cdr_set(old, fp);
 return fp;
}

canonical_original_code:
static unsigned int relocate_procedure(unsigned int old)
{
 unsigned int fp; unsigned int p;
 fp = cons_infree(car(old), cdr(old));
 p = cons_infree(car(cdr(old)), cdr(cdr(old)));
 cdr_set_infree(fp, p);
 car_set(old, 0xFFFFFFF);
 cdr_set(old, fp);
 return fp;
}

variable_types:
old
unsigned int

variable_types:
fp
unsigned int


decompiled_code:
__int64 __fastcall relocate_string(unsigned int a1)
{
int v1; // ebp
int v2; // er12
int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // er12
__int64 v6; // rsi
int v7; // er14
int v8; // eax
unsigned int v9; // er13
int v10; // eax
unsigned int v12; // [rsp+Ch] [rbp-3Ch]

v1 = string_len();
v2 = cdr(a1);
v3 = car(a1);
v12 = cons_infree(v3, v2);
if ( v1 > 0 )
{
v4 = 1;
v5 = ((v1 - 1) & 0xFFFFFFFE) + 3;
do
{
while ( 1 )
{
v9 = v4 - 1;
if ( v4 == v1 )
break;
v6 = v4;
v4 += 2;
v7 = string_ref(a1, v6);
v8 = string_ref(a1, v9);
cons_infree(v8, v7);
if ( v4 == v5 )
goto LABEL_6;
}
v4 += 2;
v10 = string_ref(a1, v9);
cons_infree(v10, 0);
}
while ( v4 != v5 );
}
LABEL_6:
car_set(a1, 0xFFFFFFFLL);
cdr_set(a1, v12);
return v12;
}

canonical_decompiled_code:
__int64 __fastcall func9(unsigned int a1)
{
int v1; // ebp
int v2; // er12
int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // er12
__int64 v6; // rsi
int v7; // er14
int v8; // eax
unsigned int v9; // er13
int v10; // eax
unsigned int v12; // [rsp+Ch] [rbp-3Ch]

v1 = string_len();
v2 = cdr(a1);
v3 = car(a1);
v12 = func0(v3, v2);
if ( v1 > 0 )
{
v4 = 1;
v5 = ((v1 - 1) & 0xFFFFFFFE) + 3;
do
{
while ( 1 )
{
v9 = v4 - 1;
if ( v4 == v1 )
break;
v6 = v4;
v4 += 2;
v7 = string_ref(a1, v6);
v8 = string_ref(a1, v9);
func0(v8, v7);
if ( v4 == v5 )
goto LABEL_6;
}
v4 += 2;
v10 = string_ref(a1, v9);
func0(v10, 0);
}
while ( v4 != v5 );
}
LABEL_6:
car_set(a1, 0xFFFFFFFLL);
cdr_set(a1, v12);
return v12;
}

original_code:
static cellpoint relocate_string(cellpoint old)
{
 int len = string_len(old);
 int i;
 cellpoint fp = cons_infree(car(old), cdr(old));
 for (i=0; i < len; i += 2){
  if (i+1 == len){
   cons_infree(string_ref(old,i), 0);
  }else {
   cons_infree(string_ref(old,i), string_ref(old, i+1));
  }
 }
 car_set(old, 0xFFFFFFF);
 cdr_set(old, fp);
 return fp;
}

canonical_original_code:
static unsigned int relocate_string(unsigned int old)
{
 int len = string_len(old);
 int i;
 unsigned int fp = cons_infree(car(old), cdr(old));
 for (i=0; i < len; i += 2){
  if (i+1 == len){
   cons_infree(string_ref(old,i), 0);
  }else {
   cons_infree(string_ref(old,i), string_ref(old, i+1));
  }
 }
 car_set(old, 0xFFFFFFF);
 cdr_set(old, fp);
 return fp;
}

variable_types: len int

variable_types: i int

return_type: unsigned int


decompiled_code:
__int64 __fastcall relocate_vector(unsigned int a1)
{
int v1; // ebp
int v2; // er12
int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // er12
__int64 v6; // rsi
int v7; // er14
int v8; // eax
unsigned int v9; // er13
int v10; // eax
unsigned int v12; // [rsp+Ch] [rbp-3Ch]

v1 = vector_len();
v2 = cdr(a1);
v3 = car(a1);
v12 = cons_infree(v3, v2);
if ( v1 > 0 )
{
v4 = 1;
v5 = ((v1 - 1) & 0xFFFFFFFE) + 3;
do
{
while ( 1 )
{
v9 = v4 - 1;
if ( v4 == v1 )
break;
v6 = v4;
v4 += 2;
v7 = vector_ref(a1, v6);
v8 = vector_ref(a1, v9);
cons_infree(v8, v7);
if ( v4 == v5 )
goto LABEL_6;
}
v4 += 2;
v10 = vector_ref(a1, v9);
cons_infree(v10, 0);
}
while ( v4 != v5 );
}
LABEL_6:
car_set(a1, 0xFFFFFFFLL);
cdr_set(a1, v12);
return v12;
}

canonical_decompiled_code:
__int64 __fastcall func10(unsigned int a1)
{
int v1; // ebp
int v2; // er12
int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // er12
__int64 v6; // rsi
int v7; // er14
int v8; // eax
unsigned int v9; // er13
int v10; // eax
unsigned int v12; // [rsp+Ch] [rbp-3Ch]

v1 = vector_len();
v2 = cdr(a1);
v3 = car(a1);
v12 = func0(v3, v2);
if ( v1 > 0 )
{
v4 = 1;
v5 = ((v1 - 1) & 0xFFFFFFFE) + 3;
do
{
while ( 1 )
{
v9 = v4 - 1;
if ( v4 == v1 )
break;
v6 = v4;
v4 += 2;
v7 = vector_ref(a1, v6);
v8 = vector_ref(a1, v9);
func0(v8, v7);
if ( v4 == v5 )
goto LABEL_6;
}
v4 += 2;
v10 = vector_ref(a1, v9);
func0(v10, 0);
}
while ( v4 != v5 );
}
LABEL_6:
car_set(a1, 0xFFFFFFFLL);
cdr_set(a1, v12);
return v12;
}

original_code:
static cellpoint relocate_vector(cellpoint old)
{
 int len = vector_len(old);
 int i;
 cellpoint fp = cons_infree(car(old), cdr(old));
 for (i=0; i < len; i += 2){
  if (i+1 == len){
   cons_infree(vector_ref(old,i), 0);
  }else {
   cons_infree(vector_ref(old,i), vector_ref(old, i+1));
  }
 }
 car_set(old, 0xFFFFFFF);
 cdr_set(old, fp);
 return fp;
}

canonical_original_code:
static unsigned int relocate_vector(unsigned int old)
{
 int len = vector_len(old);
 int i;
 unsigned int fp = cons_infree(car(old), cdr(old));
 for (i=0; i < len; i += 2){
  if (i+1 == len){
   cons_infree(vector_ref(old,i), 0);
  }else {
   cons_infree(vector_ref(old,i), vector_ref(old, i+1));
  }
 }
 car_set(old, 0xFFFFFFF);
 cdr_set(old, fp);
 return fp;
}


decompiled_code:
__int64 __fastcall relocate_cell(__int64 a1)
{
unsigned int v1; // eax
int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
int v8; // er12
int v9; // eax
unsigned int v10; // er12

v1 = is_null();
if ( (unsigned int)is_true(v1) )
return 0LL;
v3 = car((unsigned int)a1);
if ( is_broken_heart(v3) )
return cdr((unsigned int)a1);
v4 = is_pair((unsigned int)a1);
a1 = (unsigned int)a1;
if ( (unsigned int)is_true(v4) )
{
LABEL_10:
v8 = cdr(a1);
v9 = car((unsigned int)a1);
v10 = cons_infree(v9, v8);
car_set((unsigned int)a1, 0xFFFFFFFLL);
cdr_set((unsigned int)a1, v10);
return v10;
}
v5 = is_string((unsigned int)a1);
if ( (unsigned int)is_true(v5) )
return relocate_string(a1);
v6 = is_vector((unsigned int)a1);
if ( !(unsigned int)is_true(v6) )
{
v7 = is_procedure((unsigned int)a1);
a1 = (unsigned int)a1;
if ( (unsigned int)is_true(v7) )
return relocate_procedure((unsigned int)a1);
goto LABEL_10;
}
return relocate_vector(a1);
}

canonical_decompiled_code:
__int64 __fastcall func11(__int64 a1)
{
unsigned int v1; // eax
int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
int v8; // er12
int v9; // eax
unsigned int v10; // er12

v1 = is_null();
if ( (unsigned int)is_true(v1) )
return 0LL;
v3 = car((unsigned int)a1);
if ( func5(v3) )
return cdr((unsigned int)a1);
v4 = is_pair((unsigned int)a1);
a1 = (unsigned int)a1;
if ( (unsigned int)is_true(v4) )
{
LABEL_10:
v8 = cdr(a1);
v9 = car((unsigned int)a1);
v10 = func0(v9, v8);
car_set((unsigned int)a1, 0xFFFFFFFLL);
cdr_set((unsigned int)a1, v10);
return v10;
}
v5 = is_string((unsigned int)a1);
if ( (unsigned int)is_true(v5) )
return func9(a1);
v6 = is_vector((unsigned int)a1);
if ( !(unsigned int)is_true(v6) )
{
v7 = is_procedure((unsigned int)a1);
a1 = (unsigned int)a1;
if ( (unsigned int)is_true(v7) )
return func8((unsigned int)a1);
goto LABEL_10;
}
return func10(a1);
}

original_code:
static cellpoint relocate_cell(cellpoint old)
{
 if (is_true(is_null(old))){
  return 0;
 }
 if (is_broken_heart(car(old))){
  return cdr(old);
 }else {
  cellpoint fp = 0;
  if (is_true(is_pair(old))){
   fp = cons_infree(car(old), cdr(old));
   car_set(old, 0xFFFFFFF);
   cdr_set(old, fp);
   return fp;
  }else {
   if (is_true(is_string(old))){
    return relocate_string(old);
   }else if (is_true(is_vector(old))){
    return relocate_vector(old);
   }else if (is_true(is_procedure(old))){
    return relocate_procedure(old);
   }else {
    fp = cons_infree(car(old), cdr(old));
    car_set(old, 0xFFFFFFF);
    cdr_set(old, fp);
    return fp;
   }
  }
 }
}

canonical_original_code:
static unsigned int relocate_cell(unsigned int old)
{
 if (is_true(is_null(old))){
  return 0;
 }
 if (is_broken_heart(car(old))){
  return cdr(old);
 }else {
  unsigned int fp = 0;
  if (is_true(is_pair(old))){
   fp = cons_infree(car(old), cdr(old));
   car_set(old, 0xFFFFFFF);
   cdr_set(old, fp);
   return fp;
  }else {
   if (is_true(is_string(old))){
    return relocate_string(old);
   }else if (is_true(is_vector(old))){
    return relocate_vector(old);
   }else if (is_true(is_procedure(old))){
    return relocate_procedure(old);
   }else {
    fp = cons_infree(car(old), cdr(old));
    car_set(old, 0xFFFFFFF);
    cdr_set(old, fp);
    return fp;
   }
  }
 }
}


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

result = relocate_cell((unsigned int)root);
root = result;
return result;
}

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

result = func11((unsigned int)root);
root = result;
return result;
}

original_code:
static void reassign_root(void)
{
 root = relocate_cell(root);
}

canonical_original_code:
static void reassign_root()
{
 root = relocate_cell(root);
}

return_type: void


decompiled_code:
__int64 gc_flip()
{
__int64 v0; // rdx
unsigned int v1; // ebp
unsigned int v2; // ebp
unsigned int v3; // ebp
unsigned int v4; // ebp
unsigned int v5; // ebp
unsigned int v6; // ebp
unsigned int v7; // ebp
unsigned int v8; // ebp
unsigned int v9; // ebp
__int64 v10; // rbp
unsigned int v11; // eax
__int64 result; // rax

v0 = free_cons_cells;
free_cons_cells = the_cons_cells;
the_cons_cells = v0;
if ( !(unsigned int)memory_enough(1LL) )
{
puts("Error: run out of memory!");
exit(-1);
}
v1 = root;
the_global_env = car((unsigned int)root);
v2 = cdr(v1);
allocons = car(v2);
v3 = cdr(v2);
current_env = car(v3);
v4 = cdr(v3);
env_stack = car(v4);
v5 = cdr(v4);
args_stack = car(v5);
v6 = cdr(v5);
vars_stack = car(v6);
v7 = cdr(v6);
parser_stack = car(v7);
v8 = cdr(v7);
state_stack = car(v8);
v9 = cdr(v8);
current_state = car(v9);
v10 = (unsigned int)cdr(v9);
state_constants = car(v10);
set_state_constants();
LODWORD(v10) = cdr((unsigned int)v10);
obarray = car((unsigned int)v10);
LODWORD(v10) = cdr((unsigned int)v10);
reg = car((unsigned int)v10);
LODWORD(v10) = cdr((unsigned int)v10);
a_true = car((unsigned int)v10);
v11 = cdr((unsigned int)v10);
result = car(v11);
a_false = result;
return result;
}

canonical_decompiled_code:
__int64 func13()
{
__int64 v0; // rdx
unsigned int v1; // ebp
unsigned int v2; // ebp
unsigned int v3; // ebp
unsigned int v4; // ebp
unsigned int v5; // ebp
unsigned int v6; // ebp
unsigned int v7; // ebp
unsigned int v8; // ebp
unsigned int v9; // ebp
__int64 v10; // rbp
unsigned int v11; // eax
__int64 result; // rax

v0 = free_cons_cells;
free_cons_cells = the_cons_cells;
the_cons_cells = v0;
if ( !(unsigned int)memory_enough(1LL) )
{
puts("Error: run out of memory!");
exit(-1);
}
v1 = root;
the_global_env = car((unsigned int)root);
v2 = cdr(v1);
allocons = car(v2);
v3 = cdr(v2);
current_env = car(v3);
v4 = cdr(v3);
env_stack = car(v4);
v5 = cdr(v4);
args_stack = car(v5);
v6 = cdr(v5);
vars_stack = car(v6);
v7 = cdr(v6);
parser_stack = car(v7);
v8 = cdr(v7);
state_stack = car(v8);
v9 = cdr(v8);
current_state = car(v9);
v10 = (unsigned int)cdr(v9);
state_constants = car(v10);
set_state_constants();
LODWORD(v10) = cdr((unsigned int)v10);
obarray = car((unsigned int)v10);
LODWORD(v10) = cdr((unsigned int)v10);
reg = car((unsigned int)v10);
LODWORD(v10) = cdr((unsigned int)v10);
a_true = car((unsigned int)v10);
v11 = cdr((unsigned int)v10);
result = car(v11);
a_false = result;
return result;
}

original_code:
static void gc_flip(void)
{
 cellpoint r;
 struct cons_cell *tmp = the_cons_cells;
 the_cons_cells = free_cons_cells;
 free_cons_cells = tmp;
 if (!memory_enough(1)){
  printf("Error: run out of memory!\n");
  exit(-1);
 }
 r = root;
 the_global_env = car(r);
 r = cdr(r);
 allocons = car(r);
 r = cdr(r);
 current_env = car(r);
 r = cdr(r);
 env_stack = car(r);
 r = cdr(r);
 args_stack = car(r);
 r = cdr(r);
 vars_stack = car(r);
 r = cdr(r);
 parser_stack = car(r);
 r = cdr(r);
 state_stack = car(r);
 r = cdr(r);
 current_state = car(r);
 r = cdr(r);
 state_constants = car(r);
 set_state_constants();
 r = cdr(r);
 obarray = car(r);
 r = cdr(r);
 reg = car(r);
 r = cdr(r);
 a_true = car(r);
 r = cdr(r);
 a_false = car(r);
}

canonical_original_code:
static void gc_flip()
{
 unsigned int r;
 struct cons_cell *tmp = the_cons_cells;
 the_cons_cells = free_cons_cells;
 free_cons_cells = tmp;
 if (!memory_enough(1)){
  printf("Error: run out of memory!\n");
  exit(-1);
 }
 r = root;
 the_global_env = car(r);
 r = cdr(r);
 allocons = car(r);
 r = cdr(r);
 current_env = car(r);
 r = cdr(r);
 env_stack = car(r);
 r = cdr(r);
 args_stack = car(r);
 r = cdr(r);
 vars_stack = car(r);
 r = cdr(r);
 parser_stack = car(r);
 r = cdr(r);
 state_stack = car(r);
 r = cdr(r);
 current_state = car(r);
 r = cdr(r);
 state_constants = car(r);
 set_state_constants();
 r = cdr(r);
 obarray = car(r);
 r = cdr(r);
 reg = car(r);
 r = cdr(r);
 a_true = car(r);
 r = cdr(r);
 a_false = car(r);
}

variable_types:
r
unsigned int

variable_types: struct cons_cell { unsigned int car; unsigned int cdr; } *


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

root = cons(a_false, 0LL);
root = cons(a_true, (unsigned int)root);
root = cons(reg, (unsigned int)root);
root = cons(obarray, (unsigned int)root);
root = cons(state_constants, (unsigned int)root);
root = cons(current_state, (unsigned int)root);
root = cons(state_stack, (unsigned int)root);
root = cons(parser_stack, (unsigned int)root);
root = cons(vars_stack, (unsigned int)root);
root = cons(args_stack, (unsigned int)root);
root = cons(env_stack, (unsigned int)root);
root = cons(current_env, (unsigned int)root);
root = cons(allocons, (unsigned int)root);
result = cons(the_global_env, (unsigned int)root);
root = result;
return result;
}

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

root = cons(a_false, 0LL);
root = cons(a_true, (unsigned int)root);
root = cons(reg, (unsigned int)root);
root = cons(obarray, (unsigned int)root);
root = cons(state_constants, (unsigned int)root);
root = cons(current_state, (unsigned int)root);
root = cons(state_stack, (unsigned int)root);
root = cons(parser_stack, (unsigned int)root);
root = cons(vars_stack, (unsigned int)root);
root = cons(args_stack, (unsigned int)root);
root = cons(env_stack, (unsigned int)root);
root = cons(current_env, (unsigned int)root);
root = cons(allocons, (unsigned int)root);
result = cons(the_global_env, (unsigned int)root);
root = result;
return result;
}

original_code:
void gc_init(void)
{
 root = cons(a_false, 0);
 root = cons(a_true, root);
 root = cons(reg, root);
 root = cons(obarray, root);
 root = cons(state_constants, root);
 root = cons(current_state, root);
 root = cons(state_stack, root);
 root = cons(parser_stack, root);
 root = cons(vars_stack, root);
 root = cons(args_stack, root);
 root = cons(env_stack, root);
 root = cons(current_env, root);
 root = cons(allocons, root);
 root = cons(the_global_env, root);
}

canonical_original_code:
void gc_init()
{
 root = cons(a_false, 0);
 root = cons(a_true, root);
 root = cons(reg, root);
 root = cons(obarray, root);
 root = cons(state_constants, root);
 root = cons(current_state, root);
 root = cons(state_stack, root);
 root = cons(parser_stack, root);
 root = cons(vars_stack, root);
 root = cons(args_stack, root);
 root = cons(env_stack, root);
 root = cons(current_env, root);
 root = cons(allocons, root);
 root = cons(the_global_env, root);
}


decompiled_code:
int garbage_collection()
{
int v0; // eax
int v1; // eax
unsigned int v2; // er8
unsigned int v3; // eax
int v4; // eax
unsigned int v5; // eax
int v6; // eax
int v7; // edx

puts("gc starting.");
set_root();
free_point = 1;
reassign_root();
scan = root;
while ( !gc_finished() )
{
v0 = car_infree(scan);
if ( v0 < 0 )
{
if ( (v0 & 0x200) != 0 )
{
scan = v7 + 1;
v5 = car_infree(v7 + 1);
v6 = relocate_cell(v5);
car_set_infree(scan, v6);
}
}
else
{
v1 = relocate_cell((unsigned int)v0);
car_set_infree(scan, v1);
v3 = cdr_infree(v2);
v4 = relocate_cell(v3);
cdr_set_infree(scan, v4);
}
scan = v7 + 1;
}
gc_flip();
return puts("gc finished");
}

canonical_decompiled_code:
int func15()
{
int v0; // eax
int v1; // eax
unsigned int v2; // er8
unsigned int v3; // eax
int v4; // eax
unsigned int v5; // eax
int v6; // eax
int v7; // edx

puts("gc starting.");
func7();
free_point = 1;
func12();
scan = root;
while ( !func6() )
{
v0 = func1(scan);
if ( v0 < 0 )
{
if ( (v0 & 0x200) != 0 )
{
scan = v7 + 1;
v5 = func1(v7 + 1);
v6 = func11(v5);
func3(scan, v6);
}
}
else
{
v1 = func11((unsigned int)v0);
func3(scan, v1);
v3 = func2(v2);
v4 = func11(v3);
func4(scan, v4);
}
scan = v7 + 1;
}
func13();
return puts("gc finished");
}

original_code:
void garbage_collection(void)
{
 printf("gc starting.\n");
 set_root();
 free_point = 1;
 reassign_root();
 scan = root;
 while (!gc_finished()){
  if (car_infree(scan) & (1 << (sizeof(uint)*8-1))){
   if (car_infree(scan) & 0x0200){
    ++scan;
    car_set_infree(scan, relocate_cell(car_infree(scan)));
   }
  }else {
   cellpoint fp = 0;
   fp = relocate_cell(car_infree(scan));
   car_set_infree(scan, fp);
   fp = relocate_cell(cdr_infree(scan));
   cdr_set_infree(scan, fp);
  }
  ++scan;
 }
 gc_flip();
 printf("gc finished\n");
}

canonical_original_code:
void garbage_collection()
{
 printf("gc starting.\n");
 set_root();
 free_point = 1;
 reassign_root();
 scan = root;
 while (!gc_finished()){
  if (car_infree(scan) & (1 << (sizeof(uint)*8-1))){
   if (car_infree(scan) & 0x0200){
    ++scan;
    car_set_infree(scan, relocate_cell(car_infree(scan)));
   }
  }else {
   unsigned int fp = 0;
   fp = relocate_cell(car_infree(scan));
   car_set_infree(scan, fp);
   fp = relocate_cell(cdr_infree(scan));
   cdr_set_infree(scan, fp);
  }
  ++scan;
 }
 gc_flip();
 printf("gc finished\n");
}


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

check_arglst_len_eq("character?", 1LL, a1);
v1 = car(a1);
return is_char(v1);
}

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

check_arglst_len_eq("character?", 1LL, a1);
v1 = car(a1);
return is_char(v1);
}

original_code:
cellpoint char_pred_proc(cellpoint arglst)
{
    check_arglst_len_eq("character?", 1, arglst);
    return is_char(car(arglst));
}

canonical_original_code:
unsigned int char_pred_proc(unsigned int arglst)
{
    check_arglst_len_eq("character?", 1, arglst);
    return is_char(car(arglst));
}

variable_types:
arglst
unsigned int


decompiled_code:
__int64 __fastcall char_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("char=?", 2LL, a1);
v1 = car(a1);
check_arg_type("char=?", "first", v1, 1LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("char=?", "second", v3, 1LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = car(a1);
args_push(v6);
return char_eq();
}

canonical_decompiled_code:
__int64 __fastcall func1(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("char=?", 2LL, a1);
v1 = car(a1);
check_arg_type("char=?", "first", v1, 1LL);
v2 = cdr(a1);
v3 = car(v2);
check_arg_type("char=?", "second", v3, 1LL);
v4 = cdr(a1);
v5 = car(v4);
args_push(v5);
v6 = car(a1);
args_push(v6);
return char_eq();
}

original_code:
cellpoint char_eq_proc(cellpoint arglst)
{
    check_arglst_len_eq("char=?", 2, arglst);
 check_arg_type("char=?", "first", car(arglst), 1);
 check_arg_type("char=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
    return char_eq();
}

canonical_original_code:
unsigned int char_eq_proc(unsigned int arglst)
{
    check_arglst_len_eq("char=?", 2, arglst);
 check_arg_type("char=?", "first", car(arglst), 1);
 check_arg_type("char=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
    return char_eq();
}


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

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

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

original_code:
cellpoint char_less_proc(cellpoint arglst)
{
 check_arglst_len_eq("char<?", 2, arglst);
 check_arg_type("char<?", "first", car(arglst), 1);
 check_arg_type("char<?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less();
}

canonical_original_code:
unsigned int char_less_proc(unsigned int arglst)
{
 check_arglst_len_eq("char<?", 2, arglst);
 check_arg_type("char<?", "first", car(arglst), 1);
 check_arg_type("char<?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less();
}


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

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

original_code:
cellpoint char_greater_proc(cellpoint arglst)
{
 check_arglst_len_eq("char>?", 2, arglst);
 check_arg_type("char>?", "first", car(arglst), 1);
 check_arg_type("char>?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater();
}

canonical_original_code:
unsigned int char_greater_proc(unsigned int arglst)
{
 check_arglst_len_eq("char>?", 2, arglst);
 check_arg_type("char>?", "first", car(arglst), 1);
 check_arg_type("char>?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater();
}


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

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

original_code:
cellpoint char_less_eq_proc(cellpoint arglst)
{
 check_arglst_len_eq("char<=?", 2, arglst);
 check_arg_type("char<=?", "first", car(arglst), 1);
 check_arg_type("char<=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less_eq();
}

canonical_original_code:
unsigned int char_less_eq_proc(unsigned int arglst)
{
 check_arglst_len_eq("char<=?", 2, arglst);
 check_arg_type("char<=?", "first", car(arglst), 1);
 check_arg_type("char<=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less_eq();
}


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

original_code:
cellpoint char_greater_eq_proc(cellpoint arglst)
{
 check_arglst_len_eq("char>=?", 2, arglst);
 check_arg_type("char>=?", "first", car(arglst), 1);
 check_arg_type("char>=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater_eq();
}

canonical_original_code:
unsigned int char_greater_eq_proc(unsigned int arglst)
{
 check_arglst_len_eq("char>=?", 2, arglst);
 check_arg_type("char>=?", "first", car(arglst), 1);
 check_arg_type("char>=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater_eq();
}


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

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

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

original_code:
cellpoint char_eq_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-ci=?", 2, arglst);
 check_arg_type("char-ci=?", "first", car(arglst), 1);
 check_arg_type("char-ci=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_eq_ci();
}

canonical_original_code:
unsigned int char_eq_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-ci=?", 2, arglst);
 check_arg_type("char-ci=?", "first", car(arglst), 1);
 check_arg_type("char-ci=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_eq_ci();
}


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

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

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

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

original_code:
cellpoint char_less_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-ci<?", 2, arglst);
 check_arg_type("char-ci<?", "first", car(arglst), 1);
 check_arg_type("char-ci<?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less_ci();
}

canonical_original_code:
unsigned int char_less_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-ci<?", 2, arglst);
 check_arg_type("char-ci<?", "first", car(arglst), 1);
 check_arg_type("char-ci<?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less_ci();
}


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

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

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

original_code:
cellpoint char_greater_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-ci>?", 2, arglst);
 check_arg_type("char-ci>?", "first", car(arglst), 1);
 check_arg_type("char-ci>?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater_ci();
}

canonical_original_code:
unsigned int char_greater_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-ci>?", 2, arglst);
 check_arg_type("char-ci>?", "first", car(arglst), 1);
 check_arg_type("char-ci>?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater_ci();
}


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

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

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

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

original_code:
cellpoint char_less_eq_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-ci<=?", 2, arglst);
 check_arg_type("char-ci<=?", "first", car(arglst), 1);
 check_arg_type("char-ci<=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less_eq_ci();
}

canonical_original_code:
unsigned int char_less_eq_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-ci<=?", 2, arglst);
 check_arg_type("char-ci<=?", "first", car(arglst), 1);
 check_arg_type("char-ci<=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_less_eq_ci();
}


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

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

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

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

original_code:
cellpoint char_greater_eq_ci_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-ci>=?", 2, arglst);
 check_arg_type("char-ci>=?", "first", car(arglst), 1);
 check_arg_type("char-ci>=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater_eq_ci();
}

canonical_original_code:
unsigned int char_greater_eq_ci_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-ci>=?", 2, arglst);
 check_arg_type("char-ci>=?", "first", car(arglst), 1);
 check_arg_type("char-ci>=?", "second", car(cdr(arglst)), 1);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return char_greater_eq_ci();
}


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

check_arglst_len_eq("char-upper-case?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-upper-case?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_upcase();
}

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

check_arglst_len_eq("char-upper-case?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-upper-case?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_upcase();
}

original_code:
cellpoint char_upper_case_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-upper-case?", 1, arglst);
 check_arg_type("char-upper-case?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_upcase();
}

canonical_original_code:
unsigned int char_upper_case_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-upper-case?", 1, arglst);
 check_arg_type("char-upper-case?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_upcase();
}


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

check_arglst_len_eq("char-lower-case?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-lower-case?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_lowercase();
}

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

check_arglst_len_eq("char-lower-case?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-lower-case?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_lowercase();
}

original_code:
cellpoint char_lower_case_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-lower-case?", 1, arglst);
 check_arg_type("char-lower-case?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_lowercase();
}

canonical_original_code:
unsigned int char_lower_case_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-lower-case?", 1, arglst);
 check_arg_type("char-lower-case?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_lowercase();
}


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

check_arglst_len_eq("char-alphabetic?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-alphabetic?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_alphabetic();
}

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

check_arglst_len_eq("char-alphabetic?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-alphabetic?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_alphabetic();
}

original_code:
cellpoint char_alphabetic_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-alphabetic?", 1, arglst);
 check_arg_type("char-alphabetic?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_alphabetic();
}

canonical_original_code:
unsigned int char_alphabetic_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-alphabetic?", 1, arglst);
 check_arg_type("char-alphabetic?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_alphabetic();
}


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

check_arglst_len_eq("char-numeric?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-numeric?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_numeric();
}

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

check_arglst_len_eq("char-numeric?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-numeric?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_numeric();
}

original_code:
cellpoint char_numeric_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-numeric?", 1, arglst);
 check_arg_type("char-numeric?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_numeric();
}

canonical_original_code:
unsigned int char_numeric_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-numeric?", 1, arglst);
 check_arg_type("char-numeric?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_numeric();
}


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

check_arglst_len_eq("char-whitespace?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-whitespace?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_whitespace();
}

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

check_arglst_len_eq("char-whitespace?", 1LL, a1);
v1 = car(a1);
check_arg_type("char-whitespace?", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_is_whitespace();
}

original_code:
cellpoint char_whitespace_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-whitespace?", 1, arglst);
 check_arg_type("char-whitespace?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_whitespace();
}

canonical_original_code:
unsigned int char_whitespace_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-whitespace?", 1, arglst);
 check_arg_type("char-whitespace?", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_is_whitespace();
}


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

check_arglst_len_eq("char->integer", 1LL, a1);
v1 = car(a1);
check_arg_type("char->integer", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_2_integer();
}

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

check_arglst_len_eq("char->integer", 1LL, a1);
v1 = car(a1);
check_arg_type("char->integer", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_2_integer();
}

original_code:
cellpoint char_2_integer_proc(cellpoint arglst)
{
 check_arglst_len_eq("char->integer", 1, arglst);
 check_arg_type("char->integer", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_2_integer();
}

canonical_original_code:
unsigned int char_2_integer_proc(unsigned int arglst)
{
 check_arglst_len_eq("char->integer", 1, arglst);
 check_arg_type("char->integer", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_2_integer();
}


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

check_arglst_len_eq("integer->char", 1LL, a1);
v1 = car(a1);
check_arg_type("integer->char", "first", v1, 2LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return integer_2_char();
}

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

check_arglst_len_eq("integer->char", 1LL, a1);
v1 = car(a1);
check_arg_type("integer->char", "first", v1, 2LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return integer_2_char();
}

original_code:
cellpoint integer_2_char_proc(cellpoint arglst)
{
 check_arglst_len_eq("integer->char", 1, arglst);
 check_arg_type("integer->char", "first", car(arglst), 2);
 args_push(car(arglst));
 return integer_2_char();
}

canonical_original_code:
unsigned int integer_2_char_proc(unsigned int arglst)
{
 check_arglst_len_eq("integer->char", 1, arglst);
 check_arg_type("integer->char", "first", car(arglst), 2);
 args_push(car(arglst));
 return integer_2_char();
}


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

check_arglst_len_eq("char-upcase", 1LL, a1);
v1 = car(a1);
check_arg_type("char-upcase", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_upcase();
}

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

check_arglst_len_eq("char-upcase", 1LL, a1);
v1 = car(a1);
check_arg_type("char-upcase", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_upcase();
}

original_code:
cellpoint char_upcase_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-upcase", 1, arglst);
 check_arg_type("char-upcase", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_upcase();
}

canonical_original_code:
unsigned int char_upcase_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-upcase", 1, arglst);
 check_arg_type("char-upcase", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_upcase();
}


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

check_arglst_len_eq("char-downcase", 1LL, a1);
v1 = car(a1);
check_arg_type("char-downcase", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_downcase();
}

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

check_arglst_len_eq("char-downcase", 1LL, a1);
v1 = car(a1);
check_arg_type("char-downcase", "first", v1, 1LL);
v2 = (unsigned int)car(a1);
args_push(v2);
return char_downcase();
}

original_code:
cellpoint char_downcase_proc(cellpoint arglst)
{
 check_arglst_len_eq("char-downcase", 1, arglst);
 check_arg_type("char-downcase", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_downcase();
}

canonical_original_code:
unsigned int char_downcase_proc(unsigned int arglst)
{
 check_arglst_len_eq("char-downcase", 1, arglst);
 check_arg_type("char-downcase", "first", car(arglst), 1);
 args_push(car(arglst));
 return char_downcase();
}


decompiled_code:
int write_boolean()
{
int result; // eax

if ( (unsigned int)is_true() )
result = printf("#t");
else
result = printf("#f");
return result;
}

canonical_decompiled_code:
int func0()
{
int result; // eax

if ( (unsigned int)is_true() )
result = printf("#t");
else
result = printf("#f");
return result;
}

original_code:
static void write_boolean(cellpoint cp)
{
    if (is_true(cp)){
        printf("#t");
    }else{
        printf("#f");
    }
}

canonical_original_code:
static void write_boolean(unsigned int cp)
{
    if (is_true(cp)){
        printf("#t");
    }else{
        printf("#f");
    }
}

variable_types:
cp
unsigned int


decompiled_code:
int write_number()
{
unsigned int v0; // eax

v0 = get_integer();
return printf("%d", v0);
}

canonical_decompiled_code:
int func1()
{
unsigned int v0; // eax

v0 = get_integer();
return printf("%d", v0);
}

original_code:
static void write_number(cellpoint cp)
{
    printf("%d", get_integer(cp));
}

canonical_original_code:
static void write_number(unsigned int cp)
{
    printf("%d", get_integer(cp));
}


decompiled_code:
int write_character()
{
char v0; // al

v0 = get_char();
if ( v0 == 32 )
return printf("#\\space");
if ( v0 == 10 )
return printf("#\\newline");
return printf("#\\%c", (unsigned int)v0);
}

canonical_decompiled_code:
int func2()
{
char v0; // al

v0 = get_char();
if ( v0 == 32 )
return printf("#\\space");
if ( v0 == 10 )
return printf("#\\newline");
return printf("#\\%c", (unsigned int)v0);
}

original_code:
static void write_character(cellpoint cp)
{
    char ch = get_char(cp);
    if (ch == ' '){
        printf("#\\space");
    }else if (ch == '\n'){
        printf("#\\newline");
    }else {
        printf("#\\%c", ch);
    }
}

canonical_original_code:
static void write_character(unsigned int cp)
{
    char ch = get_char(cp);
    if (ch == ' '){
        printf("#\\space");
    }else if (ch == '\n'){
        printf("#\\newline");
    }else {
        printf("#\\%c", ch);
    }
}

variable_types: ch char


decompiled_code:
int display_character()
{
char v0; // al

v0 = get_char();
return putchar(v0);
}

canonical_decompiled_code:
int func3()
{
char v0; // al

v0 = get_char();
return putchar(v0);
}

original_code:
static void display_character(cellpoint cp)
{
    printf("%c", get_char(cp));
}

canonical_original_code:
static void display_character(unsigned int cp)
{
    printf("%c", get_char(cp));
}


decompiled_code:
int write_symbol()
{
const char *v0; // rax

v0 = (const char *)get_symbol();
return printf("%s", v0);
}

canonical_decompiled_code:
int func4()
{
const char *v0; // rax

v0 = (const char *)get_symbol();
return printf("%s", v0);
}

original_code:
static void write_symbol(cellpoint cp)
{
    printf("%s", get_symbol(cp));
}

canonical_original_code:
static void write_symbol(unsigned int cp)
{
    printf("%s", get_symbol(cp));
}


decompiled_code:
int __fastcall display_string(unsigned int a1)
{
int result; // eax
int v2; // ebp
unsigned int v3; // ebx
__int64 v4; // rsi
unsigned int v5; // eax
char v6; // al

result = string_len();
if ( result > 0 )
{
v2 = result;
v3 = 0;
do
{
v4 = v3++;
v5 = string_ref(a1, v4);
v6 = get_char(v5);
result = putchar(v6);
}
while ( v2 != v3 );
}
return result;
}

canonical_decompiled_code:
int __fastcall func5(unsigned int a1)
{
int result; // eax
int v2; // ebp
unsigned int v3; // ebx
__int64 v4; // rsi
unsigned int v5; // eax
char v6; // al

result = string_len();
if ( result > 0 )
{
v2 = result;
v3 = 0;
do
{
v4 = v3++;
v5 = string_ref(a1, v4);
v6 = get_char(v5);
result = putchar(v6);
}
while ( v2 != v3 );
}
return result;
}

original_code:
static void display_string(cellpoint cp)
{
    int i, len = string_len(cp);
    for (i=0; i < len; i++){
        printf("%c", get_char(string_ref(cp,i)));
    }
}

canonical_original_code:
static void display_string(unsigned int cp)
{
    int i; int len = string_len(cp);
    for (i=0; i < len; i++){
        printf("%c", get_char(string_ref(cp,i)));
    }
}


decompiled_code:
int __fastcall write_string(unsigned int a1)
{
int v1; // ebx
unsigned int v2; // er12
unsigned int v3; // eax
char v4; // al

v1 = string_len();
putchar(34);
if ( v1 > 0 )
{
v2 = 0;
while ( 1 )
{
v3 = string_ref(a1, v2);
v4 = get_char(v3);
if ( v4 == 92 || v4 == 34 )
break;
if ( v4 == 10 )
{
++v2;
printf("\\n");
if ( v1 == v2 )
return putchar(34);
}
else
{
putchar(v4);
LABEL_4:
if ( v1 == ++v2 )
return putchar(34);
}
}
printf("\\%c", (unsigned int)v4);
goto LABEL_4;
}
return putchar(34);
}

canonical_decompiled_code:
int __fastcall func6(unsigned int a1)
{
int v1; // ebx
unsigned int v2; // er12
unsigned int v3; // eax
char v4; // al

v1 = string_len();
putchar(34);
if ( v1 > 0 )
{
v2 = 0;
while ( 1 )
{
v3 = string_ref(a1, v2);
v4 = get_char(v3);
if ( v4 == 92 || v4 == 34 )
break;
if ( v4 == 10 )
{
++v2;
printf("\\n");
if ( v1 == v2 )
return putchar(34);
}
else
{
putchar(v4);
LABEL_4:
if ( v1 == ++v2 )
return putchar(34);
}
}
printf("\\%c", (unsigned int)v4);
goto LABEL_4;
}
return putchar(34);
}

original_code:
static void write_string(cellpoint cp)
{
    int i, len = string_len(cp);
    printf("\"");
    for (i=0; i < len; i++){
        char ch = get_char(string_ref(cp,i));
        if (ch == '\\' || ch == '"'){
            printf("\\%c", ch);
        } else if (ch == '\n'){
            printf("\\n");
        }else {
            printf("%c", ch);
        }
    }
    printf("\"");
}

canonical_original_code:
static void write_string(unsigned int cp)
{
    int i; int len = string_len(cp);
    printf("\"");
    for (i=0; i < len; i++){
        char ch = get_char(string_ref(cp,i));
        if (ch == '\\' || ch == '"'){
            printf("\\%c", ch);
        } else if (ch == '\n'){
            printf("\\n");
        }else {
            printf("%c", ch);
        }
    }
    printf("\"");
}


display

decompiled_code:
int __fastcall display(unsigned int 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();
if ( (unsigned int)is_true(v1) )
return printf("()");
v3 = is_boolean(a1);
if ( (unsigned int)is_true(v3) )
return write_boolean();
v4 = is_number(a1);
if ( (unsigned int)is_true(v4) )
return write_number();
v5 = is_char(a1);
if ( (unsigned int)is_true(v5) )
return display_character();
v6 = is_symbol(a1);
if ( (unsigned int)is_true(v6) )
return write_symbol();
v7 = is_string(a1);
if ( (unsigned int)is_true(v7) )
return display_string(a1);
v8 = is_vector(a1);
if ( (unsigned int)is_true(v8) )
return display_vector(a1);
v9 = is_procedure(a1);
if ( (unsigned int)is_true(v9) )
return display_procedure(a1);
v10 = is_pair(a1);
if ( (unsigned int)is_true(v10) )
return display_pair(a1);
puts("display error.");
return error_handler();
}

canonical_decompiled_code:
int __fastcall func7(unsigned int 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();
if ( (unsigned int)is_true(v1) )
return printf("()");
v3 = is_boolean(a1);
if ( (unsigned int)is_true(v3) )
return func0();
v4 = is_number(a1);
if ( (unsigned int)is_true(v4) )
return func1();
v5 = is_char(a1);
if ( (unsigned int)is_true(v5) )
return func3();
v6 = is_symbol(a1);
if ( (unsigned int)is_true(v6) )
return func4();
v7 = is_string(a1);
if ( (unsigned int)is_true(v7) )
return func5(a1);
v8 = is_vector(a1);
if ( (unsigned int)is_true(v8) )
return func8(a1);
v9 = is_procedure(a1);
if ( (unsigned int)is_true(v9) )
return func9(a1);
v10 = is_pair(a1);
if ( (unsigned int)is_true(v10) )
return func10(a1);
puts("display error.");
return error_handler();
}

original_code:
void display(cellpoint cp)
{
    if (is_true(is_null(cp))){
        printf("()");
    } else if (is_true(is_boolean(cp))){
        display_boolean(cp);
    } else if (is_true(is_number(cp))){
        display_number(cp);
    } else if (is_true(is_char(cp))){
        display_character(cp);
    } else if (is_true(is_symbol(cp))){
        display_symbol(cp);
    } else if (is_true(is_string(cp))){
        display_string(cp);
    } else if (is_true(is_vector(cp))){
        display_vector(cp);
    } else if (is_true(is_procedure(cp))){
  display_procedure(cp);
 }else if (is_true(is_pair(cp))){
        display_pair(cp);
    } else {
        printf("display error.\n");
  error_handler();
    }
}

canonical_original_code:
void display(unsigned int cp)
{
    if (is_true(is_null(cp))){
        printf("()");
    } else if (is_true(is_boolean(cp))){
        display_boolean(cp);
    } else if (is_true(is_number(cp))){
        display_number(cp);
    } else if (is_true(is_char(cp))){
        display_character(cp);
    } else if (is_true(is_symbol(cp))){
        display_symbol(cp);
    } else if (is_true(is_string(cp))){
        display_string(cp);
    } else if (is_true(is_vector(cp))){
        display_vector(cp);
    } else if (is_true(is_procedure(cp))){
  display_procedure(cp);
 }else if (is_true(is_pair(cp))){
        display_pair(cp);
    } else {
        printf("display error.\n");
  error_handler();
    }
}


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

v1 = vector_len();
printf("#(");
if ( v1 > 0 )
{
v2 = 0;
do
{
v3 = v2++;
v4 = vector_ref(a1, v3);
display(v4);
putchar(32);
}
while ( v1 != v2 );
}
return putchar(41);
}

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

v1 = vector_len();
printf("#(");
if ( v1 > 0 )
{
v2 = 0;
do
{
v3 = v2++;
v4 = vector_ref(a1, v3);
func7(v4);
putchar(32);
}
while ( v1 != v2 );
}
return putchar(41);
}

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

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

variable_types: vlen int


decompiled_code:
int __fastcall display_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) )
display(reg);
return putchar(62);
}

canonical_decompiled_code:
int __fastcall func9(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) )
func7(reg);
return putchar(62);
}

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

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

variable_types:
proc
unsigned int


decompiled_code:
int __fastcall display_pair(int a1)
{
__int64 v1; // rbp
int i; // edi
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

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

canonical_decompiled_code:
int __fastcall func10(int a1)
{
__int64 v1; // rbp
int i; // edi
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

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

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

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


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 func11(__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 func0();
v4 = is_number((unsigned int)a1);
if ( (unsigned int)is_true(v4) )
return func1();
v5 = is_char((unsigned int)a1);
if ( (unsigned int)is_true(v5) )
return func2();
v6 = is_symbol((unsigned int)a1);
if ( (unsigned int)is_true(v6) )
return func4();
v7 = is_string((unsigned int)a1);
if ( (unsigned int)is_true(v7) )
return func6(a1);
v8 = is_vector((unsigned int)a1);
if ( (unsigned int)is_true(v8) )
return func12((unsigned int)a1);
v9 = is_procedure((unsigned int)a1);
if ( (unsigned int)is_true(v9) )
return func13((unsigned int)a1);
v10 = is_pair((unsigned int)a1);
if ( (unsigned int)is_true(v10) )
return func14((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 v2; // ebx
__int64 v3; // rsi
unsigned int v4; // eax

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

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

v1 = vector_len();
printf("#(");
if ( v1 > 0 )
{
v2 = 0;
do
{
v3 = v2++;
v4 = vector_ref(a1, v3);
func11(v4);
putchar(32);
}
while ( v1 != v2 );
}
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(")");
}


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 func13(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) )
func11(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(">");
}


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

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

canonical_decompiled_code:
int __fastcall func14(int a1)
{
__int64 v1; // rbp
int i; // edi
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

LODWORD(v1) = a1;
for ( i = 40; ; i = 32 )
{
putchar(i);
v3 = car((unsigned int)v1);
func11(v3);
v1 = (unsigned int)cdr((unsigned int)v1);
v4 = is_pair(v1);
if ( !(unsigned int)is_true(v4) )
break;
}
v5 = is_null((unsigned int)v1);
if ( (unsigned int)is_false(v5) )
{
printf(" . ");
func11((unsigned int)v1);
}
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 func15()
{
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));
}


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 v4; // ebx
unsigned int v5; // eax
unsigned int v6; // eax
__int64 v7; // rsi
unsigned int v8; // eax
unsigned int v9; // 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 )
{
v4 = 0;
do
{
reg = stack_pop(&vars_stack);
v5 = stack_top(&vars_stack);
v6 = car(v5);
v7 = v4++;
string_set(reg, v7, v6);
v8 = stack_pop(&vars_stack);
v9 = cdr(v8);
stack_push(&vars_stack, v9);
stack_push(&vars_stack, reg);
}
while ( v2 != v4 );
}
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 v4; // ebx
unsigned int v5; // eax
unsigned int v6; // eax
__int64 v7; // rsi
unsigned int v8; // eax
unsigned int v9; // 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 )
{
v4 = 0;
do
{
reg = stack_pop(&vars_stack);
v5 = stack_top(&vars_stack);
v6 = car(v5);
v7 = v4++;
string_set(reg, v7, v6);
v8 = stack_pop(&vars_stack);
v9 = cdr(v8);
stack_push(&vars_stack, v9);
stack_push(&vars_stack, reg);
}
while ( v2 != v4 );
}
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;
}


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_8;
if ( v1 != v3 )
{
LABEL_7:
args_pop(2LL);
return a_false;
}
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_7;
}
while ( v1 != ++v5 );
}
LABEL_8:
args_pop(2LL);
return a_true;
}

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_8;
if ( v1 != v3 )
{
LABEL_7:
args_pop(2LL);
return a_false;
}
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_7;
}
while ( v1 != ++v5 );
}
LABEL_8:
args_pop(2LL);
return a_true;
}

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_8;
v1 = args_ref(1LL);
v2 = string_len(v1);
v3 = args_ref(2LL);
if ( v2 != (unsigned int)string_len(v3) )
{
LABEL_7:
args_pop(2LL);
return a_false;
}
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_7;
}
while ( v2 != ++v4 );
}
LABEL_8:
args_pop(2LL);
return a_true;
}

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_8;
v1 = args_ref(1LL);
v2 = string_len(v1);
v3 = args_ref(2LL);
if ( v2 != (unsigned int)string_len(v3) )
{
LABEL_7:
args_pop(2LL);
return a_false;
}
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_7;
}
while ( v2 != ++v4 );
}
LABEL_8:
args_pop(2LL);
return a_true;
}

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; // ebp
int v4; // er12
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
__int64 result; // rax
int v13; // eax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v3 = v1;
if ( v3 <= 0 )
{
LABEL_9:
v13 = a_true;
if ( v1 >= v4 )
v13 = a_false;
reg = v13;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
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) )
{
args_pop(2LL);
return a_true;
}
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) )
break;
if ( v3 == ++v5 )
goto LABEL_9;
}
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; // ebp
int v4; // er12
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
__int64 result; // rax
int v13; // eax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v3 = v1;
if ( v3 <= 0 )
{
LABEL_9:
v13 = a_true;
if ( v1 >= v4 )
v13 = a_false;
reg = v13;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
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) )
{
args_pop(2LL);
return a_true;
}
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) )
break;
if ( v3 == ++v5 )
goto LABEL_9;
}
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; // ebp
int v4; // er12
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
__int64 result; // rax
int v13; // eax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v3 = v1;
if ( v3 <= 0 )
{
LABEL_9:
v13 = a_true;
if ( v1 >= v4 )
v13 = a_false;
reg = v13;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
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) )
{
args_pop(2LL);
return a_true;
}
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) )
break;
if ( v3 == ++v5 )
goto LABEL_9;
}
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; // ebp
int v4; // er12
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
__int64 result; // rax
int v13; // eax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v3 = v1;
if ( v3 <= 0 )
{
LABEL_9:
v13 = a_true;
if ( v1 >= v4 )
v13 = a_false;
reg = v13;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
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) )
{
args_pop(2LL);
return a_true;
}
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) )
break;
if ( v3 == ++v5 )
goto LABEL_9;
}
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; // ebp
int v4; // er12
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
__int64 result; // rax
int v13; // eax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v3 = v1;
if ( v3 <= 0 )
{
LABEL_9:
v13 = a_true;
if ( v1 <= v4 )
v13 = a_false;
reg = v13;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
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) )
{
args_pop(2LL);
return a_true;
}
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) )
break;
if ( v3 == ++v5 )
goto LABEL_9;
}
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; // ebp
int v4; // er12
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
__int64 result; // rax
int v13; // eax

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
v3 = string_len(v2);
v4 = v3;
if ( v1 <= v3 )
v3 = v1;
if ( v3 <= 0 )
{
LABEL_9:
v13 = a_true;
if ( v1 <= v4 )
v13 = a_false;
reg = v13;
args_pop(2LL);
result = reg;
}
else
{
v5 = 0;
while ( 1 )
{
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) )
{
args_pop(2LL);
return a_true;
}
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) )
break;
if ( v3 == ++v5 )
goto LABEL_9;
}
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;
}