decompiled_code:
__int64 __fastcall make_boolean(int a1)
{
__int64 result; // rax

result = (unsigned int)a_true;
if ( a1 != 1 )
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func14(int a1)
{
__int64 result; // rax

result = (unsigned int)a_true;
if ( a1 != 1 )
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint make_boolean(int b)
{
    if (b == 1){
        return a_true;
    }else {
        return a_false;
    }
}

canonical_original_code:
unsigned int make_boolean(int b)
{
    if (b == 1){
        return a_true;
    }else {
        return a_false;
    }
}

variable_types: b int


decompiled_code:
__int64 __fastcall is_boolean(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)is_atom(a1) && (atom_type(a1) & 0x10) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func15(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)func3(a1) && (func1(a1) & 0x10) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint is_boolean(cellpoint cp)
{
    if (is_atom(cp) && (atom_type(cp) & 0x0010)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_boolean(unsigned int cp)
{
    if (is_atom(cp) && (atom_type(cp) & 0x0010)){
  return a_true;
 }else {
  return a_false;
 }
}

variable_types:
cp
unsigned int

return_type: unsigned int


decompiled_code:
_BOOL8 __fastcall is_false(int a1)
{
return a_false == a1;
}

canonical_decompiled_code:
_BOOL8 __fastcall func16(int a1)
{
return a_false == a1;
}

original_code:
int is_false(cellpoint cp)
{
 return (cp == a_false) ? 1 : 0;
}

canonical_original_code:
int is_false(unsigned int cp)
{
 return (cp == a_false) ? 1 : 0;
}

return_type: int


decompiled_code:
__int64 __fastcall is_pair(unsigned int a1)
{
int v1; // eax
__int64 result; // rax

v1 = is_null(a1);
if ( !is_false(v1) || (unsigned int)is_atom(a1) )
result = (unsigned int)a_false;
else
result = (unsigned int)a_true;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func17(unsigned int a1)
{
int v1; // eax
__int64 result; // rax

v1 = func5(a1);
if ( !func16(v1) || (unsigned int)func3(a1) )
result = (unsigned int)a_false;
else
result = (unsigned int)a_true;
return result;
}

original_code:
cellpoint is_pair(cellpoint cp)
{
 if (is_false(is_null(cp)) && !is_atom(cp)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_pair(unsigned int cp)
{
 if (is_false(is_null(cp)) && !is_atom(cp)){
  return a_true;
 }else {
  return a_false;
 }
}


decompiled_code:
_BOOL8 __fastcall is_true(int a1)
{
return !is_false(a1);
}

canonical_decompiled_code:
_BOOL8 __fastcall func18(int a1)
{
return !func16(a1);
}

original_code:
int is_true(cellpoint cp)
{
    return is_false(cp) ? 0 : 1;
}

canonical_original_code:
int is_true(unsigned int cp)
{
    return is_false(cp) ? 0 : 1;
}


decompiled_code:
__int64 __fastcall get_symbol(unsigned int a1)
{
return (unsigned int)atom_obj(a1);
}

canonical_decompiled_code:
__int64 __fastcall func19(unsigned int a1)
{
return (unsigned int)func2(a1);
}

original_code:
char *get_symbol(cellpoint cp)
{
    return (char *)atom_obj(cp);
}

canonical_original_code:
char *get_symbol(unsigned int cp)
{
    return (char *)atom_obj(cp);
}

return_type: char *


decompiled_code:
__int64 __fastcall is_symbol(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)is_atom(a1) && (atom_type(a1) & 0x40) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func20(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)func3(a1) && (func1(a1) & 0x40) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint is_symbol(cellpoint cp)
{
    if (is_atom(cp) && (atom_type(cp) & 0x0040)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_symbol(unsigned int cp)
{
    if (is_atom(cp) && (atom_type(cp) & 0x0040)){
  return a_true;
 }else {
  return a_false;
 }
}


decompiled_code:
__int64 __fastcall make_string(int a1, unsigned int a2)
{
unsigned int v2; // ebp
unsigned int v3; // er14
int v4; // ebx

v2 = a2;
if ( !(unsigned int)memory_enough((unsigned int)(a1 / 2 + 1)) )
{
car_set(allocons, a2);
cdr_set(allocons, 0LL);
garbage_collection();
v2 = car(allocons);
}
v3 = make_atom(-2147483520, a1);
if ( a1 > 0 )
{
v4 = 1;
do
{
if ( a1 == v4 )
cons(v2, 0LL);
else
cons(v2, v2);
v4 += 2;
}
while ( v4 != ((a1 - 1) & 0xFFFFFFFE) + 3 );
}
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func21(int a1, unsigned int a2)
{
unsigned int v2; // ebp
unsigned int v3; // er14
int v4; // ebx

v2 = a2;
if ( !(unsigned int)memory_enough((unsigned int)(a1 / 2 + 1)) )
{
car_set(allocons, a2);
cdr_set(allocons, 0LL);
garbage_collection();
v2 = car(allocons);
}
v3 = func0(-2147483520, a1);
if ( a1 > 0 )
{
v4 = 1;
do
{
if ( a1 == v4 )
cons(v2, 0LL);
else
cons(v2, v2);
v4 += 2;
}
while ( v4 != ((a1 - 1) & 0xFFFFFFFE) + 3 );
}
return v3;
}

original_code:
cellpoint make_string(int k, cellpoint ch)
{
 if (!memory_enough(k/2 + 1)){
  car_set(allocons, ch);
  cdr_set(allocons, 0);
  garbage_collection();
  ch = car(allocons);
 }
    cellpoint cpstr = make_atom((1 << (sizeof(uint)*8-1))|0x0080, k);
 int i;
 for (i=0; i < k; i += 2){
  if (i+1 == k){
   cons(ch, 0);
  }else {
   cons(ch, ch);
  }
 }
    return cpstr;
}

canonical_original_code:
unsigned int make_string(int k, unsigned int ch)
{
 if (!memory_enough(k/2 + 1)){
  car_set(allocons, ch);
  cdr_set(allocons, 0);
  garbage_collection();
  ch = car(allocons);
 }
    unsigned int cpstr = make_atom((1 << (sizeof(uint)*8-1))|0x0080, k);
 int i;
 for (i=0; i < k; i += 2){
  if (i+1 == k){
   cons(ch, 0);
  }else {
   cons(ch, ch);
  }
 }
    return cpstr;
}

variable_types: k int

variable_types:
ch
unsigned int

variable_types:
cpstr
unsigned int

variable_types: i int


decompiled_code:
__int64 __fastcall is_string(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)is_atom(a1) && (atom_type(a1) & 0x80u) != 0LL )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func22(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)func3(a1) && (func1(a1) & 0x80u) != 0LL )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint is_string(cellpoint cp)
{
    if (is_atom(cp) && (atom_type(cp) & 0x0080)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_string(unsigned int cp)
{
    if (is_atom(cp) && (atom_type(cp) & 0x0080)){
  return a_true;
 }else {
  return a_false;
 }
}


decompiled_code:
__int64 string_len()
{
return cdr();
}

canonical_decompiled_code:
__int64 func23()
{
return cdr();
}

original_code:
int string_len(cellpoint str)
{
 return cdr(str);
}

canonical_original_code:
int string_len(unsigned int str)
{
 return cdr(str);
}

variable_types:
str
unsigned int


decompiled_code:
__int64 __fastcall string_ref(unsigned int a1, int a2)
{
unsigned int v2; // eax
__int64 v3; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)((__int64 (*)(void))string_len)() <= a2 )
{
v2 = string_len(a1);
printf("Error: the index %d out of the range. The length of string is %d. -- STRING-REF\n", (unsigned int)a2, v2);
error_handler();
}
v3 = a1 + a2 / 2 + 1;
if ( (a2 & 1) != 0 )
result = cdr(v3);
else
result = car(v3);
return result;
}

canonical_decompiled_code:
__int64 __fastcall func24(unsigned int a1, int a2)
{
unsigned int v2; // eax
__int64 v3; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)((__int64 (*)(void))string_len)() <= a2 )
{
v2 = func23(a1);
printf("Error: the index %d out of the range. The length of string is %d. -- STRING-REF\n", (unsigned int)a2, v2);
error_handler();
}
v3 = a1 + a2 / 2 + 1;
if ( (a2 & 1) != 0 )
result = cdr(v3);
else
result = car(v3);
return result;
}

original_code:
cellpoint string_ref(cellpoint str, int ind)
{
 if (ind < 0 || ind >= string_len(str)){
        printf("Error: the index %d out of the range. The length of string is %d. -- STRING-REF\n", ind, string_len(str));
  error_handler();
    }
 cellpoint s = str + ind / 2 + 1;
 if (ind % 2 == 0){
  return car(s);
 }else {
  return cdr(s);
 }
}

canonical_original_code:
unsigned int string_ref(unsigned int str, int ind)
{
 if (ind < 0 || ind >= string_len(str)){
        printf("Error: the index %d out of the range. The length of string is %d. -- STRING-REF\n", ind, string_len(str));
  error_handler();
    }
 unsigned int s = str + ind / 2 + 1;
 if (ind % 2 == 0){
  return car(s);
 }else {
  return cdr(s);
 }
}

variable_types: ind int

variable_types:
s
unsigned int


decompiled_code:
__int64 __fastcall string_set(__int64 a1, int a2, unsigned int a3)
{
unsigned int v4; // eax
__int64 v5; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)string_len(a1) <= a2 )
{
v4 = string_len((unsigned int)a1);
printf("Error: the index %d out of the range. The length of string is %d.-- STRING-SET\n", (unsigned int)a2, v4);
error_handler();
}
v5 = (unsigned int)(a1 + a2 / 2 + 1);
if ( (a2 & 1) != 0 )
result = cdr_set(v5, a3);
else
result = car_set(v5, a3);
return result;
}

canonical_decompiled_code:
__int64 __fastcall func25(__int64 a1, int a2, unsigned int a3)
{
unsigned int v4; // eax
__int64 v5; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)func23(a1) <= a2 )
{
v4 = func23((unsigned int)a1);
printf("Error: the index %d out of the range. The length of string is %d.-- STRING-SET\n", (unsigned int)a2, v4);
error_handler();
}
v5 = (unsigned int)(a1 + a2 / 2 + 1);
if ( (a2 & 1) != 0 )
result = cdr_set(v5, a3);
else
result = car_set(v5, a3);
return result;
}

original_code:
void string_set(cellpoint str, int ind, cellpoint ch)
{
    if (ind < 0 || ind >= string_len(str)){
        printf("Error: the index %d out of the range. The length of string is %d.-- STRING-SET\n", ind, string_len(str));
  error_handler();
    }
 cellpoint s = str + ind / 2 + 1;
 if (ind % 2 == 0){
  car_set(s, ch);
 }else {
  cdr_set(s, ch);
 }
}

canonical_original_code:
void string_set(unsigned int str, int ind, unsigned int ch)
{
    if (ind < 0 || ind >= string_len(str)){
        printf("Error: the index %d out of the range. The length of string is %d.-- STRING-SET\n", ind, string_len(str));
  error_handler();
    }
 unsigned int s = str + ind / 2 + 1;
 if (ind % 2 == 0){
  car_set(s, ch);
 }else {
  cdr_set(s, ch);
 }
}

return_type: void


decompiled_code:
__int64 __fastcall chars_2_string(const char *a1)
{
int v1; // ebx
unsigned int v2; // ebp
__int64 v3; // r13
__int64 v4; // rbx
unsigned int v5; // eax
__int64 v6; // rax

v1 = strlen(a1);
v2 = make_string(v1, 0);
if ( v1 > 0 )
{
v3 = (unsigned int)(v1 - 1);
v4 = 0LL;
do
{
v5 = make_char(a1[v4]);
string_set(v2, v4, v5);
v6 = v4++;
}
while ( v6 != v3 );
}
return v2;
}

canonical_decompiled_code:
__int64 __fastcall func26(const char *a1)
{
int v1; // ebx
unsigned int v2; // ebp
__int64 v3; // r13
__int64 v4; // rbx
unsigned int v5; // eax
__int64 v6; // rax

v1 = strlen(a1);
v2 = func21(v1, 0);
if ( v1 > 0 )
{
v3 = (unsigned int)(v1 - 1);
v4 = 0LL;
do
{
v5 = func6(a1[v4]);
func25(v2, v4, v5);
v6 = v4++;
}
while ( v6 != v3 );
}
return v2;
}

original_code:
cellpoint chars_2_string(char *str)
{
    int i,len = strlen(str);
    cellpoint cpstr = make_string(len, '\0');
 for (i=0; i < len; ++i){
  string_set(cpstr, i, make_char(*(str+i)));
 }
    return cpstr;
}

canonical_original_code:
unsigned int chars_2_string(char *str)
{
    int i; int len = strlen(str);
    unsigned int cpstr = make_string(len, '\0');
 for (i=0; i < len; ++i){
  string_set(cpstr, i, make_char(*(str+i)));
 }
    return cpstr;
}

variable_types:
str
char *

variable_types: len int


decompiled_code:
__int64 __fastcall make_vector(int a1, unsigned int a2)
{
unsigned int v2; // ebp
unsigned int v3; // er14
int v4; // ebx

v2 = a2;
if ( !(unsigned int)memory_enough((unsigned int)(a1 / 2 + 1)) )
{
car_set(allocons, a2);
cdr_set(allocons, 0LL);
garbage_collection();
v2 = car(allocons);
}
v3 = make_atom(-2147483392, a1);
if ( a1 > 0 )
{
v4 = 1;
do
{
if ( a1 == v4 )
cons(v2, 0LL);
else
cons(v2, v2);
v4 += 2;
}
while ( v4 != ((a1 - 1) & 0xFFFFFFFE) + 3 );
}
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func27(int a1, unsigned int a2)
{
unsigned int v2; // ebp
unsigned int v3; // er14
int v4; // ebx

v2 = a2;
if ( !(unsigned int)memory_enough((unsigned int)(a1 / 2 + 1)) )
{
car_set(allocons, a2);
cdr_set(allocons, 0LL);
garbage_collection();
v2 = car(allocons);
}
v3 = func0(-2147483392, a1);
if ( a1 > 0 )
{
v4 = 1;
do
{
if ( a1 == v4 )
cons(v2, 0LL);
else
cons(v2, v2);
v4 += 2;
}
while ( v4 != ((a1 - 1) & 0xFFFFFFFE) + 3 );
}
return v3;
}

original_code:
cellpoint make_vector(int num, cellpoint fill)
{
 if (!memory_enough(num/2 + 1)){
  car_set(allocons, fill);
  cdr_set(allocons, 0);
  garbage_collection();
  fill = car(allocons);
 }
    cellpoint cpv = make_atom((1 << (sizeof(uint)*8-1))|0x0100, num);
    int i;
    for (i=0; i < num; i = i+2){
        if (i+1 == num){
            cons(fill, 0);
        } else{
            cons(fill, fill);
        }
    }
    return cpv;
}

canonical_original_code:
unsigned int make_vector(int num, unsigned int fill)
{
 if (!memory_enough(num/2 + 1)){
  car_set(allocons, fill);
  cdr_set(allocons, 0);
  garbage_collection();
  fill = car(allocons);
 }
    unsigned int cpv = make_atom((1 << (sizeof(uint)*8-1))|0x0100, num);
    int i;
    for (i=0; i < num; i = i+2){
        if (i+1 == num){
            cons(fill, 0);
        } else{
            cons(fill, fill);
        }
    }
    return cpv;
}

variable_types: num int

variable_types:
fill
unsigned int

variable_types:
cpv
unsigned int


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

result = make_vector(89, 0);
obarray = result;
return result;
}

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

result = func27(89, 0);
obarray = result;
return result;
}

original_code:
void init_obarray(void)
{
 obarray = make_vector(89, 0);
}

canonical_original_code:
void init_obarray()
{
 obarray = make_vector(89, 0);
}


decompiled_code:
__int64 __fastcall is_vector(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)is_atom(a1) && (atom_type(a1) & 0x100) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func29(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)func3(a1) && (func1(a1) & 0x100) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint is_vector(cellpoint point)
{
    if (is_atom(point) && (atom_type(point) & 0x0100)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_vector(unsigned int point)
{
    if (is_atom(point) && (atom_type(point) & 0x0100)){
  return a_true;
 }else {
  return a_false;
 }
}

variable_types:
point
unsigned int


decompiled_code:
__int64 __fastcall vector_len(__int64 a1)
{
return cdr(a1);
}

canonical_decompiled_code:
__int64 __fastcall func30(__int64 a1)
{
return cdr(a1);
}

original_code:
int vector_len(cellpoint vec)
{
 return cdr(vec);
}

canonical_original_code:
int vector_len(unsigned int vec)
{
 return cdr(vec);
}

variable_types:
vec
unsigned int


decompiled_code:
__int64 __fastcall vector_ref(__int64 a1, int a2)
{
unsigned int v2; // eax
__int64 v3; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)vector_len(a1) <= a2 )
{
v2 = vector_len((unsigned int)a1);
printf("Error: the index %d out of the range. The length of vector is %d.\n", (unsigned int)a2, v2);
error_handler();
}
v3 = (unsigned int)(a1 + a2 / 2 + 1);
if ( (a2 & 1) != 0 )
result = cdr(v3);
else
result = car(v3);
return result;
}

canonical_decompiled_code:
__int64 __fastcall func31(__int64 a1, int a2)
{
unsigned int v2; // eax
__int64 v3; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)func30(a1) <= a2 )
{
v2 = func30((unsigned int)a1);
printf("Error: the index %d out of the range. The length of vector is %d.\n", (unsigned int)a2, v2);
error_handler();
}
v3 = (unsigned int)(a1 + a2 / 2 + 1);
if ( (a2 & 1) != 0 )
result = cdr(v3);
else
result = car(v3);
return result;
}

