LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: store_string
static char *store_string(scheme * sc, int len, const char *str) {
  char *q;
  const char *end;
  int char_size = 1;
  int i;

  for (i = 0; i < len; i++) {
    if ((str[i] & 0x80) != 0) {
      char_size = 4;
      break;
    }
  }

  q = (char *) sc->malloc((len + 1) * char_size);
  if (q == 0) {
    sc->no_memory = 1;
    return sc->strbuff;
  }
  if (str != 0) {
    if (char_size == 1) {
      memcpy(q, str, len);
      q[len] = 0;
    } else {
      i = 1;
      end = str + len;
      while (str < end) {
        if (IS_ASCII(*str) || (*str & 0xE0) == 0xC0) {
          ((int*) q)[i++] = utf8_decode(str);
        }
        str++;
      }
      ((int*) q)[0] = UTFSTR_LEN_SET(i - 1);
    }
  }
  return (q);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r12
movslq %esi, %rbx
xorl %edx, %edx
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %esi, %ecx
pushq $0x1
popq %rax
pushq $0x4
popq %rdi
movq %rdx, %r13
cmpq %rdx, %rcx
je 0x47ae
leaq 0x1(%r13), %rdx
cmpb $0x0, (%r14,%r13)
jns 0x4799
movl %edi, %eax
incl %esi
imull %eax, %esi
movslq %esi, %rdi
callq *(%r12)
testq %rax, %rax
je 0x4800
movq %rax, %r15
testq %r14, %r14
je 0x483a
cmpq %rbx, %r13
jge 0x4813
addq %r14, %rbx
pushq $0x1
popq %rbp
cmpq %rbx, %r14
jae 0x4828
movb (%r14), %al
testb %al, %al
sets %cl
andb $-0x20, %al
cmpb $-0x40, %al
setne %al
testb %al, %cl
jne 0x47fb
movq %r14, %rdi
callq 0x61dc
movslq %ebp, %rcx
incl %ebp
movl %eax, (%r15,%rcx,4)
incq %r14
jmp 0x47d2
movb $0x1, 0xa99(%r12)
movq 0xea0(%r12), %r15
jmp 0x483a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x41d0
movb $0x0, (%r15,%rbx)
jmp 0x483a
shll $0x8, %ebp
addl $0x7fffff00, %ebp       # imm = 0x7FFFFF00
orl $0x80000080, %ebp       # imm = 0x80000080
movl %ebp, (%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_symbol
INTERFACE pointer mk_symbol(scheme * sc, const char *name) {
  pointer x;

  /* first check oblist */
  x = oblist_find_by_name(sc, name);
  if (x != sc->NIL) {
    return (x);
  } else {
    x = oblist_add_by_name(sc, name);
    return (x);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x487b
cmpq 0x90(%r14), %rax
je 0x486c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x48f9
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: oblist_find_by_name
static INLINE pointer oblist_find_by_name(scheme * sc, const char *name) {
  int location;
  pointer x;
  char *s;

  location = hash_fn(name, ivalue_unchecked(sc->oblist));
  for (x = vector_elem(sc->oblist, location); x != sc->NIL; x = cdr(x)) {
    s = symname(car(x));
    if (str_eq_to_lower(name, s)) {
      return car(x);
    }
  }
  return sc->NIL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf8(%rdi), %r15
movl 0x10(%r15), %esi
movq %rbx, %rdi
callq 0x621a
movl %eax, %ecx
pushq $0x2
popq %rsi
cltd
idivl %esi
cltq
imulq $0x18, %rax, %rax
addq %r15, %rax
andl $0x1, %ecx
leaq (%rax,%rcx,8), %r12
addq $0x20, %r12
movq 0x90(%r14), %r15
movq (%r12), %r12
cmpq %r15, %r12
je 0x48e7
movq 0x8(%r12), %r14
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x41a0
addq $0x10, %r12
testl %eax, %eax
jne 0x48bf
jmp 0x48ea
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: oblist_add_by_name
static pointer oblist_add_by_name(scheme * sc, const char *name) {
  pointer x;
  int location;

  x = immutable_cons(sc, mk_string(sc, name), sc->NIL);
  typeflag(x) = T_SYMBOL;
  setimmutable(car(x));

  location = hash_fn(name, ivalue_unchecked(sc->oblist));
  set_vector_elem(sc->oblist, location,
      immutable_cons(sc, x, vector_elem(sc->oblist, location)));
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x46f1
movq 0x90(%rbx), %rdx
pushq $0x1
popq %rbp
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %ecx
callq 0x45e8
movq %rax, %r14
movl $0x3, (%rax)
movq 0x8(%rax), %rax
orl $0x2000, (%rax)         # imm = 0x2000
movq 0xf8(%rbx), %r12
movl 0x10(%r12), %esi
movq %r15, %rdi
callq 0x621a
movl %eax, %r15d
pushq $0x2
popq %rcx
cltd
idivl %ecx
cltq
imulq $0x18, %rax, %r13
addq %r12, %r13
andl $0x1, %r15d
movq 0x20(%r13,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x45e8
movq %rax, 0x20(%r13,%r15,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: gensym
INTERFACE pointer gensym(scheme * sc) {
  pointer x;
  char name[40];

  for (; sc->gensym_cnt < LONG_MAX; sc->gensym_cnt++) {
    snprintf(name, 40, "gensym-%ld", sc->gensym_cnt);

    /* first check oblist */
    x = oblist_find_by_name(sc, name);

    if (x != sc->NIL) {
      continue;
    } else {
      x = oblist_add_by_name(sc, name);
      return (x);
    }
  }

  return sc->NIL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0xed8(%rdi), %rcx
movabsq $0x7fffffffffffffff, %r13 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x7ab4(%rip), %r14      # 0xc468
movq %rsp, %r15
pushq $0x28
popq %r12
cmpq %r13, %rcx
je 0x49f7
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x40e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x487b
cmpq 0x90(%rbx), %rax
je 0x4a00
movq 0xed8(%rbx), %rcx
incq %rcx
movq %rcx, 0xed8(%rbx)
jmp 0x49bb
movq 0x90(%rbx), %rax
jmp 0x4a0b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x48f9
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: putstr
INTERFACE void putstr(scheme * sc, const char *s) {
  port *pt = sc->outport->_object._port;
  if (pt->kind & port_file) {
    fputs(s, pt->rep.stdio.file);
  } else {
    for (; *s; s++) {
      if (pt->rep.string.curr != pt->rep.string.past_the_end) {
        *pt->rep.string.curr++ = *s;
      } else if (pt->kind & port_srfi6 && realloc_port_string(sc, pt)) {
        *pt->rep.string.curr++ = *s;
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x178(%rdi), %rax
movq 0x8(%rax), %r15
testb $0x1, (%r15)
jne 0x4a73
movq %rdi, %r14
movb (%rbx), %al
testb %al, %al
je 0x4a84
movq 0x18(%r15), %rcx
cmpq 0x10(%r15), %rcx
je 0x4a51
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r15)
movb %al, (%rcx)
jmp 0x4a6e
testb $0x4, (%r15)
je 0x4a6e
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a8a
testl %eax, %eax
je 0x4a6e
movb (%rbx), %al
movq 0x18(%r15), %rcx
jmp 0x4a45
incq %rbx
jmp 0x4a35
movq 0x8(%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: realloc_port_string
static int realloc_port_string(scheme * sc, port * p) {
  char *start = p->rep.string.start;
  size_t new_size = p->rep.string.past_the_end - start + 1 + BLOCK_SIZE;
  char *str = sc->malloc(new_size);
  if (str) {
    memset(str, ' ', new_size - 1);
    str[new_size - 1] = '\0';
    strcpy(str, start);
    p->rep.string.start = str;
    p->rep.string.past_the_end = str + new_size - 1;
    p->rep.string.curr -= start - str;
    sc->free(start);
    return 1;
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbp
subq %r14, %rbp
leaq 0x101(%rbp), %r12
movq %r12, %rdi
callq *(%rbx)
testq %rax, %rax
je 0x4b01
movq %rax, %r13
leaq 0x100(%rbp), %rdx
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x4120
movb $0x0, 0x100(%r13,%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x4050
movq %r13, 0x8(%r15)
leaq (%r12,%r13), %rax
decq %rax
movq %rax, 0x10(%r15)
subq %r14, %r13
addq %r13, 0x18(%r15)
movq %r14, %rdi
callq *0x8(%rbx)
pushq $0x1
popq %rax
jmp 0x4b03
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: putcharacter
INTERFACE void putcharacter(scheme * sc, int c) {
  port *pt = sc->outport->_object._port;
  if (pt->kind & port_file) {
    fputc(c, pt->rep.stdio.file);
  } else {
    if (pt->rep.string.curr != pt->rep.string.past_the_end) {
      *pt->rep.string.curr++ = c;
    } else if (pt->kind & port_srfi6 && realloc_port_string(sc, pt)) {
      *pt->rep.string.curr++ = c;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x178(%rdi), %rax
movq 0x8(%rax), %r14
movzbl (%r14), %eax
testb $0x1, %al
jne 0x4b41
movq 0x18(%r14), %rcx
cmpq 0x10(%r14), %rcx
je 0x4b53
leaq 0x1(%rcx), %rax
movq %rax, 0x18(%r14)
movb %bl, (%rcx)
jmp 0x4b71
movq 0x8(%r14), %rsi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4170
testb $0x4, %al
je 0x4b71
movq %r14, %rsi
callq 0x4a8a
testl %eax, %eax
je 0x4b71
movq 0x18(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%r14)
movb %bl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: long_to_str
void long_to_str(long v, char *s, int base) {
  char *p;
  char c;
  if (v < 0) {
    *s++ = '-';
    v = -v;
  }
  p = s;
  if (v == 0) {
    *s++ = '0';
  }
  while (v > 0) {
    c = (char) (v % base);
    v /= base;
    if (c < 10) {
      c += '0';
    } else {
      c += 'A' - 10;
    }
    *s++ = c;
  }
  *s-- = '\0';
  while (s > p) {
    c = *p;
    *p++ = *s;
    *s-- = c;
  }
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
js 0x4b8e
jne 0x4b97
leaq 0x1(%rsi), %rcx
movb $0x30, (%rsi)
xorl %eax, %eax
jmp 0x4b9a
movb $0x2d, (%rsi)
incq %rsi
negq %rax
movq %rsi, %rcx
movslq %edx, %rdi
decq %rcx
pushq $0x30
popq %r8
pushq $0x37
popq %r9
testq %rax, %rax
jle 0x4bc8
cqto
idivq %rdi
cmpb $0xa, %dl
movl %r9d, %r10d
cmovll %r8d, %r10d
addb %dl, %r10b
movb %r10b, 0x1(%rcx)
incq %rcx
jmp 0x4ba8
movb $0x0, 0x1(%rcx)
cmpq %rsi, %rcx
jbe 0x4be1
movb (%rsi), %al
movb (%rcx), %dl
movb %dl, (%rsi)
incq %rsi
movb %al, (%rcx)
decq %rcx
jmp 0x4bcc
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: eqv
int eqv(pointer a, pointer b) {
  if (is_string(a)) {
    if (is_string(b))
      return (strvalue(a) == strvalue(b));
    else
      return (0);
  } else if (is_number(a)) {
    if (is_number(b)) {
      if (num_is_integer(a) == num_is_integer(b))
        return num_eq(nvalue(a), nvalue(b));
    }
    return (0);
  } else if (is_character(a)) {
    if (is_character(b))
      return charvalue(a) == charvalue(b);
    else
      return (0);
  } else if (is_port(a)) {
    if (is_port(b))
      return a == b;
    else
      return (0);
  } else if (is_proc(a)) {
    if (is_proc(b))
      return procnum(a) == procnum(b);
    else
      return (0);
  } else {
    return (a == b);
  }
}

// Assembly:
movl (%rdi), %eax
andl $0x1f, %eax
decl %eax
cmpl $0x9, %eax
ja 0x4c77
leaq 0x740f(%rip), %rcx      # 0xc008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x1, %eax
jne 0x4c7e
movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq 0x8(%rsi), %rcx
jmp 0x4c9e
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x4, %eax
jne 0x4c7e
cmpb $0x0, 0x8(%rdi)
je 0x4c81
movq 0x10(%rdi), %rcx
jmp 0x4c87
movl (%rsi), %ecx
andl $0x1f, %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
jne 0x4ca1
movb 0x8(%rdi), %dl
cmpb 0x8(%rsi), %dl
jne 0x4ca1
movq 0x10(%rdi), %rax
movq 0x10(%rsi), %rcx
movzbl %dl, %edi
movq %rax, %rsi
movl %edi, %edx
jmp 0x4ca2
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x9, %eax
jne 0x4c7e
movq 0x10(%rdi), %rcx
xorl %eax, %eax
cmpq 0x10(%rsi), %rcx
jmp 0x4c9e
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0xa, %eax
jne 0x4c7e
xorl %eax, %eax
cmpq %rsi, %rdi
jmp 0x4c9e
xorl %eax, %eax
retq
cvttsd2si 0x10(%rdi), %rcx
cmpb $0x0, 0x8(%rsi)
je 0x4c93
movq 0x10(%rsi), %rdx
jmp 0x4c99
cvttsd2si 0x10(%rsi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: num_eq
static int num_eq(num a, num b) {
  int ret;
  int is_fixnum = a.is_fixnum && b.is_fixnum;
  if (is_fixnum) {
    ret = a.value.ivalue == b.value.ivalue;
  } else {
    ret = num_rvalue(a) == num_rvalue(b);
  }
  return ret;
}

// Assembly:
testb %dil, %dil
setne %al
testb %dl, %dl
setne %r8b
andb %al, %r8b
cmpb $0x1, %r8b
jne 0x4cbf
cmpq %rcx, %rsi
sete %al
jmp 0x4ced
testb %dil, %dil
je 0x4ccb
cvtsi2sd %rsi, %xmm0
jmp 0x4cd0
movq %rsi, %xmm0
testb %dl, %dl
je 0x4cdb
cvtsi2sd %rcx, %xmm1
jmp 0x4ce0
movq %rcx, %xmm1
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: list_length
int list_length(scheme * sc, pointer a) {
  int i = 0;
  pointer slow, fast;

  slow = fast = a;
  while (1) {
    if (fast == sc->NIL)
      return i;
    if (!is_pair(fast))
      return -2 - i;
    fast = cdr(fast);
    ++i;
    if (fast == sc->NIL)
      return i;
    if (!is_pair(fast))
      return -2 - i;
    ++i;
    fast = cdr(fast);

    /* Safe because we would have already returned if `fast'
       encountered a non-pair. */
    slow = cdr(slow);
    if (fast == slow) {
      /* the fast pointer has looped back around and caught up
         with the slow pointer, hence the structure is circular,
         not of finite length, and therefore not a list */
      return -1;
    }
  }
}

// Assembly:
movq 0x90(%rdi), %rcx
xorl %eax, %eax
pushq $-0x1
popq %rdx
movq %rsi, %rdi
cmpq %rcx, %rdi
je 0x4d3a
movl (%rdi), %r8d
andl $0x1f, %r8d
cmpl $0x5, %r8d
jne 0x4d3b
movq 0x10(%rdi), %rdi
cmpq %rcx, %rdi
je 0x4d3f
movl (%rdi), %r8d
andl $0x1f, %r8d
cmpl $0x5, %r8d
jne 0x4d42
addl $0x2, %eax
movq 0x10(%rdi), %rdi
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdi
jne 0x4d00
movl %edx, %eax
retq
pushq $-0x2
jmp 0x4d44
incl %eax
retq
pushq $-0x3
popq %rcx
subl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_init_new
scheme *scheme_init_new() {
  scheme *sc = (scheme *) malloc(sizeof(scheme));
  if (!scheme_init(sc)) {
    free(sc);
    return 0;
  } else {
    return sc;
  }
}

// Assembly:
pushq %rbx
movl $0xef8, %edi            # imm = 0xEF8
callq 0x4318
movq %rax, %rbx
movq %rax, %rdi
callq 0x4d73
testl %eax, %eax
jne 0x4d6e
movq %rbx, %rdi
callq 0x4310
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_init_new_custom_alloc
scheme *scheme_init_new_custom_alloc(func_alloc malloc, func_dealloc free) {
  scheme *sc = (scheme *) malloc(sizeof(scheme));
  if (!scheme_init_custom_alloc(sc, malloc, free)) {
    free(sc);
    return 0;
  } else {
    return sc;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xef8, %edi            # imm = 0xEF8
callq *%r15
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4dbf
testl %eax, %eax
jne 0x4db6
movq %rbx, %rdi
callq *%r14
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: alloc_cellseg
static int alloc_cellseg(scheme * sc, int n) {
  pointer newp;
  pointer last;
  pointer p;
  char *cp;
  long i;
  int k;
  int adj = ADJ;

  if (adj < sizeof(struct cell)) {
    adj = sizeof(struct cell);
  }
  for (k = 0; k < n; k++) {
    if (sc->last_cell_seg >= cell_nsegment - 1)
      return k;
    cp = (char *) sc->malloc(cell_segsize * sizeof(struct cell) + adj);
    if (cp == 0)
      return k;
    i = ++sc->last_cell_seg;
    sc->alloc_seg[i] = cp;
    /* adjust in TYPE_BITS-bit boundary */
    if (((unsigned long) cp) % adj != 0) {
      cp = (char *) (adj * ((unsigned long) cp / adj + 1));
    }
    /* insert new segment in address order */
    newp = (pointer) cp;
    sc->cell_seg[i] = newp;
    while (i > 0 && sc->cell_seg[i - 1] > sc->cell_seg[i]) {
      p = sc->cell_seg[i];
      sc->cell_seg[i] = sc->cell_seg[i - 1];
      sc->cell_seg[--i] = p;
    }
    sc->fcells += cell_segsize;
    last = newp + cell_segsize - 1;
    for (p = newp; p <= last; p++) {
      typeflag(p) = 0;
      cdr(p) = p + 1;
      car(p) = sc->NIL;
    }
    /* insert new cells in address order on free list */
    if (sc->free_cell == sc->NIL || p < sc->free_cell) {
      cdr(last) = sc->free_cell;
      sc->free_cell = newp;
    } else {
      p = sc->free_cell;
      while (cdr(p) != sc->NIL && newp > cdr(p))
        p = cdr(p);
      cdr(last) = cdr(p);
      cdr(p) = newp;
    }
  }
  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x160(%rdi), %r15
xorl %ebp, %ebp
testl %esi, %esi
movl $0x0, %r12d
cmovgl %esi, %r12d
cmpl %r12d, %ebp
je 0x5308
movl 0xcf9a(%rip), %eax      # 0x12198
decl %eax
cmpl %eax, 0x28(%r14)
jge 0x5306
movslq 0xcf8b(%rip), %rax      # 0x1219c
imulq $0x18, %rax, %rdi
addq $0x20, %rdi
callq *(%r14)
testq %rax, %rax
je 0x5306
movslq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdx
movl %edx, 0x28(%r14)
movq 0x18(%r14), %rcx
movq %rax, 0x8(%rcx,%rsi,8)
movq %rax, %rcx
andq $-0x20, %rcx
addq $0x20, %rcx
testb $0x1f, %al
cmoveq %rax, %rcx
movq 0x20(%r14), %rax
movq %rcx, 0x8(%rax,%rsi,8)
testq %rdx, %rdx
jle 0x527d
movq 0x20(%r14), %rax
movq -0x8(%rax,%rdx,8), %rdi
movq (%rax,%rdx,8), %rsi
cmpq %rsi, %rdi
jbe 0x527d
movq %rdi, (%rax,%rdx,8)
movq 0x20(%r14), %rax
movq %rsi, -0x8(%rax,%rdx,8)
decq %rdx
jmp 0x5254
movslq 0xcf18(%rip), %rax      # 0x1219c
addq %rax, 0x168(%r14)
imulq $0x18, %rax, %rdx
leaq (%rcx,%rdx), %rax
addq %rcx, %rdx
addq $-0x18, %rdx
movq %rcx, %rdi
cmpq %rdx, %rdi
ja 0x52bd
andl $0x0, (%rdi)
leaq 0x18(%rdi), %rsi
movq %rsi, 0x10(%rdi)
movq 0x90(%r14), %r8
movq %r8, 0x8(%rdi)
movq %rsi, %rdi
jmp 0x529d
movq 0x90(%r14), %rsi
movq 0x160(%r14), %rdx
cmpq %rsi, %rdx
sete %r8b
cmpq %rdx, %rdi
setb %dil
orb %r8b, %dil
je 0x52e3
movq %r15, %rdi
jmp 0x52f8
movq %rdx, %rdi
movq 0x10(%rdx), %rdx
cmpq %rsi, %rdx
je 0x52f4
cmpq %rdx, %rcx
ja 0x52e3
addq $0x10, %rdi
movq %rdx, -0x8(%rax)
movq %rcx, (%rdi)
incl %ebp
jmp 0x51ef
movl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: new_frame_in_env
static void new_frame_in_env(scheme * sc, pointer old_env) {
  pointer new_frame;

  /* The interaction-environment has about 300 variables in it. */
  if (old_env == sc->NIL) {
    new_frame = mk_vector(sc, 461);
  } else {
    new_frame = sc->NIL;
  }

  sc->envir = immutable_cons(sc, new_frame, old_env);
  setenvironment(sc->envir);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
cmpq %r14, %rsi
jne 0x5339
movq %rbx, %rdi
movl $0x1cd, %esi            # imm = 0x1CD
callq 0x6234
movq %rax, %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x45e8
movq %rax, 0x38(%rbx)
movl $0xe, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: port_from_file
static pointer port_from_file(scheme * sc, FILE * f, int prop) {
  port *pt;
  pt = port_rep_from_file(sc, f, prop);
  if (pt == 0) {
    return sc->NIL;
  }
  return mk_port(sc, pt);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq *(%rbx)
testq %rax, %rax
je 0x53bd
orb $0x1, %bpl
movb %bpl, (%rax)
movq %r14, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x588a
movq 0x90(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: port_from_string
static pointer port_from_string(scheme * sc, char *start, char *past_the_end,
    int prop) {
  port *pt;
  pt = port_rep_from_string(sc, start, past_the_end, prop);
  if (pt == 0) {
    return sc->NIL;
  }
  return mk_port(sc, pt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq *(%rbx)
testq %rax, %rax
je 0x5422
orb $0x2, %bpl
movb %bpl, (%rax)
movq %r15, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x588a
movq 0x90(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_deinit
void scheme_deinit(scheme * sc) {
  int i;

#if SHOW_ERROR_LINE
  char *fname;
#endif

  sc->oblist = sc->NIL;
  sc->global_env = sc->NIL;
  dump_stack_free(sc);
  sc->envir = sc->NIL;
  sc->code = sc->NIL;
  sc->args = sc->NIL;
  sc->value = sc->NIL;
  if (is_port(sc->inport)) {
    typeflag(sc->inport) = T_ATOM;
  }
  sc->inport = sc->NIL;
  sc->outport = sc->NIL;
  if (is_port(sc->save_inport)) {
    typeflag(sc->save_inport) = T_ATOM;
  }
  sc->save_inport = sc->NIL;
  if (is_port(sc->loadport)) {
    typeflag(sc->loadport) = T_ATOM;
  }
  sc->loadport = sc->NIL;
  sc->free(sc->strbuff);
  sc->gc_verbose = 0;
  gc(sc, sc->NIL, sc->NIL);

  for (i = 0; i <= sc->last_cell_seg; i++) {
    sc->free(sc->alloc_seg[i]);
  }
  sc->free(sc->cell_seg);
  sc->free(sc->alloc_seg);

#if SHOW_ERROR_LINE
  for (i = 0; i <= sc->file_i; i++) {
    if (sc->load_stack[i].kind & port_file) {
      fname = sc->load_stack[i].rep.stdio.filename;
      if (fname)
        sc->free(fname);
    }
  }
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x170(%rdi), %rcx
movq %rax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqu %xmm0, 0x40(%rdi)
movdqu %xmm0, 0x30(%rdi)
movq %rax, 0xec0(%rdi)
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x54b5
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x170(%rbx)
movq %rax, 0x178(%rbx)
movq 0x180(%rbx), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x54da
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x180(%rbx)
movq 0x188(%rbx), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x54f8
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x188(%rbx)
movq 0xea0(%rbx), %rdi
callq *0x8(%rbx)
movb $0x0, 0xa98(%rbx)
movq 0x90(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5585
xorl %r14d, %r14d
movslq 0x28(%rbx), %rcx
movq 0x8(%rbx), %rax
cmpq %rcx, %r14
jg 0x5541
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
incq %r14
jmp 0x5525
movq 0x20(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rdi
callq *0x8(%rbx)
leaq 0x1a8(%rbx), %r14
xorl %r15d, %r15d
movslq 0xa90(%rbx), %rax
cmpq %rax, %r15
jg 0x557f
testb $0x1, -0x18(%r14)
je 0x5576
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5576
callq *0x8(%rbx)
incq %r15
addq $0x20, %r14
jmp 0x5558
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_load_named_file
void scheme_load_named_file(scheme * sc, FILE * fin, const char *filename) {
  if (fin == NULL) {
    fprintf(stderr, "File pointer can not be NULL when loading a file\n");
    return;
  }
  dump_stack_reset(sc);
  sc->envir = sc->global_env;
  sc->file_i = 0;
  sc->load_stack[0].kind = port_input | port_file;
  sc->load_stack[0].rep.stdio.file = fin;
  sc->loadport = mk_port(sc, sc->load_stack);
  sc->retcode = 0;
  if (fin == stdin && !str_eq(filename, "--")) {
    sc->interactive_repl = 1;
  }
#if SHOW_ERROR_LINE
  sc->load_stack[0].rep.stdio.curr_line = 0;
  if (fin != stdin && filename)
    sc->load_stack[0].rep.stdio.filename =
        store_string(sc, strlen(filename), filename);
  else
    sc->load_stack[0].rep.stdio.filename = NULL;
#endif

  sc->args = mk_integer(sc, sc->file_i);
  Eval_Cycle(sc, OP_T0LVL);
  typeflag(sc->loadport) = T_ATOM;
  if (sc->retcode == 0) {
    sc->retcode = sc->nesting != 0;
  }
}

// Assembly:
testq %rsi, %rsi
je 0x586e
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x100(%rdi), %rcx
movq %rax, 0x48(%rdi)
movq %rcx, 0x38(%rdi)
andl $0x0, 0xa90(%rdi)
leaq 0x190(%rdi), %rsi
movb $0x11, 0x190(%rdi)
movq %r15, 0x198(%rdi)
callq 0x588a
movq %rax, 0x188(%rbx)
andl $0x0, 0x10(%rbx)
movq 0xc7ff(%rip), %rax      # 0x11fd0
movq (%rax), %rax
cmpq %r15, %rax
jne 0x57f4
cmpb $0x2d, (%r14)
jne 0x57ed
cmpb $0x2d, 0x1(%r14)
jne 0x57ed
cmpb $0x0, 0x2(%r14)
je 0x57f4
movl $0x1, 0x50(%rbx)
andl $0x0, 0x1a4(%rbx)
cmpq %r15, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x5822
movq %r14, %rdi
callq 0x40c0
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x4773
jmp 0x5824
xorl %eax, %eax
movq %rax, 0x1a8(%rbx)
movslq 0xa90(%rbx), %rsi
movq %rbx, %rdi
callq 0x46a3
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x58a9
movq 0x188(%rbx), %rax
movl $0x4000, (%rax)         # imm = 0x4000
cmpl $0x0, 0x10(%rbx)
jne 0x5868
xorl %eax, %eax
cmpl $0x0, 0xa94(%rbx)
setne %al
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0xc783(%rip), %rax      # 0x11ff8
movq (%rax), %rcx
leaq 0x6c99(%rip), %rdi      # 0xc518
pushq $0x31
popq %rsi
pushq $0x1
popq %rdx
jmp 0x42a0
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_port
static pointer mk_port(scheme * sc, port * p) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = T_PORT | T_ATOM;
  x->_object._port = p;
  return (x);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4617
movl $0x400a, (%rax)         # imm = 0x400A
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_load_string
void scheme_load_string(scheme * sc, const char *cmd) {
  dump_stack_reset(sc);
  sc->envir = sc->global_env;
  sc->file_i = 0;
  sc->load_stack[0].kind = port_input | port_string;
  sc->load_stack[0].rep.string.start = (char *) cmd;    /* This func respects const */
  sc->load_stack[0].rep.string.past_the_end = (char *) cmd + strlen(cmd);
  sc->load_stack[0].rep.string.curr = (char *) cmd;
  sc->loadport = mk_port(sc, sc->load_stack);
  sc->retcode = 0;
  sc->interactive_repl = 0;
  sc->args = mk_integer(sc, sc->file_i);
  Eval_Cycle(sc, OP_T0LVL);
  typeflag(sc->loadport) = T_ATOM;
  if (sc->retcode == 0) {
    sc->retcode = sc->nesting != 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x100(%rdi), %rcx
movq %rax, 0x48(%rdi)
movq %rcx, 0x38(%rdi)
andl $0x0, 0xa90(%rdi)
movq %rsi, %r14
leaq 0x190(%rdi), %r15
movb $0x12, 0x190(%rdi)
movq %rsi, 0x198(%rdi)
movq %rsi, %rdi
callq 0x40c0
addq %r14, %rax
movq %rax, 0x1a0(%rbx)
movq %r14, 0x1a8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x588a
movq %rax, 0x188(%rbx)
andl $0x0, 0x10(%rbx)
andl $0x0, 0x50(%rbx)
movslq 0xa90(%rbx), %rsi
movq %rbx, %rdi
callq 0x46a3
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x58a9
movq 0x188(%rbx), %rax
movl $0x4000, (%rax)         # imm = 0x4000
xorl %eax, %eax
cmpl %eax, 0x10(%rbx)
jne 0x5b8d
xorl %eax, %eax
cmpl $0x0, 0xa94(%rbx)
setne %al
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_define
void scheme_define(scheme * sc, pointer envir, pointer symbol, pointer value) {
  pointer x;

  x = find_slot_in_env(sc, envir, symbol, 0);
  if (x != sc->NIL) {
    set_slot_in_env(x, value);
  } else {
    new_slot_spec_in_env(sc, envir, symbol, value);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x5be4
cmpq 0x90(%r12), %rax
je 0x5bc8
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5c75
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: find_slot_in_env
static pointer find_slot_in_env(scheme * sc, pointer env, pointer hdl,
    int all) {
  pointer x, y;
  int location;

  for (x = env; x != sc->NIL; x = cdr(x)) {
    if (is_vector(car(x))) {
      location = hash_fn(symname(hdl), ivalue_unchecked(car(x)));
      y = vector_elem(car(x), location);
    } else {
      y = car(x);
    }
    for (; y != sc->NIL; y = cdr(y)) {
      if (caar(y) == hdl) {
        break;
      }
    }
    if (y != sc->NIL) {
      break;
    }
    if (!all) {
      return sc->NIL;
    }
  }
  if (x != sc->NIL) {
    return car(y);
  }
  return sc->NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq 0x90(%rdi), %r12
pushq $0x2
popq %rbp
cmpq %r12, %r15
je 0x5c63
movq 0x8(%r15), %r13
movl (%r13), %eax
andl $0x1f, %eax
cmpl $0xb, %eax
jne 0x5c44
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movl 0x10(%r13), %esi
callq 0x621a
movl %eax, %ecx
cltd
idivl %ebp
cltq
imulq $0x18, %rax, %rax
addq %r13, %rax
andl $0x1, %ecx
leaq (%rax,%rcx,8), %r13
addq $0x20, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x5c59
movq 0x8(%r13), %rax
cmpq %r14, 0x8(%rax)
je 0x5c66
addq $0x10, %r13
jmp 0x5c40
testl %ebx, %ebx
je 0x5c63
movq 0x10(%r15), %r15
jmp 0x5c01
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: new_slot_spec_in_env
static INLINE void new_slot_spec_in_env(scheme * sc, pointer env,
    pointer variable, pointer value) {
  pointer slot = immutable_cons(sc, variable, value);

  if (is_vector(car(env))) {
    int location = hash_fn(symname(variable), ivalue_unchecked(car(env)));

    set_vector_elem(car(env), location,
        immutable_cons(sc, slot, vector_elem(car(env), location)));
  } else {
    car(env) = immutable_cons(sc, slot, car(env));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x1
popq %rax
movq %rdx, %rsi
movq %rcx, %rdx
movl %eax, %ecx
callq 0x45e8
movq %rax, %r14
movq 0x8(%r12), %r15
movl (%r15), %eax
andl $0x1f, %eax
cmpl $0xb, %eax
jne 0x5ceb
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdi
movl 0x10(%r15), %esi
callq 0x621a
movl %eax, %r12d
pushq $0x2
popq %rcx
cltd
idivl %ecx
cltq
imulq $0x18, %rax, %r13
addq %r15, %r13
andl $0x1, %r12d
movq 0x20(%r13,%r12,8), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45e8
movq %rax, 0x20(%r13,%r12,8)
jmp 0x5d01
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x45e8
movq %rax, 0x8(%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: initFromEnv
void initFromEnv() {
    char* val = getenv("CELL_SEGSIZE");
    cell_segsize = val != NULL ? atoi(val) : CELL_SEGSIZE;
    val = getenv("CELL_NSEGMENT");
    cell_nsegment = val != NULL ? atoi(val) : CELL_NSEGMENT;
#ifdef EVAL_LIMIT
    val = getenv("EVAL_LIMIT");
    eval_limit = val != NULL ? atol(val) : EVAL_LIMIT;
#endif
}

// Assembly:
pushq %rax
leaq 0x681a(%rip), %rdi      # 0xc563
callq 0x4040
testq %rax, %rax
je 0x5d5d
movq %rax, %rdi
callq 0x4270
jmp 0x5d62
movl $0x4e20, %eax           # imm = 0x4E20
movl %eax, 0xc434(%rip)      # 0x1219c
leaq 0x6801(%rip), %rdi      # 0xc570
callq 0x4040
testq %rax, %rax
je 0x5d83
movq %rax, %rdi
callq 0x4270
jmp 0x5d86
pushq $0xc
popq %rax
movl %eax, 0xc40c(%rip)      # 0x12198
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: get_cell_x
static INLINE pointer get_cell_x(scheme * sc, pointer a, pointer b) {
  if (sc->free_cell != sc->NIL) {
    pointer x = sc->free_cell;
    sc->free_cell = cdr(x);
    --sc->fcells;
    return (x);
  }
  return _get_cell(sc, a, b);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x160(%rdi), %rax
cmpq 0x90(%rdi), %rax
je 0x613f
movq 0x10(%rax), %rcx
movq %rcx, 0x160(%rbx)
decq 0x168(%rbx)
jmp 0x614c
cmpb $0x0, 0xa99(%rbx)
je 0x6154
movq 0x70(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movslq 0x28(%rbx), %r14
shlq $0x3, %r14
movq %rbx, %rdi
callq 0x5585
cmpq %r14, 0x168(%rbx)
jl 0x617d
movq 0x160(%rbx), %rax
cmpq 0x90(%rbx), %rax
jne 0x612b
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x51cd
movl %eax, %ecx
movq 0x160(%rbx), %rax
testl %ecx, %ecx
jne 0x612b
cmpq 0x90(%rbx), %rax
jne 0x612b
movb $0x1, 0xa99(%rbx)
jmp 0x6148
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: push_recent_alloc
static void push_recent_alloc(scheme * sc, pointer recent, pointer extra) {
  pointer holder = get_cell_x(sc, recent, extra);
  typeflag(holder) = T_PAIR | T_IMMUTABLE;
  car(holder) = recent;
  cdr(holder) = car(sc->sink);
  car(sc->sink) = holder;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6114
movl $0x2005, (%rax)         # imm = 0x2005
movq %rbx, 0x8(%rax)
movq 0x70(%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x70(%r14), %rcx
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: utf8_decode
static int utf8_decode(const char *p) {
  int bytes;
  int c;
  unsigned char *s = (unsigned char*) p;
  if (IS_ASCII(*s)) {
    return *s;
  }
  bytes = (*s < 0xE0) ? 2 : ((*s < 0xF0) ? 3 : 4);
  c = *s & ((0x100 >> bytes) - 1);
  while (--bytes) {
    c = (c << 6) | (*(++s) & 0x3F);
  }
  return c;
}

// Assembly:
movsbl (%rdi), %eax
testl %eax, %eax
js 0x61e4
retq
cmpb $-0x10, %al
pushq $0x4
popq %rdx
sbbl $0x0, %edx
cmpb $-0x20, %al
pushq $0x2
popq %rcx
cmovael %edx, %ecx
movl $0x100, %edx            # imm = 0x100
shrl %cl, %edx
decl %edx
andl %eax, %edx
movzbl %dl, %eax
pushq $0x1
popq %rdx
cmpl %edx, %ecx
je 0x61e3
shll $0x6, %eax
movzbl (%rdi,%rdx), %esi
andl $0x3f, %esi
orl %esi, %eax
incq %rdx
jmp 0x6205
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: hash_fn
static int hash_fn(const char *key, int table_size) {
  unsigned int hashed = 0;
  const char *c;
  int bits_per_int = sizeof(unsigned int) * 8;

  for (c = key; *c; c++) {
    /* letters have about 5 bits in them */
    hashed = (hashed << 5) | (hashed >> (bits_per_int - 5));
    hashed ^= *c;
  }
  return hashed % table_size;
}

// Assembly:
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x622d
roll $0x5, %eax
xorl %ecx, %eax
incq %rdi
jmp 0x621c
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: fill_vector
INTERFACE static void fill_vector(pointer vec, pointer obj) {
  int i;
  int num = ivalue(vec) / 2 + ivalue(vec) % 2;
  for (i = 0; i < num; i++) {
    typeflag(vec + 1 + i) = T_PAIR;
    setimmutable(vec + 1 + i);
    car(vec + 1 + i) = obj;
    cdr(vec + 1 + i) = obj;
  }
}

// Assembly:
cmpb $0x0, 0x8(%rdi)
je 0x6325
movq 0x10(%rdi), %rax
jmp 0x632b
cvttsd2si 0x10(%rdi), %rax
pushq $0x2
popq %rcx
cqto
idivq %rcx
addl %eax, %edx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
imulq $0x18, %rdx, %rcx
cmpq %rax, %rcx
je 0x635d
movl $0x2005, 0x18(%rdi,%rax) # imm = 0x2005
movq %rsi, 0x20(%rdi,%rax)
movq %rsi, 0x28(%rdi,%rax)
addq $0x18, %rax
jmp 0x6340
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: find_consecutive_cells
static pointer find_consecutive_cells(scheme * sc, int n) {
  pointer *pp;
  int cnt;

  pp = &sc->free_cell;
  while (*pp != sc->NIL) {
    cnt = count_consecutive_cells(*pp, n);
    if (cnt >= n) {
      pointer x = *pp;
      *pp = cdr(*pp + n - 1);
      sc->fcells -= n;
      return x;
    }
    pp = &cdr(*pp + cnt - 1);
  }
  return sc->NIL;
}

// Assembly:
leaq 0x160(%rdi), %rcx
movq 0x90(%rdi), %rdx
pushq $0x1
popq %r8
movq (%rcx), %rax
cmpq %rdx, %rax
je 0x63b4
movq %rax, %r9
movl %r8d, %r10d
movq %r9, %r11
movq 0x10(%r9), %r9
addq $0x18, %r11
cmpq %r11, %r9
jne 0x639c
leal 0x1(%r10), %r11d
cmpl %esi, %r10d
movl %r11d, %r10d
jl 0x637e
jmp 0x639f
movl %r10d, %r11d
cmpl %esi, %r11d
jge 0x63b8
movslq %r11d, %rcx
imulq $0x18, %rcx, %rcx
addq %rax, %rcx
addq $-0x8, %rcx
jmp 0x6370
movq %rdx, %rax
retq
movslq %esi, %rdx
imulq $0x18, %rdx, %rsi
movq -0x8(%rax,%rsi), %rsi
movq %rsi, (%rcx)
subq %rdx, 0x168(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: s_return
static pointer _s_return(scheme * sc, pointer a) {
  sc->value = (a);
  if (sc->dump == sc->NIL)
    return sc->NIL;
  sc->op = ivalue(car(sc->dump));
  sc->args = cadr(sc->dump);
  sc->envir = caddr(sc->dump);
  sc->code = cadddr(sc->dump);
  sc->dump = cddddr(sc->dump);
  return sc->T;
}

// Assembly:
movq %rsi, 0xec0(%rdi)
movq 0x48(%rdi), %rcx
movq 0x90(%rdi), %rax
cmpq %rax, %rcx
je 0xa7df
movq 0x8(%rcx), %rax
cmpb $0x0, 0x8(%rax)
je 0xa788
movq 0x10(%rax), %rax
jmp 0xa78e
cvttsd2si 0x10(%rax), %rax
movl %eax, 0xec8(%rdi)
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rdi)
movq 0xb0(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_closure
static pointer mk_closure(scheme * sc, pointer c, pointer e) {
  pointer x = get_cell(sc, c, e);

  typeflag(x) = T_CLOSURE;
  car(x) = c;
  cdr(x) = e;
  return (x);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x4617
movl $0x6, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: port_close
static void port_close(scheme * sc, pointer p, int flag) {
  port *pt = p->_object._port;
  pt->kind &= ~flag;
  if ((pt->kind & (port_input | port_output)) == 0) {
    if (pt->kind & port_file) {

#if SHOW_ERROR_LINE
      /* Cleanup is here so (close-*-port) functions could work too */
      pt->rep.stdio.curr_line = 0;

      if (pt->rep.stdio.filename)
        sc->free(pt->rep.stdio.filename);
#endif

      fclose(pt->rep.stdio.file);
    }
    pt->kind = port_free;
  }
}

// Assembly:
pushq %rbx
movq 0x8(%rsi), %rbx
movzbl (%rbx), %esi
notb %dl
movzbl %dl, %ecx
andl %esi, %ecx
movb %cl, (%rbx)
testb $0x30, %cl
jne 0xaa54
testb $0x1, %cl
je 0xaa51
movq %rdi, %rax
andl $0x0, 0x14(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xaa48
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
callq 0x40b0
movb $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: inchar
static int inchar(scheme * sc) {
  int c;
  port *pt;
  if (sc->backchar >= 0) {
    c = sc->backchar;
    sc->backchar = -1;
    return c;
  }
  pt = sc->inport->_object._port;
  if (pt->kind & port_saw_EOF) {
    return EOF;
  }
  c = utf8_inchar(pt);
  if (c == EOF && sc->inport == sc->loadport) {
    /* Instead, set port_saw_EOF */
    pt->kind |= port_saw_EOF;
    return EOF;
  }
  return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
testl %eax, %eax
js 0xaa75
orl $-0x1, 0x2c(%rbx)
jmp 0xaafa
movq 0x170(%rbx), %rax
movq 0x8(%rax), %r14
pushq $-0x1
popq %rbp
testb $0x40, (%r14)
jne 0xaaf8
movq %r14, %rdi
callq 0xab21
cmpl $0x80, %eax
jl 0xaadf
movb %al, 0xc(%rsp)
cmpl $0xf0, %eax
pushq $0x4
popq %rcx
sbbq $0x0, %rcx
cmpl $0xe0, %eax
pushq $0x2
popq %r15
cmovaeq %rcx, %r15
pushq $0x1
popq %r12
cmpq %r15, %r12
jae 0xaad5
movq %r14, %rdi
callq 0xab21
cmpl $-0x1, %eax
je 0xaae4
movb %al, 0xc(%rsp,%r12)
incq %r12
jmp 0xaab9
leaq 0xc(%rsp), %rdi
callq 0x61dc
cmpl $-0x1, %eax
jne 0xaafa
movq 0x170(%rbx), %rax
cmpq 0x188(%rbx), %rax
jne 0xaaf8
orb $0x40, (%r14)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: is_one_of
static INLINE int is_one_of(char *s, int c) {
  if (c == EOF)
    return 1;
  while (*s)
    if (*s++ == c)
      return (1);
  return (0);
}

// Assembly:
pushq $0x1
popq %rax
cmpl $-0x1, %esi
je 0xab1d
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0xab1e
incq %rdi
cmpl %esi, %ecx
jne 0xab0f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: basic_inchar
static int basic_inchar(port * pt) {
  if (pt->kind & port_file) {
    return fgetc(pt->rep.stdio.file);
  } else {
    if (*pt->rep.string.curr == 0 ||
        pt->rep.string.curr == pt->rep.string.past_the_end) {
      return EOF;
    } else {
      return *pt->rep.string.curr++;
    }
  }
}

// Assembly:
testb $0x1, (%rdi)
jne 0xab44
movq 0x18(%rdi), %rcx
pushq $-0x1
popq %rax
cmpb $0x0, (%rcx)
je 0xab43
cmpq 0x10(%rdi), %rcx
je 0xab43
leaq 0x1(%rcx), %rax
movq %rax, 0x18(%rdi)
movsbl (%rcx), %eax
retq
movq 0x8(%rdi), %rdi
jmp 0x4130
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: list_star
static pointer list_star(scheme * sc, pointer d) {
  pointer p, q;
  if (cdr(d) == sc->NIL) {
    return car(d);
  }
  p = cons(sc, car(d), cdr(d));
  q = p;
  while (cdr(cdr(p)) != sc->NIL) {
    d = cons(sc, car(p), cdr(p));
    if (cdr(cdr(p)) != sc->NIL) {
      p = cdr(d);
    }
  }
  cdr(p) = car(cdr(p));
  return q;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rbx
movq 0x10(%rsi), %rdx
cmpq 0x90(%rdi), %rdx
je 0xabb4
movq %rdi, %r14
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x45e8
movq %rax, %rbx
movq 0x90(%r14), %rcx
movq %rax, %r15
movq 0x10(%r15), %rdx
cmpq %rcx, 0x10(%rdx)
je 0xabac
movq 0x8(%r15), %rsi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x45e8
movq 0x10(%r15), %rdx
movq 0x90(%r14), %rcx
cmpq %rcx, 0x10(%rdx)
je 0xab7d
movq 0x10(%rax), %r15
jmp 0xab7d
movq 0x8(%rdx), %rax
movq %rax, 0x10(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: mk_sharp_const
static pointer mk_sharp_const(scheme * sc, char *name) {
  if (str_eq_to_lower(name, "t")) {
    return (sc->T);
  } else if (str_eq_to_lower(name, "f")) {
    return (sc->F);
  } else if (*name == '\\') {   /* #\w (character) */
    int c = 0;
    if (str_eq_to_lower(name + 1, "space")) {
      c = ' ';
    } else if (str_eq_to_lower(name + 1, "newline")) {
      c = '\n';
    } else if (str_eq_to_lower(name + 1, "return")) {
      c = '\r';
    } else if (str_eq_to_lower(name + 1, "tab")) {
      c = '\t';
    } else if (name[1] == 'x' && name[2] != 0) {
      int c1 = 0;
      if (sscanf(name + 2, "%x", (unsigned int *) &c1) == 1) {
        c = c1;
      } else {
        return sc->NIL;
      }
    } else if (name[2] == 0) {
      c = name[1];
    } else {
      return sc->NIL;
    }
    return mk_character(sc, c);
  } else if (*name == 'x') {    /* #x (hex) */
    return (mk_integer(sc, strtol(name + 1, 0, 16)));
  } else if (*name == 'b') {    /* #b (bin) */
    return (mk_integer(sc, strtol(name + 1, 0, 2)));
  } else if (*name == 'o') {    /* #o (oct) */
    return (mk_integer(sc, strtol(name + 1, 0, 8)));
  } else if (*name == 'd') {    /* #d (dec) */
    return (mk_integer(sc, strtol(name + 1, 0, 10)));
  } else {
    return (sc->NIL);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %eax
cmpl $0x5c, %eax
je 0xac4f
cmpl $0x62, %eax
je 0xacf8
cmpl $0x64, %eax
je 0xacf1
cmpl $0x66, %eax
je 0xac24
cmpl $0x6f, %eax
je 0xac45
cmpl $0x78, %eax
je 0xac3b
cmpl $0x74, %eax
jne 0xac2f
cmpb $0x0, 0x1(%r14)
jne 0xac2f
movq 0xb0(%rbx), %rax
jmp 0xad3c
cmpb $0x0, 0x1(%r14)
je 0xad1c
movq 0x90(%rbx), %rax
jmp 0xad3c
incq %r14
pushq $0x10
jmp 0xacfd
incq %r14
pushq $0x8
jmp 0xacfd
leaq 0x1(%r14), %r15
leaq 0x2433(%rip), %rsi      # 0xd08d
movq %r15, %rdi
callq 0x41a0
testl %eax, %eax
je 0xad25
leaq 0x2424(%rip), %rsi      # 0xd095
movq %r15, %rdi
callq 0x41a0
testl %eax, %eax
je 0xad29
leaq 0x2417(%rip), %rsi      # 0xd09f
movq %r15, %rdi
callq 0x41a0
testl %eax, %eax
je 0xad2d
leaq 0x2409(%rip), %rsi      # 0xd0a8
movq %r15, %rdi
callq 0x41a0
testl %eax, %eax
je 0xad31
movsbl 0x1(%r14), %esi
movb 0x2(%r14), %al
cmpl $0x78, %esi
jne 0xad46
testb %al, %al
je 0xad34
addq $0x2, %r14
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x23d7(%rip), %rsi      # 0xd0af
movq %r14, %rdi
xorl %eax, %eax
callq 0x4200
cmpl $0x1, %eax
jne 0xac2f
movl 0xc(%rsp), %esi
jmp 0xad34
incq %r14
pushq $0xa
jmp 0xacfd
incq %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x41c0
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x46a3
movq 0xd0(%rbx), %rax
jmp 0xad3c
pushq $0x20
jmp 0xad33
pushq $0xa
jmp 0xad33
pushq $0xd
jmp 0xad33
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x467e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
testb %al, %al
jne 0xac2f
jmp 0xad34
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: upgrade_string
static void upgrade_string(scheme *sc, pointer p) {
  int len = strlength(p);
  char *s = strvalue(p);
  int *sbig = (int*) sc->malloc((len + 1) * sizeof(int));
  int i;
  sbig[0] = UTFSTR_LEN_SET(len);
  for (i = 0; i < len; i++) {
    sbig[i + 1] = s[i];
  }
  sc->free(s);
  strvalue(p) = (char*) sbig;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x10(%rsi), %r13
movq 0x8(%rsi), %r15
leaq 0x4(,%r13,4), %rdi
callq *(%r14)
movq %rax, %r12
movl %r13d, %eax
shll $0x8, %eax
orl $0x80000080, %eax       # imm = 0x80000080
movl %eax, (%r12)
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
cmpq %rax, %rcx
je 0xb5a9
movsbl (%r15,%rax), %edx
movl %edx, 0x4(%r12,%rax,4)
incq %rax
jmp 0xb595
movq %r15, %rdi
callq *0x8(%r14)
movq %r12, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/RodionGork[P]tinyscheme/scheme.c
// Function: char_to_utf8
static void char_to_utf8(int c, char *p, int *plen) {
  unsigned char *s = (unsigned char *) p;
  int bytes;
  if (c < 0 || c > 0x10FFFF) {
    c = '?';
  }
  if (c < 0x80) {
    *s++ = (unsigned char) c;
    *s = 0;
  } else {
    bytes = (c < 0x800) ? 2 : ((c < 0x10000) ? 3 : 4);
    s[bytes] = 0;
    s[0] = 0x80;
    while (--bytes) {
      s[0] |= (0x80 >> bytes);
      s[bytes] = (unsigned char) (0x80 | (c & 0x3F));
      c >>= 6;
    }
    s[0] |= (unsigned char) c;
  }
  *plen = strlen(p);
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
cmpl $0x110000, %edi         # imm = 0x110000
pushq $0x3f
popq %rax
cmovbl %edi, %eax
cmpl $0x7f, %eax
ja 0xb5db
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
jmp 0xb620
cmpl $0x10000, %eax          # imm = 0x10000
pushq $0x4
popq %rdx
sbbl $0x0, %edx
cmpl $0x800, %eax            # imm = 0x800
pushq $0x2
popq %rcx
cmovael %edx, %ecx
movb $0x0, (%rsi,%rcx)
decl %ecx
movb $-0x80, %al
testl %ecx, %ecx
je 0xb61b
movl $0x80, %edx
shrl %cl, %edx
orb %dl, %al
movb %al, (%rsi)
movl %edi, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movb %dl, (%rsi,%rcx)
shrl $0x6, %edi
decq %rcx
jmp 0xb5f9
orb %dil, %al
movb %al, (%rsi)
movq %rsi, %rdi
callq 0x40c0
movl %eax, (%rbx)
popq %rbx
retq