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

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

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

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

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

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


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

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

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

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

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

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

return_type: unsigned int


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


substring

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

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

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

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

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

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

variable_types: len int

variable_types: start int

variable_types: end int

variable_types: i int


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
reg = v2;
if ( v1 > 0 )
{
v3 = v2;
v4 = 0;
while ( 1 )
{
v5 = args_ref(1LL);
v6 = v4++;
string_set(v5, v6, v3);
if ( v1 == v4 )
break;
v3 = reg;
}
}
return args_pop(1LL);
}

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

v0 = args_ref(1LL);
v1 = string_len(v0);
v2 = args_ref(2LL);
reg = v2;
if ( v1 > 0 )
{
v3 = v2;
v4 = 0;
while ( 1 )
{
v5 = args_ref(1LL);
v6 = v4++;
string_set(v5, v6, v3);
if ( v1 == v4 )
break;
v3 = reg;
}
}
return args_pop(1LL);
}

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

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

return_type: void


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

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

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

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

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

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

variable_types:
arglst
unsigned int

variable_types:
arg
unsigned int


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

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

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

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

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

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

variable_types:
farg
unsigned int

variable_types:
sarg
unsigned int


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

variable_types: ch char


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

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

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

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

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

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


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

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

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

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

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

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

variable_types: c char


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

original_code:
cellpoint number_eq_proc(cellpoint arglst)
{
    check_arglst_len_eq("=", 2, arglst);
 check_arg_type("=", "first", car(arglst), 3);
 check_arg_type("=", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_eq();
}

canonical_original_code:
unsigned int number_eq_proc(unsigned int arglst)
{
    check_arglst_len_eq("=", 2, arglst);
 check_arg_type("=", "first", car(arglst), 3);
 check_arg_type("=", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_eq();
}


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

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

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

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

original_code:
cellpoint number_less_proc(cellpoint arglst)
{
 check_arglst_len_eq("<", 2, arglst);
 check_arg_type("<", "first", car(arglst), 3);
 check_arg_type("<", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_less();
}

canonical_original_code:
unsigned int number_less_proc(unsigned int arglst)
{
 check_arglst_len_eq("<", 2, arglst);
 check_arg_type("<", "first", car(arglst), 3);
 check_arg_type("<", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_less();
}


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

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

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

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

original_code:
cellpoint number_greater_proc(cellpoint arglst)
{
 check_arglst_len_eq(">", 2, arglst);
 check_arg_type(">", "first", car(arglst), 3);
 check_arg_type(">", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_greater();
}

canonical_original_code:
unsigned int number_greater_proc(unsigned int arglst)
{
 check_arglst_len_eq(">", 2, arglst);
 check_arg_type(">", "first", car(arglst), 3);
 check_arg_type(">", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_greater();
}


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

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

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

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

original_code:
cellpoint number_less_eq_proc(cellpoint arglst)
{
  check_arglst_len_eq("<=", 2, arglst);
 check_arg_type("<=", "first", car(arglst), 3);
 check_arg_type("<=", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_less_eq();
}

canonical_original_code:
unsigned int number_less_eq_proc(unsigned int arglst)
{
  check_arglst_len_eq("<=", 2, arglst);
 check_arg_type("<=", "first", car(arglst), 3);
 check_arg_type("<=", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_less_eq();
}


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

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

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

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

original_code:
cellpoint number_greater_eq_proc(cellpoint arglst)
{
 check_arglst_len_eq(">=", 2, arglst);
 check_arg_type(">=", "first", car(arglst), 3);
 check_arg_type(">=", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_greater_eq();
}

canonical_original_code:
unsigned int number_greater_eq_proc(unsigned int arglst)
{
 check_arglst_len_eq(">=", 2, arglst);
 check_arg_type(">=", "first", car(arglst), 3);
 check_arg_type(">=", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return number_greater_eq();
}


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

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

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

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

original_code:
cellpoint add_proc(cellpoint arglst)
{
 check_arglst_len_eq("+", 2, arglst);
 check_arg_type("+", "first", car(arglst), 3);
 check_arg_type("+", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return add();
}

canonical_original_code:
unsigned int add_proc(unsigned int arglst)
{
 check_arglst_len_eq("+", 2, arglst);
 check_arg_type("+", "first", car(arglst), 3);
 check_arg_type("+", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return add();
}


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

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

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

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

original_code:
cellpoint sub_proc(cellpoint arglst)
{
 check_arglst_len_eq("-", 2, arglst);
 check_arg_type("-", "first", car(arglst), 3);
 check_arg_type("-", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return sub();
}

canonical_original_code:
unsigned int sub_proc(unsigned int arglst)
{
 check_arglst_len_eq("-", 2, arglst);
 check_arg_type("-", "first", car(arglst), 3);
 check_arg_type("-", "second", car(cdr(arglst)), 3);
 args_push(car(cdr(arglst)));
 args_push(car(arglst));
 return sub();
}


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


decompiled_code:
__int64 __fastcall string_proc(__int64 a1, __int64 a2)
{
unsigned int v2; // ebp
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

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

canonical_decompiled_code:
__int64 __fastcall func2(__int64 a1, __int64 a2)
{
unsigned int v2; // ebp
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

variable_types:
targ
unsigned int


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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


decompiled_code:
__int64 __fastcall list_2_string_proc(unsigned int a1)
{
__int64 i; // rdi
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

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

canonical_decompiled_code:
__int64 __fastcall func19(unsigned int a1)
{
__int64 i; // rdi
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
__int64 v6; // rdi

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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