original_code:
cellpoint vector_ref(cellpoint vec, int ind)
{
    if (ind < 0 || ind >= vector_len(vec)){
        printf("Error: the index %d out of the range. The length of vector is %d.\n", ind, vector_len(vec));
  error_handler();
    }
    cellpoint v = vec + ind/2 + 1;
    if (ind % 2 == 0){
        return car(v);
    } else{
  return cdr(v);
    }
}

canonical_original_code:
unsigned int vector_ref(unsigned int vec, int ind)
{
    if (ind < 0 || ind >= vector_len(vec)){
        printf("Error: the index %d out of the range. The length of vector is %d.\n", ind, vector_len(vec));
  error_handler();
    }
    unsigned int v = vec + ind/2 + 1;
    if (ind % 2 == 0){
        return car(v);
    } else{
  return cdr(v);
    }
}

variable_types:
v
unsigned int


decompiled_code:
__int64 __fastcall lookup_symbol(char *s1)
{
int v1; // eax
unsigned int v2; // ebx
unsigned int v3; // ebp
const char *v4; // rax

v1 = compute_obarray_index(s1);
v2 = vector_ref((unsigned int)obarray, v1);
if ( !v2 )
return 0;
while ( 1 )
{
v3 = car(v2);
v4 = (const char *)get_symbol(v3);
if ( !strcmp(s1, v4) )
break;
v2 = cdr(v2);
if ( !v2 )
return 0;
}
return v3;
}

