LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: cons
pointer _cons(scheme * sc, pointer a, pointer b, int immutable) {
  pointer x = get_cell(sc, a, b);

  typeflag(x) = T_PAIR;
  if (immutable) {
    setimmutable(x);
  }
  car(x) = a;
  cdr(x) = b;
  return (x);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x5, (%rax)
cmpl $0x0, 0xc(%rsp)
je 0x4999
movq (%rsp), %rdi
callq 0x4930
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: get_cell
static pointer get_cell(scheme * sc, pointer a, pointer b) {
  pointer cell = get_cell_x(sc, a, b);
  /* For right now, include "a" and "b" in "cell" so that gc doesn't
     think they are garbage. */
  /* Tentatively record it as a pair so gc understands it. */
  typeflag(cell) = T_PAIR;
  car(cell) = a;
  cdr(cell) = b;
  push_recent_alloc(sc, cell, sc->NIL);
  return cell;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x7db0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x5, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x7e50
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_foreign_func
pointer mk_foreign_func(scheme * sc, foreign_func f) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_FOREIGN | T_ATOM);
  x->_object._ff = f;
  return (x);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x4008, (%rax)         # imm = 0x4008
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_character
INTERFACE pointer mk_character(scheme * sc, int c) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_CHARACTER | T_ATOM);
  ivalue_unchecked(x) = c;
  set_num_integer(x);
  return (x);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x4009, (%rax)         # imm = 0x4009