canonical_decompiled_code:
__int64 __fastcall func32(char *s1)
{
int v1; // eax
unsigned int v2; // ebx
unsigned int v3; // ebp
const char *v4; // rax

v1 = func4(s1);
v2 = func31((unsigned int)obarray, v1);
if ( !v2 )
return 0;
while ( 1 )
{
v3 = car(v2);
v4 = (const char *)func19(v3);
if ( !strcmp(s1, v4) )
break;
v2 = cdr(v2);
if ( !v2 )
return 0;
}
return v3;
}

original_code:
static cellpoint lookup_symbol(char *sym)
{
    int ind = compute_obarray_index(sym);
    cellpoint p = vector_ref(obarray, ind);
    while(p != 0){
  cellpoint s = car(p);
        if(strcmp(sym, get_symbol(s)) == 0){
            return s;
        }
        p = cdr(p);
    }
    return 0;
}

canonical_original_code:
static unsigned int lookup_symbol(char *sym)
{
    int ind = compute_obarray_index(sym);
    unsigned int p = vector_ref(obarray, ind);
    while(p != 0){
  unsigned int s = car(p);
        if(strcmp(sym, get_symbol(s)) == 0){
            return s;
        }
        p = cdr(p);
    }
    return 0;
}

variable_types:
sym
char *

variable_types:
p
unsigned int


decompiled_code:
__int64 __fastcall vector_set(__int64 a1, int a2, unsigned int a3)
{
unsigned int v4; // eax
__int64 v5; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)vector_len(a1) <= a2 )
{
v4 = vector_len((unsigned int)a1);
printf("Error: the index %d out of the range. The length of vector is %d.\n", (unsigned int)a2, v4);
error_handler();
}
v5 = (unsigned int)(a1 + a2 / 2 + 1);
if ( (a2 & 1) != 0 )
result = cdr_set(v5, a3);
else
result = car_set(v5, a3);
return result;
}

canonical_decompiled_code:
__int64 __fastcall func33(__int64 a1, int a2, unsigned int a3)
{
unsigned int v4; // eax
__int64 v5; // rdi
__int64 result; // rax

if ( a2 < 0 || (int)func30(a1) <= a2 )
{
v4 = func30((unsigned int)a1);
printf("Error: the index %d out of the range. The length of vector is %d.\n", (unsigned int)a2, v4);
error_handler();
}
v5 = (unsigned int)(a1 + a2 / 2 + 1);
if ( (a2 & 1) != 0 )
result = cdr_set(v5, a3);
else
result = car_set(v5, a3);
return result;
}

original_code:
void vector_set(cellpoint vec, int ind, cellpoint np)
{
    if (ind < 0 || ind >= vector_len(vec)){
        printf("Error: the index %d out of the range. The length of vector is %d.\n", ind, vector_len(vec));
  error_handler();
    }
    cellpoint v = vec + ind/2 + 1;
    if (ind % 2 == 0){
        car_set(v, np);
    } else{
        cdr_set(v, np);
    }
}

canonical_original_code:
void vector_set(unsigned int vec, int ind, unsigned int np)
{
    if (ind < 0 || ind >= vector_len(vec)){
        printf("Error: the index %d out of the range. The length of vector is %d.\n", ind, vector_len(vec));
  error_handler();
    }
    unsigned int v = vec + ind/2 + 1;
    if (ind % 2 == 0){
        car_set(v, np);
    } else{
        cdr_set(v, np);
    }
}

variable_types:
np
unsigned int


decompiled_code:
__int64 __fastcall interning_symbol(char *a1, unsigned int a2)
{
int v2; // ebx
unsigned int v3; // eax
unsigned int v4; // eax

v2 = compute_obarray_index(a1);
v3 = vector_ref((unsigned int)obarray, v2);
v4 = cons(a2, v3);
return vector_set((unsigned int)obarray, v2, v4);
}

canonical_decompiled_code:
__int64 __fastcall func34(char *a1, unsigned int a2)
{
int v2; // ebx
unsigned int v3; // eax
unsigned int v4; // eax

v2 = func4(a1);
v3 = func31((unsigned int)obarray, v2);
v4 = cons(a2, v3);
return func33((unsigned int)obarray, v2, v4);
}

original_code:
static void interning_symbol(char *sym, cellpoint cp)
{
    int ind = compute_obarray_index(sym);
 cellpoint p = vector_ref(obarray, ind);
 vector_set(obarray, ind, cons(cp, p));
}

canonical_original_code:
static void interning_symbol(char *sym, unsigned int cp)
{
    int ind = compute_obarray_index(sym);
 unsigned int p = vector_ref(obarray, ind);
 vector_set(obarray, ind, cons(cp, p));
}

variable_types:
cp
unsigned int


decompiled_code:
__int64 __fastcall make_symbol(char *src)
{
unsigned int v1; // ebx
size_t v3; // rax
char *v4; // r12

v1 = lookup_symbol(src);
if ( !v1 )
{
if ( !(unsigned int)memory_enough(1LL) )
garbage_collection();
v3 = strlen(src);
v4 = (char *)malloc(v3 + 1);
if ( !v4 )
{
perror("Error:malloc error. -- CREATE_SYMBOL\n");
error_handler();
}
strcpy(v4, src);
v1 = make_atom(-2147483584, (int)v4);
interning_symbol(v4, v1);
}
return v1;
}

canonical_decompiled_code:
__int64 __fastcall func35(char *src)
{
unsigned int v1; // ebx
size_t v3; // rax
char *v4; // r12

v1 = func32(src);
if ( !v1 )
{
if ( !(unsigned int)memory_enough(1LL) )
garbage_collection();
v3 = strlen(src);
v4 = (char *)malloc(v3 + 1);
if ( !v4 )
{
perror("Error:malloc error. -- CREATE_SYMBOL\n");
error_handler();
}
strcpy(v4, src);
v1 = func0(-2147483584, (int)v4);
func34(v4, v1);
}
return v1;
}

original_code:
cellpoint make_symbol(char *sym)
{
    cellpoint cp = lookup_symbol(sym);
    if (cp != 0){
        return cp;
    }
 if (!memory_enough(1)){
  garbage_collection();
 }
    char *new_sym = (char *)malloc(strlen(sym)+1);
    if(new_sym == ((void *)0)){
        perror("Error:malloc error. -- CREATE_SYMBOL\n");
  error_handler();
    }
    strcpy(new_sym, sym);
    cp = make_atom((1 << (sizeof(uint)*8-1))|0x0040, (uint)new_sym);
    interning_symbol(new_sym, cp);
    return cp;
}