movslq 0xc(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x1, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_integer
INTERFACE pointer mk_integer(scheme * sc, long num) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_NUMBER | T_ATOM);
  ivalue_unchecked(x) = num;
  set_num_integer(x);
  return (x);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x4002, (%rax)         # imm = 0x4002
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x1, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_real
INTERFACE pointer mk_real(scheme * sc, double n) {
  pointer x = get_cell(sc, sc->NIL, sc->NIL);

  typeflag(x) = (T_NUMBER | T_ATOM);
  rvalue_unchecked(x) = n;
  set_num_real(x);
  return (x);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x4002, (%rax)         # imm = 0x4002
movsd 0x8(%rsp), %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq (%rsp), %rax
movb $0x0, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_counted_string
INTERFACE pointer mk_counted_string(scheme * sc, const char *str, int len) {
  char *s;
  pointer x = get_cell(sc, sc->NIL, sc->NIL);
  typeflag(x) = (T_STRING | T_ATOM);
  s = store_string(sc, len, str);
  strvalue(x) = s;
  strlength(x) = IS_ASCII(*s) ? len : UTFSTR_LEN_GET(s);
  return x;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x30(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x4001, (%rax)         # imm = 0x4001
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x4cc0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
andl $-0x80, %eax
cmpl $0x0, %eax
jne 0x4c94
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x4ca7
movq 0x18(%rsp), %rax
movl (%rax), %eax
sarl $0x8, %eax
andl $0x7fffff, %eax         # imm = 0x7FFFFF
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x1, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x4d18
movq 0x18(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4d0b
movl $0x4, 0x4(%rsp)
jmp 0x4d18
jmp 0x4d0d
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4ce1
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
imull 0x4(%rsp), %ecx
movslq %ecx, %rdi
callq *%rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4d60
movq 0x28(%rsp), %rax
movb $0x1, 0xa99(%rax)
movq 0x28(%rsp), %rax
movq 0xea0(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x4e3d
cmpq $0x0, 0x18(%rsp)
je 0x4e33
cmpl $0x1, 0x4(%rsp)
jne 0x4d9a
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x24(%rsp), %rdx
callq 0x41b0
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x4e31
movl $0x1, (%rsp)
movq 0x18(%rsp), %rax
movslq 0x24(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x4e15
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
andl $-0x80, %eax
cmpl $0x0, %eax
je 0x4de3
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x4e05
movq 0x18(%rsp), %rdi
callq 0x8020
movl %eax, %edx
movq 0x10(%rsp), %rax
movl (%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4db3
movl (%rsp), %ecx
subl $0x1, %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
shll $0x8, %ecx
orl $0x80000080, %ecx       # imm = 0x80000080
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4e33
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4ec0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x4e91
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x4eaf
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4f80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xf8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, %esi
callq 0x8100
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0xf8(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0x8180
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x4f64
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x47b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x4f52
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x4f75
jmp 0x4f54
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x4f08
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4bc0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rdx
movl $0x1, %ecx
callq 0x4950
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl $0x3, (%rax)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4930
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0xf8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, %esi
callq 0x8100
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movq 0xf8(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0xf8(%rax), %rdi
movl 0x2c(%rsp), %esi
callq 0x8180
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x4950
movq 0x20(%rsp), %rdi
movl 0x28(%rsp), %esi
movq %rax, %rdx
callq 0x81f0
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0xed8(%rax)
jge 0x5128
movq %rsp, %rdi
movq 0x38(%rsp), %rax
movq 0xed8(%rax), %rcx
movl $0x28, %esi
leaq 0x12600(%rip), %rdx     # 0x176c0
movb $0x0, %al
callq 0x40c0
movq 0x38(%rsp), %rdi
movq %rsp, %rsi
callq 0x4ec0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x50ee
jmp 0x510c
movq 0x38(%rsp), %rdi
movq %rsp, %rsi
callq 0x4f80
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x5139
movq 0x38(%rsp), %rax
movq 0xed8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xed8(%rax)
jmp 0x5089
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x178(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5198
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x40f0
jmp 0x522f
jmp 0x519a
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x522d
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x51d8
movq 0x8(%rsp), %rax
movb (%rax), %cl
movq (%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
jmp 0x5218
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5216
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x5240
cmpl $0x0, %eax
je 0x5216
movq 0x8(%rsp), %rax
movb (%rax), %cl
movq (%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
jmp 0x5218
jmp 0x521a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x519a
jmp 0x522f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
addq $0x1, %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdi
callq *%rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5336
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
subq $0x1, %rdx
movl $0x20, %esi
callq 0x4100
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4040
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
addq 0x10(%rsp), %rcx
addq $-0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rax, %rsi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movl $0x1, 0x34(%rsp)
jmp 0x533e
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x178(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5393
movl 0xc(%rsp), %edi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x4150
jmp 0x5403
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x53c2
movl 0xc(%rsp), %eax
movb %al, %cl
movq (%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
jmp 0x5401
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x53ff
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x5240
cmpl $0x0, %eax
je 0x53ff
movl 0xc(%rsp), %eax
movb %al, %cl
movq (%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
jmp 0x5401
jmp 0x5403
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
cmpq $0x0, -0x8(%rsp)
jge 0x5446
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x546c
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movb $0x30, (%rax)
jmp 0x546e
cmpq $0x0, -0x8(%rsp)
jle 0x54dc
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
cqto
idivq %rcx
movb %dl, %al
movb %al, -0x21(%rsp)
movslq -0x14(%rsp), %rcx
movq -0x8(%rsp), %rax
cqto
idivq %rcx
movq %rax, -0x8(%rsp)
movsbl -0x21(%rsp), %eax
cmpl $0xa, %eax
jge 0x54b7
movsbl -0x21(%rsp), %eax
addl $0x30, %eax
movb %al, -0x21(%rsp)
jmp 0x54c3
movsbl -0x21(%rsp), %eax
addl $0x37, %eax
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
jmp 0x546e
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
movb $0x0, (%rax)
movq -0x10(%rsp), %rax
cmpq -0x20(%rsp), %rax
jbe 0x553a
movq -0x20(%rsp), %rax
movb (%rax), %al
movb %al, -0x21(%rsp)
movq -0x10(%rsp), %rax
movb (%rax), %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
movb -0x21(%rsp), %cl
movq -0x10(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rsp)
movb %cl, (%rax)
jmp 0x54f0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4400
cmpl $0x0, %eax
je 0x559c
movq 0x40(%rsp), %rdi
callq 0x4400
cmpl $0x0, %eax
je 0x558f
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x40(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
jmp 0x574b
movl $0x0, 0x54(%rsp)
jmp 0x574b
movq 0x48(%rsp), %rdi
callq 0x4460
cmpl $0x0, %eax
je 0x563b
movq 0x40(%rsp), %rdi
callq 0x4460
cmpl $0x0, %eax
je 0x562e
movq 0x48(%rsp), %rdi
callq 0x4500
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4500
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jne 0x562c
movq 0x48(%rsp), %rdi
callq 0x4620
movb %al, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4620
movb %al, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movb 0x30(%rsp), %dl
movq 0x38(%rsp), %rsi
movb 0x20(%rsp), %al
movq 0x28(%rsp), %rcx
movzbl %dl, %edi
movzbl %al, %edx
callq 0x5760
movl %eax, 0x54(%rsp)
jmp 0x574b
jmp 0x562e
movl $0x0, 0x54(%rsp)
jmp 0x574b
movq 0x48(%rsp), %rdi
callq 0x45f0
cmpl $0x0, %eax
je 0x569b
movq 0x40(%rsp), %rdi
callq 0x45f0
cmpl $0x0, %eax
je 0x568e
movq 0x48(%rsp), %rdi
callq 0x4640
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4640
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
jmp 0x574b
movl $0x0, 0x54(%rsp)
jmp 0x574b
movq 0x48(%rsp), %rdi
callq 0x4650
cmpl $0x0, %eax
je 0x56db
movq 0x40(%rsp), %rdi
callq 0x4650
cmpl $0x0, %eax
je 0x56d1
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
jmp 0x574b
movl $0x0, 0x54(%rsp)
jmp 0x574b
movq 0x48(%rsp), %rdi
callq 0x47f0
cmpl $0x0, %eax
je 0x5735
movq 0x40(%rsp), %rdi
callq 0x47f0
cmpl $0x0, %eax
je 0x572b
movq 0x48(%rsp), %rdi
callq 0x4510
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4510
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
jmp 0x574b
movl $0x0, 0x54(%rsp)
jmp 0x574b
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movb %al, -0x20(%rsp)
movq %rcx, -0x18(%rsp)
movsbl -0x10(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rsp)
je 0x5796
movsbl -0x20(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rsp)
cmpl $0x0, -0x28(%rsp)
je 0x57c2
movq -0x8(%rsp), %rax
cmpq -0x18(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rsp)
jmp 0x5833
cmpb $0x0, -0x10(%rsp)
jne 0x57d7
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
jmp 0x57e4
cvtsi2sdq -0x8(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
movsd -0x38(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
cmpb $0x0, -0x20(%rsp)
jne 0x5805
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x5812
cvtsi2sdq -0x18(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x40(%rsp), %xmm0
movsd -0x48(%rsp), %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x5885
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x593c
movq 0x8(%rsp), %rdi
callq 0x4710
cmpl $0x0, %eax
jne 0x58a6
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x593c
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x58dc
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x593c
movq 0x8(%rsp), %rdi
callq 0x4710
cmpl $0x0, %eax
jne 0x58fa
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
subl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x593c
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x5937
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x593c
jmp 0x5865
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0xef8, %edi            # imm = 0xEF8
callq 0x42f8
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x59a0
cmpl $0x0, %eax
jne 0x5987
movq 0x8(%rsp), %rdi
callq 0x42f0
movq $0x0, 0x10(%rsp)
jmp 0x5991
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0xef8, %edi            # imm = 0xEF8
callq *0x18(%rsp)
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x5a20
cmpl $0x0, %eax
jne 0x5a0c
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq $0x0, 0x20(%rsp)
jmp 0x5a16
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x6496
movq 0x10(%rsp), %rdi
movl $0x1cd, %esi            # imm = 0x1CD
callq 0x8270
movq %rax, (%rsp)
jmp 0x64a6
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x1, %ecx
callq 0x4950
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl $0xe, (%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: assign_proc
static void assign_proc(scheme * sc, enum scheme_opcodes op, char *name) {
  pointer x, y;

  x = mk_symbol(sc, name);
  y = mk_proc(sc, op);
  new_slot_in_env(sc, x, y);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4e50
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x169f0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x64e0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x16230
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x6633
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x6646
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6f30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x16a50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x66df
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x66f3
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6f30
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x6d78
movq 0x14296(%rip), %rax     # 0x1aff8
movq (%rax), %rdi
leaq 0x10a04(%rip), %rsi     # 0x17770
movb $0x0, %al
callq 0x4190
jmp 0x6eff
movq 0x20(%rsp), %rdi
callq 0x6f10
movq 0x20(%rsp), %rax
movq 0x100(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0xa90(%rax)
movq 0x20(%rsp), %rax
movb $0x11, 0x190(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x198(%rax)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x190, %rsi            # imm = 0x190
callq 0x6f30
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x188(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x141d0(%rip), %rcx     # 0x1afd0
cmpq (%rcx), %rax
jne 0x6e27
movq 0x10(%rsp), %rdi
leaq 0x10991(%rip), %rsi     # 0x177a2
callq 0x4180
cmpl $0x0, %eax
je 0x6e27
movq 0x20(%rsp), %rax
movl $0x1, 0x50(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x1a4(%rax)
movq 0x18(%rsp), %rax
movq 0x1418e(%rip), %rcx     # 0x1afd0
cmpq (%rcx), %rax
je 0x6e85
cmpq $0x0, 0x10(%rsp)
je 0x6e85
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x40a0
movq 0x8(%rsp), %rdi
movl %eax, %esi
movq 0x10(%rsp), %rdx
callq 0x4cc0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x1a8(%rax)
jmp 0x6e95
movq 0x20(%rsp), %rax
movq $0x0, 0x1a8(%rax)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0xa90(%rax), %rsi
callq 0x4b00
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x6f90
movq 0x20(%rsp), %rax
movq 0x188(%rax), %rax
movl $0x4000, (%rax)         # imm = 0x4000
movq 0x20(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x6eff
movq 0x20(%rsp), %rax
cmpl $0x0, 0xa94(%rax)
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x400a, (%rax)         # imm = 0x400A
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x6f10
movq 0x10(%rsp), %rax
movq 0x100(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0xa90(%rax)
movq 0x10(%rsp), %rax
movb $0x12, 0x190(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x198(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x40a0
movq (%rsp), %rcx
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1a0(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x1a8(%rax)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x190, %rsi            # imm = 0x190
callq 0x6f30
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x188(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x50(%rax)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0xa90(%rax), %rsi
callq 0x4b00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x6f90
movq 0x10(%rsp), %rax
movq 0x188(%rax), %rax
movl $0x4000, (%rax)         # imm = 0x4000
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x7487
movq 0x10(%rsp), %rax
cmpl $0x0, 0xa94(%rax)
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x7510
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x74e4
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x7670
jmp 0x74fd
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x7690
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x7628
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4420
cmpl $0x0, %eax
je 0x7599
movq 0x28(%rsp), %rdi
callq 0x47b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, %esi
callq 0x8100
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x8180
movq %rax, 0x10(%rsp)
jmp 0x75a7
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x75a9
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x75e4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0x75d2
jmp 0x75e4
jmp 0x75d4
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x75a9
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x75f9
jmp 0x7628
cmpl $0x0, 0x24(%rsp)
jne 0x7613
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x765c
jmp 0x7615
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x7531
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x764b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x765c
movq 0x38(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl $0x1, %ecx
callq 0x4950
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4420
cmpl $0x0, %eax
je 0x7766
movq 0x30(%rsp), %rdi
callq 0x47b0
movq %rax, %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movl %eax, %esi
callq 0x8100
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0x8180
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x4950
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %esi
movq %rax, %rdx
callq 0x81f0
jmp 0x778f
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %ecx
callq 0x4950
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
leaq 0xff91(%rip), %rdi      # 0x177bc
callq 0x4030
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x784d
movq 0x10(%rsp), %rdi
callq 0x4260
movl %eax, 0xc(%rsp)
jmp 0x7858
movl $0x4e20, %eax           # imm = 0x4E20
movl %eax, 0xc(%rsp)
jmp 0x7858
movl 0xc(%rsp), %eax
movl %eax, 0x150de(%rip)     # 0x1c940
leaq 0xff60(%rip), %rdi      # 0x177c9
callq 0x4030
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x788b
movq 0x10(%rsp), %rdi
callq 0x4260
movl %eax, 0x8(%rsp)
jmp 0x7896
movl $0xc, %eax
movl %eax, 0x8(%rsp)
jmp 0x7896
movl 0x8(%rsp), %eax
movl %eax, 0x138f0(%rip)     # 0x1b190
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: reverse_in_place
static pointer reverse_in_place(scheme * sc, pointer term, pointer list) {
  pointer p = list, result = term, q;

  while (p != sc->NIL) {
    q = cdr(p);
    cdr(p) = result;
    result = p;
    p = q;
  }
  return (result);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x7da8
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x7d63
movq -0x28(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x160(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x7e23
movq 0x18(%rsp), %rax
movq 0x160(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x160(%rax)
movq 0x18(%rsp), %rax
movq 0x168(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x168(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7e3c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x7ed0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x7db0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x2005, (%rax)         # imm = 0x2005
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: get_cell
static pointer _get_cell(scheme * sc, pointer a, pointer b) {
  pointer x;

  if (sc->no_memory) {
    return sc->sink;
  }

  if (sc->free_cell == sc->NIL) {
    const int min_to_be_recovered = sc->last_cell_seg * 8;
    gc(sc, a, b);
    if (sc->fcells < min_to_be_recovered || sc->free_cell == sc->NIL) {
      /* if only a few recovered, get more to avoid fruitless gc's */
      if (!alloc_cellseg(sc, 1) && sc->free_cell == sc->NIL) {
        sc->no_memory = 1;
        return sc->sink;
      }
    }
  }
  x = sc->free_cell;
  sc->free_cell = cdr(x);
  --sc->fcells;
  return (x);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpb $0x0, 0xa99(%rax)
je 0x7f04
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x800a
movq 0x28(%rsp), %rax
movq 0x160(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x7fc3
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
shll $0x3, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x6a70
movq 0x28(%rsp), %rax
movq 0x168(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq %rcx, %rax
jl 0x7f75
movq 0x28(%rsp), %rax
movq 0x160(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x7fc1
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x60d0
cmpl $0x0, %eax
jne 0x7fbf
movq 0x28(%rsp), %rax
movq 0x160(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x7fbf
movq 0x28(%rsp), %rax
movb $0x1, 0xa99(%rax)
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x800a
jmp 0x7fc1
jmp 0x7fc3
movq 0x28(%rsp), %rax
movq 0x160(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x160(%rax)
movq 0x28(%rsp), %rax
movq 0x168(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x168(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)