canonical_original_code:
unsigned int make_symbol(char *sym)
{
    unsigned int cp = lookup_symbol(sym);
    if (cp != 0){
        return cp;
    }
 if (!memory_enough(1)){
  garbage_collection();
 }
    char *new_sym = (char *)malloc(strlen(sym)+1);
    if(new_sym == ((void *)0)){
        perror("Error:malloc error. -- CREATE_SYMBOL\n");
  error_handler();
    }
    strcpy(new_sym, sym);
    cp = make_atom((1 << (sizeof(uint)*8-1))|0x0040, (unsigned int)new_sym);
    interning_symbol(new_sym, cp);
    return cp;
}


decompiled_code:
__int64 __fastcall make_prim_proc(unsigned int a1, unsigned int a2)
{
unsigned int v2; // ebx
int v3; // eax

v2 = a1;
if ( !(unsigned int)memory_enough(1LL) )
{
car_set(allocons, a1);
cdr_set(allocons, 0LL);
garbage_collection();
v2 = car(allocons);
}
v3 = cons(v2, a2);
return make_atom(-2147483136, v3);
}

canonical_decompiled_code:
__int64 __fastcall func36(unsigned int a1, unsigned int a2)
{
unsigned int v2; // ebx
int v3; // eax

v2 = a1;
if ( !(unsigned int)memory_enough(1LL) )
{
car_set(allocons, a1);
cdr_set(allocons, 0LL);
garbage_collection();
v2 = car(allocons);
}
v3 = cons(v2, a2);
return func0(-2147483136, v3);
}

original_code:
cellpoint make_prim_proc(cellpoint pname, prim_proc_t pp)
{
 if (!memory_enough(1)){
  car_set(allocons, pname);
  cdr_set(allocons, 0);
  garbage_collection();
  pname = car(allocons);
 }
 return make_atom((1 << (sizeof(uint)*8-1))|0x0200, cons(pname, (uint)pp));
}

canonical_original_code:
unsigned int make_prim_proc(unsigned int pname, unsigned int (*pp)(unsigned int))
{
 if (!memory_enough(1)){
  car_set(allocons, pname);
  cdr_set(allocons, 0);
  garbage_collection();
  pname = car(allocons);
 }
 return make_atom((1 << (sizeof(uint)*8-1))|0x0200, cons(pname, (unsigned int)pp));
}

variable_types:
pname
unsigned int

variable_types:
pp
unsigned int (*)(unsigned int)


decompiled_code:
__int64 __fastcall is_prim_proc(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)is_atom(a1) && (atom_type(a1) & 0x200) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func37(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)func3(a1) && (func1(a1) & 0x200) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint is_prim_proc(cellpoint obj)
{
 if (is_atom(obj) && (atom_type(obj) & 0x0200)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_prim_proc(unsigned int obj)
{
 if (is_atom(obj) && (atom_type(obj) & 0x0200)){
  return a_true;
 }else {
  return a_false;
 }
}

variable_types:
obj
unsigned int


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

v1 = cdr(a1);
return (unsigned int)cdr(v1);
}

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

v1 = cdr(a1);
return (unsigned int)cdr(v1);
}

original_code:
prim_proc_t prim_proc_obj(cellpoint obj)
{
 return (prim_proc_t)cdr(cdr(obj));
}

canonical_original_code:
unsigned int (*prim_proc_obj(unsigned int obj))(unsigned int)
{
 return (unsigned int (*)(unsigned int))cdr(cdr(obj));
}

return_type: unsigned int (*)(unsigned int)


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

v0 = args_ref(3LL);
v1 = cons(v0, 0LL);
reg = v1;
v2 = args_ref(2LL);
v3 = cons(v2, v1);
reg = v3;
v4 = args_ref(1LL);
reg = cons(v4, v3);
reg = cons(0LL, reg);
if ( !(unsigned int)memory_enough(1LL) )
garbage_collection();
reg = make_atom(-2147467264, reg);
args_pop(3LL);
return reg;
}

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

v0 = args_ref(3LL);
v1 = cons(v0, 0LL);
reg = v1;
v2 = args_ref(2LL);
v3 = cons(v2, v1);
reg = v3;
v4 = args_ref(1LL);
reg = cons(v4, v3);
reg = cons(0LL, reg);
if ( !(unsigned int)memory_enough(1LL) )
garbage_collection();
reg = func0(-2147467264, reg);
args_pop(3LL);
return reg;
}

original_code:
cellpoint make_procedure(void)
{
 reg = cons(args_ref(3), 0);
 reg = cons(args_ref(2), reg);
 reg = cons(args_ref(1), reg);
 reg = cons(0, reg);
 if (!memory_enough(1)){
  garbage_collection();
 }
 reg = make_atom((1 << (sizeof(uint)*8-1))|0x04000, reg);
 args_pop(3);
 return reg;
}

canonical_original_code:
unsigned int make_procedure()
{
 reg = cons(args_ref(3), 0);
 reg = cons(args_ref(2), reg);
 reg = cons(args_ref(1), reg);
 reg = cons(0, reg);
 if (!memory_enough(1)){
  garbage_collection();
 }
 reg = make_atom((1 << (sizeof(uint)*8-1))|0x04000, reg);
 args_pop(3);
 return reg;
}


decompiled_code:
__int64 __fastcall is_compound_proc(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)is_atom(a1) && (atom_type(a1) & 0x4000) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func40(unsigned int a1)
{
__int64 result; // rax

if ( (unsigned int)func3(a1) && (func1(a1) & 0x4000) != 0 )
result = (unsigned int)a_true;
else
result = (unsigned int)a_false;
return result;
}

original_code:
cellpoint is_compound_proc(cellpoint obj)
{
 if (is_atom(obj) && (atom_type(obj) & 0x04000)){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_compound_proc(unsigned int obj)
{
 if (is_atom(obj) && (atom_type(obj) & 0x04000)){
  return a_true;
 }else {
  return a_false;
 }
}


decompiled_code:
__int64 __fastcall is_procedure(unsigned int a1)
{
unsigned int v1; // eax
__int64 result; // rax
unsigned int v3; // eax
int v4; // edx

v1 = is_prim_proc();
if ( (unsigned int)is_true(v1) || (v3 = is_compound_proc(a1), v4 = is_true(v3), result = a_false, v4) )
result = a_true;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1)
{
unsigned int v1; // eax
__int64 result; // rax
unsigned int v3; // eax
int v4; // edx

v1 = is_prim_proc();
if ( (unsigned int)is_true(v1) || (v3 = is_compound_proc(a1), v4 = is_true(v3), result = a_false, v4) )
result = a_true;
return result;
}

original_code:
cellpoint is_procedure(cellpoint obj)
{
 if (is_true(is_prim_proc(obj)) || is_true(is_compound_proc(obj))){
  return a_true;
 }else {
  return a_false;
 }
}

canonical_original_code:
unsigned int is_procedure(unsigned int obj)
{
 if (is_true(is_prim_proc(obj)) || is_true(is_compound_proc(obj))){
  return a_true;
 }else {
  return a_false;
 }
}


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

v0 = args_ref(1LL);
v1 = cdr(v0);
reg = car(v1);
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = cdr(v0);
reg = car(v1);
args_pop(1LL);
return reg;
}

original_code:
cellpoint procedure_name(void)
{
 reg = car(cdr(args_ref(1)));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int procedure_name()
{
 reg = car(cdr(args_ref(1)));
 args_pop(1);
 return reg;
}


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

v0 = args_ref(2LL);
v1 = args_ref(1LL);
v2 = cdr(v1);
car_set(v2, v0);
return args_pop(2LL);
}

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

v0 = args_ref(2LL);
v1 = args_ref(1LL);
v2 = cdr(v1);
car_set(v2, v0);
return args_pop(2LL);
}

original_code:
void procedure_name_set(void)
{
 car_set(cdr(args_ref(1)), args_ref(2));
 args_pop(2);
}

canonical_original_code:
void procedure_name_set()
{
 car_set(cdr(args_ref(1)), args_ref(2));
 args_pop(2);
}


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

v0 = args_ref(1LL);
v1 = prim_proc_obj(v0);
reg = v1;
v2 = args_ref(2LL);
reg = ((__int64 (__fastcall *)(_QWORD))v1)(v2);
args_pop(2LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = prim_proc_obj(v0);
reg = v1;
v2 = args_ref(2LL);
reg = ((__int64 (__fastcall *)(_QWORD))v1)(v2);
args_pop(2LL);
return reg;
}

original_code:
cellpoint apply_prim_proc(void)
{
 reg = (cellpoint)prim_proc_obj(args_ref(1));
 reg = (*(prim_proc_t)reg)(args_ref(2));
 args_pop(2);
 return reg;
}

canonical_original_code:
unsigned int apply_prim_proc()
{
 reg = (unsigned int)prim_proc_obj(args_ref(1));
 reg = (*(unsigned int (*)(unsigned int))reg)(args_ref(2));
 args_pop(2);
 return reg;
}


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

v0 = args_ref(1LL);
v1 = cdr(v0);
v2 = cdr(v1);
reg = car(v2);
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = cdr(v0);
v2 = cdr(v1);
reg = car(v2);
args_pop(1LL);
return reg;
}

original_code:
cellpoint procedure_parameters(void)
{
 reg = car(cdr(cdr(args_ref(1))));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int procedure_parameters()
{
 reg = car(cdr(cdr(args_ref(1))));
 args_pop(1);
 return reg;
}


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

v0 = args_ref(1LL);
v1 = cdr(v0);
v2 = cdr(v1);
v3 = cdr(v2);
reg = car(v3);
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = cdr(v0);
v2 = cdr(v1);
v3 = cdr(v2);
reg = car(v3);
args_pop(1LL);
return reg;
}

original_code:
cellpoint procedure_body(void)
{
 reg = car(cdr(cdr(cdr(args_ref(1)))));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int procedure_body()
{
 reg = car(cdr(cdr(cdr(args_ref(1)))));
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 procedure_env()
{
unsigned int v0; // eax
unsigned int v1; // eax
unsigned int v2; // eax
unsigned int v3; // eax
unsigned int v4; // eax

v0 = args_ref(1LL);
v1 = cdr(v0);
v2 = cdr(v1);
v3 = cdr(v2);
v4 = cdr(v3);
reg = car(v4);
args_pop(1LL);
return reg;
}

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

v0 = args_ref(1LL);
v1 = cdr(v0);
v2 = cdr(v1);
v3 = cdr(v2);
v4 = cdr(v3);
reg = car(v4);
args_pop(1LL);
return reg;
}

original_code:
cellpoint procedure_env(void)
{
 reg = car(cdr(cdr(cdr(cdr(args_ref(1))))));
 args_pop(1);
 return reg;
}

canonical_original_code:
unsigned int procedure_env()
{
 reg = car(cdr(cdr(cdr(cdr(args_ref(1))))));
 args_pop(1);
 return reg;
}


decompiled_code:
__int64 __fastcall cons_infree(int a1, int a2)
{
__int64 result; // rax

*(_DWORD *)(free_cons_cells + 8LL * free_point) = a1;
result = free_point;
*(_DWORD *)(free_cons_cells + 8LL * free_point + 4) = a2;
free_point = result + 1;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(int a1, int a2)
{
__int64 result; // rax

*(_DWORD *)(free_cons_cells + 8LL * free_point) = a1;
result = free_point;
*(_DWORD *)(free_cons_cells + 8LL * free_point + 4) = a2;
free_point = result + 1;
return result;
}

original_code:
static cellpoint cons_infree(cellpoint addr, cellpoint decre)
{
 free_cons_cells[free_point].car = addr;
 free_cons_cells[free_point].cdr = decre;
 return free_point++;
}

canonical_original_code:
static unsigned int cons_infree(unsigned int addr, unsigned int decre)
{
 free_cons_cells[free_point].car = addr;
 free_cons_cells[free_point].cdr = decre;
 return free_point++;
}

variable_types:
addr
unsigned int

variable_types:
decre
unsigned int


decompiled_code:
__int64 __fastcall car_infree(unsigned int a1)
{
return *(unsigned int *)(free_cons_cells + 8LL * a1);
}

canonical_decompiled_code:
__int64 __fastcall func1(unsigned int a1)
{
return *(unsigned int *)(free_cons_cells + 8LL * a1);
}

original_code:
static cellpoint car_infree(cellpoint p)
{
 return free_cons_cells[p].car;
}

canonical_original_code:
static unsigned int car_infree(unsigned int p)
{
 return free_cons_cells[p].car;
}


decompiled_code:
__int64 __fastcall cdr_infree(unsigned int a1)
{
return *(unsigned int *)(free_cons_cells + 8LL * a1 + 4);
}

canonical_decompiled_code:
__int64 __fastcall func2(unsigned int a1)
{
return *(unsigned int *)(free_cons_cells + 8LL * a1 + 4);
}

original_code:
static cellpoint cdr_infree(cellpoint p)
{
 return free_cons_cells[p].cdr;
}

canonical_original_code:
static unsigned int cdr_infree(unsigned int p)
{
 return free_cons_cells[p].cdr;
}


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

result = free_cons_cells;
*(_DWORD *)(free_cons_cells + 8LL * a1) = a2;
return result;
}

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

result = free_cons_cells;
*(_DWORD *)(free_cons_cells + 8LL * a1) = a2;
return result;
}

original_code:
static void car_set_infree(cellpoint p, cellpoint n)
{
 free_cons_cells[p].car = n;
}

canonical_original_code:
static void car_set_infree(unsigned int p, unsigned int n)
{
 free_cons_cells[p].car = n;
}

variable_types:
n
unsigned int


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

result = free_cons_cells;
*(_DWORD *)(free_cons_cells + 8LL * a1 + 4) = a2;
return result;
}

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

result = free_cons_cells;
*(_DWORD *)(free_cons_cells + 8LL * a1 + 4) = a2;
return result;
}

original_code:
static void cdr_set_infree(cellpoint p, cellpoint n)
{
 free_cons_cells[p].cdr = n;
}

canonical_original_code:
static void cdr_set_infree(unsigned int p, unsigned int n)
{
 free_cons_cells[p].cdr = n;
}


decompiled_code:
_BOOL8 __fastcall is_broken_heart(int a1)
{
return a1 == 0xFFFFFFF;
}

canonical_decompiled_code:
_BOOL8 __fastcall func5(int a1)
{
return a1 == 0xFFFFFFF;
}

original_code:
static int is_broken_heart(uint p)
{
 return (p == 0xFFFFFFF) ? 1 : 0;
}

canonical_original_code:
static int is_broken_heart(unsigned int p)
{
 return (p == 0xFFFFFFF) ? 1 : 0;
}


decompiled_code:
_BOOL8 gc_finished()
{
return (unsigned int)scan >= free_point;
}

canonical_decompiled_code:
_BOOL8 func6()
{
return (unsigned int)scan >= free_point;
}

original_code:
static int gc_finished(void)
{
 return (scan >= free_point) ? 1 : 0;
}

canonical_original_code:
static int gc_finished()
{
 return (scan >= free_point) ? 1 : 0;
}


decompiled_code:
__int64 set_root()
{
unsigned int v0; // ebx
unsigned int v1; // ebx
unsigned int v2; // ebx
unsigned int v3; // ebx
unsigned int v4; // ebx
unsigned int v5; // ebx
unsigned int v6; // ebx
unsigned int v7; // ebx
unsigned int v8; // ebx
unsigned int v9; // ebx
unsigned int v10; // ebx
unsigned int v11; // ebx
__int64 v12; // rbx
unsigned int v13; // eax

v0 = root;
car_set((unsigned int)root, the_global_env);
v1 = cdr(v0);
car_set(v1, allocons);
v2 = cdr(v1);
car_set(v2, current_env);
v3 = cdr(v2);
car_set(v3, env_stack);
v4 = cdr(v3);
car_set(v4, args_stack);
v5 = cdr(v4);
car_set(v5, vars_stack);
v6 = cdr(v5);
car_set(v6, parser_stack);
v7 = cdr(v6);
car_set(v7, state_stack);
v8 = cdr(v7);
car_set(v8, current_state);
v9 = cdr(v8);
car_set(v9, state_constants);
v10 = cdr(v9);
car_set(v10, obarray);
v11 = cdr(v10);
car_set(v11, reg);
v12 = (unsigned int)cdr(v11);
car_set(v12, a_true);
v13 = cdr((unsigned int)v12);
return car_set(v13, a_false);
}

canonical_decompiled_code:
__int64 func7()
{
unsigned int v0; // ebx
unsigned int v1; // ebx
unsigned int v2; // ebx
unsigned int v3; // ebx
unsigned int v4; // ebx
unsigned int v5; // ebx
unsigned int v6; // ebx
unsigned int v7; // ebx
unsigned int v8; // ebx
unsigned int v9; // ebx
unsigned int v10; // ebx
unsigned int v11; // ebx
__int64 v12; // rbx
unsigned int v13; // eax

v0 = root;
car_set((unsigned int)root, the_global_env);
v1 = cdr(v0);
car_set(v1, allocons);
v2 = cdr(v1);
car_set(v2, current_env);
v3 = cdr(v2);
car_set(v3, env_stack);
v4 = cdr(v3);
car_set(v4, args_stack);
v5 = cdr(v4);
car_set(v5, vars_stack);
v6 = cdr(v5);
car_set(v6, parser_stack);
v7 = cdr(v6);
car_set(v7, state_stack);
v8 = cdr(v7);
car_set(v8, current_state);
v9 = cdr(v8);
car_set(v9, state_constants);
v10 = cdr(v9);
car_set(v10, obarray);
v11 = cdr(v10);
car_set(v11, reg);
v12 = (unsigned int)cdr(v11);
car_set(v12, a_true);
v13 = cdr((unsigned int)v12);
return car_set(v13, a_false);
}

original_code:
static void set_root(void)
{
 cellpoint r = root;
 car_set(r, the_global_env);
 r = cdr(r);
 car_set(r, allocons);
 r = cdr(r);
 car_set(r, current_env);
 r = cdr(r);
 car_set(r, env_stack);
 r = cdr(r);
 car_set(r, args_stack);
 r = cdr(r);
 car_set(r, vars_stack);
 r = cdr(r);
 car_set(r, parser_stack);
 r = cdr(r);
 car_set(r, state_stack);
 r = cdr(r);
 car_set(r, current_state);
 r = cdr(r);
 car_set(r, state_constants);
 r = cdr(r);
 car_set(r, obarray);
 r = cdr(r);
 car_set(r, reg);
 r = cdr(r);
 car_set(r, a_true);
 r = cdr(r);
 car_set(r, a_false);
}

canonical_original_code:
static void set_root()
{
 unsigned int r = root;
 car_set(r, the_global_env);
 r = cdr(r);
 car_set(r, allocons);
 r = cdr(r);
 car_set(r, current_env);
 r = cdr(r);
 car_set(r, env_stack);
 r = cdr(r);
 car_set(r, args_stack);
 r = cdr(r);
 car_set(r, vars_stack);
 r = cdr(r);
 car_set(r, parser_stack);
 r = cdr(r);
 car_set(r, state_stack);
 r = cdr(r);
 car_set(r, current_state);
 r = cdr(r);
 car_set(r, state_constants);
 r = cdr(r);
 car_set(r, obarray);
 r = cdr(r);
 car_set(r, reg);
 r = cdr(r);
 car_set(r, a_true);
 r = cdr(r);
 car_set(r, a_false);
}

variable_types:
r
unsigned int


decompiled_code:
__int64 __fastcall relocate_procedure(__int64 a1)
{
int v1; // ebp
int v2; // eax
unsigned int v3; // ebp
unsigned int v4; // eax
int v5; // er12
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; // ebp
int v2; // eax
unsigned int v3; // ebp
unsigned int v4; // eax
int v5; // er12
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; // er14
int v2; // ebx
int v3; // eax
unsigned int v4; // ebx
int v5; // eax
unsigned int v6; // er13
int v7; // ebp
int v8; // eax
unsigned int v10; // [rsp+Ch] [rbp-3Ch]

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

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

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

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


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

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

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

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

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(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // ebp
int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
unsigned int v7; // eax
unsigned int v8; // eax
int v9; // ebp
int v10; // eax

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

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

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

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(root);
root = result;
return result;
}

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

result = func11(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);
}


decompiled_code:
__int64 gc_flip()
{
__int64 v0; // rax
unsigned int v1; // ebx
unsigned int v2; // ebx
unsigned int v3; // ebx
unsigned int v4; // ebx
unsigned int v5; // ebx
unsigned int v6; // ebx
unsigned int v7; // ebx
unsigned int v8; // ebx
unsigned int v9; // ebx
__int64 v10; // rdi
unsigned int v11; // ebx
unsigned int v12; // ebx
unsigned int v13; // ebx
unsigned int v14; // eax
__int64 result; // rax

v0 = the_cons_cells;
the_cons_cells = free_cons_cells;
free_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();
v11 = cdr((unsigned int)v10);
obarray = car(v11);
v12 = cdr(v11);
reg = car(v12);
v13 = cdr(v12);
a_true = car(v13);
v14 = cdr(v13);
result = car(v14);
a_false = result;
return result;
}

canonical_decompiled_code:
__int64 func13()
{
__int64 v0; // rax
unsigned int v1; // ebx
unsigned int v2; // ebx
unsigned int v3; // ebx
unsigned int v4; // ebx
unsigned int v5; // ebx
unsigned int v6; // ebx
unsigned int v7; // ebx
unsigned int v8; // ebx
unsigned int v9; // ebx
__int64 v10; // rdi
unsigned int v11; // ebx
unsigned int v12; // ebx
unsigned int v13; // ebx
unsigned int v14; // eax
__int64 result; // rax

v0 = the_cons_cells;
the_cons_cells = free_cons_cells;
free_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();
v11 = cdr((unsigned int)v10);
obarray = car(v11);
v12 = cdr(v11);
reg = car(v12);
v13 = cdr(v12);
a_true = car(v13);
v14 = cdr(v13);
result = car(v14);
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: 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
unsigned int v1; // ebx
unsigned int v2; // eax
int v3; // eax
int v4; // ebx
signed int v5; // eax
unsigned int v6; // eax
int v7; // eax

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

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

puts("gc starting.");
func7();
free_point = 1;
func12();
scan = root;
while ( !func6() )
{
v4 = scan;
v5 = func1(scan);
if ( v5 >= 0 )
{
v0 = func11(v5);
v1 = scan;
func3(scan, v0);
v2 = func2(v1);
v3 = func11(v2);
func4(scan, v3);
}
else if ( (v5 & 0x200) != 0 )
{
scan = v4 + 1;
v6 = func1(v4 + 1);
v7 = func11(v6);
func3(scan, v7);
}
++scan;
}
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 func1()
{
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");
    }
}


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

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

canonical_decompiled_code:
int func3()
{
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 func4()
{
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 func5()
{
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 func7()
{
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 i; // ebx
unsigned int v4; // eax
char v5; // al

result = string_len();
if ( result > 0 )
{
v2 = result;
for ( i = 0; i != v2; ++i )
{
v4 = string_ref(a1, i);
v5 = get_char(v4);
result = putchar(v5);
}
}
return result;
}

canonical_decompiled_code:
int __fastcall func8(unsigned int a1)
{
int result; // eax
int v2; // ebp
unsigned int i; // ebx
unsigned int v4; // eax
char v5; // al

result = string_len();
if ( result > 0 )
{
v2 = result;
for ( i = 0; i != v2; ++i )
{
v4 = string_ref(a1, i);
v5 = get_char(v4);
result = putchar(v5);
}
}
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; // ebp
unsigned int i; // ebx
unsigned int v3; // eax
char v4; // al

v1 = string_len();
putchar(34);
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = string_ref(a1, i);
v4 = get_char(v3);
if ( v4 == 92 || v4 == 34 )
{
printf("\\%c", (unsigned int)v4);
}
else if ( v4 == 10 )
{
printf("\\n");
}
else
{
putchar(v4);
}
}
}
return putchar(34);
}

canonical_decompiled_code:
int __fastcall func9(unsigned int a1)
{
int v1; // ebp
unsigned int i; // ebx
unsigned int v3; // eax
char v4; // al

v1 = string_len();
putchar(34);
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = string_ref(a1, i);
v4 = get_char(v3);
if ( v4 == 92 || v4 == 34 )
{
printf("\\%c", (unsigned int)v4);
}
else if ( v4 == 10 )
{
printf("\\n");
}
else
{
putchar(v4);
}
}
}
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 display_boolean();
v4 = is_number(a1);
if ( (unsigned int)is_true(v4) )
return display_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 display_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 func10(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 func2();
v5 = is_char(a1);
if ( (unsigned int)is_true(v5) )
return func5();
v6 = is_symbol(a1);
if ( (unsigned int)is_true(v6) )
return func6();
v7 = is_string(a1);
if ( (unsigned int)is_true(v7) )
return func8(a1);
v8 = is_vector(a1);
if ( (unsigned int)is_true(v8) )
return func11(a1);
v9 = is_procedure(a1);
if ( (unsigned int)is_true(v9) )
return func12(a1);
v10 = is_pair(a1);
if ( (unsigned int)is_true(v10) )
return func13(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 i; // ebx
unsigned int v3; // eax

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

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

v1 = vector_len();
printf("#(");
if ( v1 > 0 )
{
for ( i = 0; i != v1; ++i )
{
v3 = vector_ref(a1, i);
func10(v3);
putchar(32);
}
}
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 func12(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) )
func10(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(unsigned int a1)
{
unsigned int v1; // eax
unsigned int i; // ebx
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

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

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

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

variable_types:
cp
unsigned int