LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
andl $-0x80, %eax
cmpl $0x0, %eax
jne 0x8050
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rsp)
jmp 0x80ee
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xe0, %eax
jge 0x806a
movl $0x2, %eax
movl %eax, -0x24(%rsp)
jmp 0x8089
movq -0x20(%rsp), %rax
movzbl (%rax), %edx
movl $0x4, %eax
movl $0x3, %ecx
cmpl $0xf0, %edx
cmovll %ecx, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x20(%rsp), %rax
movzbl (%rax), %eax
movl -0x14(%rsp), %ecx
movl $0x100, %edx            # imm = 0x100
sarl %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, %eax
je 0x80e6
movl -0x18(%rsp), %eax
shll $0x6, %eax
movq -0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movzbl 0x1(%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rsp)
jmp 0x80af
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl $0x20, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x8169
movl -0x10(%rsp), %eax
shll $0x5, %eax
movl -0x10(%rsp), %edx
movl -0x1c(%rsp), %ecx
subl $0x5, %ecx
shrl %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x8123
movl -0x10(%rsp), %eax
xorl %edx, %edx
divl -0xc(%rsp)
movl %edx, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: vector_elem
INTERFACE static pointer vector_elem(pointer vec, int ielem) {
  int n = ielem / 2;
  if (ielem % 2 == 0) {
    return car(vec + 1 + n);
  } else {
    return cdr(vec + 1 + n);
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x81ca
movq -0x10(%rsp), %rax
addq $0x18, %rax
movslq -0x18(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x81e8
movq -0x10(%rsp), %rax
addq $0x18, %rax
movslq -0x18(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: set_vector_elem
INTERFACE static pointer set_vector_elem(pointer vec, int ielem, pointer a) {
  int n = ielem / 2;
  if (ielem % 2 == 0) {
    return car(vec + 1 + n) = a;
  } else {
    return cdr(vec + 1 + n) = a;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movl -0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rsp)
movl -0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x8244
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
addq $0x18, %rcx
movslq -0x24(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x8(%rsp)
jmp 0x8267
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
addq $0x18, %rcx
movslq -0x24(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq %rax, 0x10(%rcx)
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: get_vector_object
static pointer get_vector_object(scheme * sc, int len, pointer init) {
  pointer cells = get_consecutive_cells(sc, len / 2 + len % 2 + 1);
  if (sc->no_memory) {
    return sc->sink;
  }
  /* Record it as a vector so that gc understands it. */
  typeflag(cells) = (T_VECTOR | T_ATOM);
  ivalue_unchecked(cells) = len;
  set_num_integer(cells);
  fill_vector(cells, init);
  push_recent_alloc(sc, cells, sc->NIL);
  return cells;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl 0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl %edx, %esi
addl $0x1, %esi
callq 0x8360
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpb $0x0, 0xa99(%rax)
je 0x82fd
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x834d
movq (%rsp), %rax
movl $0x400b, (%rax)         # imm = 0x400B
movslq 0x14(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x1, 0x8(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x84a0
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x7e50
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: get_consecutive_cells
static pointer get_consecutive_cells(scheme * sc, int n) {
  pointer x;

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

  /* Are there any cells available? */
  x = find_consecutive_cells(sc, n);
  if (x != sc->NIL) {
    return x;
  }

  /* If not, try gc'ing some */
  gc(sc, sc->NIL, sc->NIL);
  x = find_consecutive_cells(sc, n);
  if (x != sc->NIL) {
    return x;
  }

  /* If there still aren't, try getting more heap */
  if (!alloc_cellseg(sc, 1)) {
    sc->no_memory = 1;
    return sc->sink;
  }

  x = find_consecutive_cells(sc, n);
  if (x != sc->NIL) {
    return x;
  }

  /* If all fail, report failure */
  sc->no_memory = 1;
  return sc->sink;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpb $0x0, 0xa99(%rax)
je 0x838e
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x8493
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8590
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x83c3
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x8493
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x6a70
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8590
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x8417
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x8493
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x60d0
cmpl $0x0, %eax
jne 0x8447
movq 0x18(%rsp), %rax
movb $0x1, 0xa99(%rax)
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x8493
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x8590
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x8479
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x8493
movq 0x18(%rsp), %rax
movb $0x1, 0xa99(%rax)
movq 0x18(%rsp), %rax
movq 0x70(%rax), %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: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4510
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4510
movl $0x2, %ecx
cqto
idivq %rcx
movq 0x8(%rsp), %rax
addq %rdx, %rax
movl %eax, 0x10(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x857e
movq 0x20(%rsp), %rax
addq $0x18, %rax
movslq 0x14(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x5, (%rax)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x14(%rsp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x4930
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
addq $0x18, %rax
movslq 0x14(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
addq $0x18, %rax
movslq 0x14(%rsp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x84ef
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
addq $0x160, %rax            # imm = 0x160
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x8664
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl 0x24(%rsp), %esi
callq 0x8680
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jl 0x863a
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movslq 0x24(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x168(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x168(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x8675
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $-0x18, %rax
addq $0x8, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x85ad
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: count_consecutive_cells
static int count_consecutive_cells(pointer x, int needed) {
  int n = 1;
  while (cdr(x) == x + 1) {
    x = cdr(x);
    n++;
    if (n > needed)
      return n;
  }
  return n;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl $0x1, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x86d7
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rsp)
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jle 0x86d5
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x86df
jmp 0x8691
movl -0x18(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: file_push
static int file_push(scheme * sc, const char *fname) {
  FILE *fin = NULL;

  if (sc->file_i == MAXFIL - 1)
    return 0;
  fin = fopen(fname, "r");
  if (fin != 0) {
    sc->file_i++;
    sc->load_stack[sc->file_i].kind = port_file | port_input;
    sc->load_stack[sc->file_i].rep.stdio.file = fin;
    sc->load_stack[sc->file_i].rep.stdio.closeit = 1;
    sc->nesting_stack[sc->file_i] = 0;
    sc->loadport->_object._port = sc->load_stack + sc->file_i;

#if SHOW_ERROR_LINE
    sc->load_stack[sc->file_i].rep.stdio.curr_line = 0;
    if (fname)
      sc->load_stack[sc->file_i].rep.stdio.filename =
          store_string(sc, strlen(fname), fname);
#endif
  }
  return fin != 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x3f, 0xa90(%rax)
jne 0x12b52
movl $0x0, 0x24(%rsp)
jmp 0x12cc9
movq 0x10(%rsp), %rdi
leaq 0x4e9c(%rip), %rsi      # 0x179fa
callq 0x4230
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x12cb7
movq 0x18(%rsp), %rax
movl 0xa90(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa90(%rax)
movq 0x18(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x18(%rsp), %rcx
movslq 0xa90(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x11, (%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x18(%rsp), %rdx
movslq 0xa90(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x18(%rsp), %rcx
movslq 0xa90(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x1, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq 0xa90(%rcx), %rcx
movl $0x0, 0x990(%rax,%rcx,4)
movq 0x18(%rsp), %rcx
addq $0x190, %rcx            # imm = 0x190
movq 0x18(%rsp), %rax
movslq 0xa90(%rax), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x188(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x18(%rsp), %rcx
movslq 0xa90(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x14(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x12cb5
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x40a0
movq (%rsp), %rdi
movl %eax, %esi
movq 0x10(%rsp), %rdx
callq 0x4cc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x18(%rsp), %rdx
movslq 0xa90(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
jmp 0x12cb7
cmpq $0x0, 0x8(%rsp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: file_pop
static void file_pop(scheme * sc) {
  if (sc->file_i != 0) {
    sc->nesting = sc->nesting_stack[sc->file_i];
    port_close(sc, sc->loadport, port_input);
    sc->file_i--;
    sc->loadport->_object._port = sc->load_stack + sc->file_i;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0xa90(%rax)
je 0x131aa
movq (%rsp), %rax
movq (%rsp), %rcx
movslq 0xa90(%rcx), %rcx
movl 0x990(%rax,%rcx,4), %ecx
movq (%rsp), %rax
movl %ecx, 0xa94(%rax)
movq (%rsp), %rdi
movq (%rsp), %rax
movq 0x188(%rax), %rsi
movl $0x10, %edx
callq 0x138f0
movq (%rsp), %rax
movl 0xa90(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xa90(%rax)
movq (%rsp), %rcx
addq $0x190, %rcx            # imm = 0x190
movq (%rsp), %rax
movslq 0xa90(%rax), %rax
shlq $0x5, %rax
addq %rax, %rcx
movq (%rsp), %rax
movq 0x188(%rax), %rax
movq %rcx, 0x8(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xec0(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x131fa
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x132a6
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x4510
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xec8(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: syntaxnum
static int syntaxnum(pointer p) {
  const char *s = strvalue(car(p));
  switch (strlength(car(p))) {
  case 2:
    if (s[0] == 'i')
      return OP_IF0;            /* if */
    else
      return OP_OR0;            /* or */
  case 3:
    if (s[0] == 'a')
      return OP_AND0;           /* and */
    else
      return OP_LET0;           /* let */
  case 4:
    switch (s[3]) {
    case 'e':
      return OP_CASE0;          /* case */
    case 'd':
      return OP_COND0;          /* cond */
    case '*':
      return OP_LET0AST;        /* let* */
    default:
      return OP_SET0;           /* set! */
    }
  case 5:
    switch (s[2]) {
    case 'g':
      return OP_BEGIN;          /* begin */
    case 'l':
      return OP_DELAY;          /* delay */
    case 'c':
      return OP_MACRO0;         /* macro */
    default:
      return OP_QUOTE;          /* quote */
    }
  case 6:
    switch (s[2]) {
    case 'm':
      return OP_LAMBDA;         /* lambda */
    case 'f':
      return OP_DEF0;           /* define */
    default:
      return OP_LET0REC;        /* letrec */
    }
  default:
    return OP_C0STREAM;         /* cons-stream */
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rsp)
subl $0x4, %eax
ja 0x13846
movq -0x20(%rsp), %rax
leaq 0x3dc6(%rip), %rcx      # 0x174c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x69, %eax
jne 0x13725
movl $0x16, -0x4(%rsp)
jmp 0x1384e
movl $0x28, -0x4(%rsp)
jmp 0x1384e
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x1374c
movl $0x26, -0x4(%rsp)
jmp 0x1384e
movl $0x1a, -0x4(%rsp)
jmp 0x1384e
movq -0x18(%rsp), %rax
movsbl 0x3(%rax), %eax
movl %eax, -0x24(%rsp)
subl $0x2a, %eax
je 0x1379d
jmp 0x1376d
movl -0x24(%rsp), %eax
subl $0x64, %eax
je 0x13790
jmp 0x13778
movl -0x24(%rsp), %eax
subl $0x65, %eax
jne 0x137aa
jmp 0x13783
movl $0x2e, -0x4(%rsp)
jmp 0x1384e
movl $0x23, -0x4(%rsp)
jmp 0x1384e
movl $0x1d, -0x4(%rsp)
jmp 0x1384e
movl $0x18, -0x4(%rsp)
jmp 0x1384e
movq -0x18(%rsp), %rax
movsbl 0x2(%rax), %eax
movl %eax, -0x28(%rsp)
subl $0x63, %eax
je 0x137f5
jmp 0x137cb
movl -0x28(%rsp), %eax
subl $0x67, %eax
je 0x137e1
jmp 0x137d6
movl -0x28(%rsp), %eax
subl $0x6c, %eax
je 0x137eb
jmp 0x137ff
movl $0x15, -0x4(%rsp)
jmp 0x1384e
movl $0x25, -0x4(%rsp)
jmp 0x1384e
movl $0x2c, -0x4(%rsp)
jmp 0x1384e
movl $0x11, -0x4(%rsp)
jmp 0x1384e
movq -0x18(%rsp), %rax
movsbl 0x2(%rax), %eax
movl %eax, -0x2c(%rsp)
subl $0x66, %eax
je 0x13832
jmp 0x1381d
movl -0x2c(%rsp), %eax
subl $0x6d, %eax
jne 0x1383c
jmp 0x13828
movl $0xe, -0x4(%rsp)
jmp 0x1384e
movl $0x12, -0x4(%rsp)
jmp 0x1384e
movl $0x20, -0x4(%rsp)
jmp 0x1384e
movl $0x2a, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
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 0x49c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x6, (%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 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edx
xorl $-0x1, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x30, %eax
cmpl $0x0, %eax
jne 0x13985
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1397d
movq 0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1396f
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4090
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: skipspace
static INLINE int skipspace(scheme * sc) {
  int c = 0, curr_line = 0;

  do {
    c = inchar(sc);
#if SHOW_ERROR_LINE
    if (c == '\n')
      curr_line++;
#endif
  } while (isspace(c));

/* record it */
#if SHOW_ERROR_LINE
  if (sc->load_stack[sc->file_i].kind & port_file)
    sc->load_stack[sc->file_i].rep.stdio.curr_line += curr_line;
#endif

  if (c != EOF) {
    backchar(sc, c);
    return 1;
  } else {
    return EOF;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x13a70
movl %eax, 0x4(%rsp)
cmpl $0xa, 0x4(%rsp)
jne 0x139c6
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x139c8
callq 0x42e0
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x139a8
movq 0x8(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x8(%rsp), %rcx
movslq 0xa90(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13a33
movl (%rsp), %ecx
movq 0x8(%rsp), %rax
addq $0x190, %rax            # imm = 0x190
movq 0x8(%rsp), %rdx
movslq 0xa90(%rdx), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
cmpl $-0x1, 0x4(%rsp)
je 0x13a52
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x13b90
movl $0x1, 0x14(%rsp)
jmp 0x13a5a
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jl 0x13aa6
movq 0x18(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x13b23
movq 0x18(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x13ad5
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x13b23
movq 0x8(%rsp), %rdi
callq 0x13bb0
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x13b1b
movq 0x18(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x188(%rcx), %rax
jne 0x13b1b
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
orl $0x40, %ecx
movb %cl, (%rax)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x13b23
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $-0x1, -0x14(%rsp)
jne 0x13b4a
movl $0x1, -0x4(%rsp)
jmp 0x13b84
jmp 0x13b4c
movq -0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0x13b7c
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movsbl (%rax), %eax
cmpl -0x14(%rsp), %eax
jne 0x13b7a
movl $0x1, -0x4(%rsp)
jmp 0x13b84
jmp 0x13b4c
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: utf8_inchar
static int utf8_inchar(port *pt) {
  int c = basic_inchar(pt);
  int bytes, i;
  char buf[4];
  if (c == EOF || c < 0x80) {
    return c;
  }
  buf[0] = (char) c;
  bytes = (c < 0xE0) ? 2 : ((c < 0xF0) ? 3 : 4);
  for (i = 1; i < bytes; i++) {
    c = basic_inchar(pt);
    if (c == EOF) {
      return EOF;
    }
    buf[i] = (char) c;
  }
  return utf8_decode(buf);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x13c90
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
je 0x13bd8
cmpl $0x80, 0x14(%rsp)
jge 0x13be5
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x13c80
movl 0x14(%rsp), %eax
movb %al, 0x8(%rsp)
cmpl $0xe0, 0x14(%rsp)
jge 0x13c02
movl $0x2, %eax
movl %eax, 0x4(%rsp)
jmp 0x13c1d
movl 0x14(%rsp), %edx
movl $0x4, %eax
movl $0x3, %ecx
cmpl $0xf0, %edx
cmovll %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x13c72
movq 0x18(%rsp), %rdi
callq 0x13c90
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x13c56
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x13c80
movl 0x14(%rsp), %eax
movb %al, %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x8(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x13c2d
leaq 0x8(%rsp), %rdi
callq 0x8020
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13cbd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4110
movl %eax, 0x14(%rsp)
jmp 0x13d07
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x13ce2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x13cec
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x13d07
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rcx)
movsbl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x13d48
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x13dfc
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
xorl %ecx, %ecx
callq 0x4950
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x13ddd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
xorl %ecx, %ecx
callq 0x4950
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x13ddb
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x13d74
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
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: mk_continuation
static pointer mk_continuation(scheme * sc, pointer d) {
  pointer x = get_cell(sc, sc->NIL, d);

  typeflag(x) = T_CONTINUATION;
  cont_dump(x) = d;
  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 0x8(%rsp), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x7, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: round_per_R5RS
static double round_per_R5RS(double x) {
  double fl = floor(x);
  double ce = ceil(x);
  double dfl = x - fl;
  double dce = ce - x;
  if (dfl > dce) {
    return ce;
  } else if (dfl < dce) {
    return fl;
  } else {
    if (fmod(fl, 2.0) == 0.0) { /* I imagine this holds */
      return fl;
    } else {
      return ce;
    }
  }
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x4250
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x42b0
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x13ecc
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x13f24
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13eec
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x13f24
movsd 0x20(%rsp), %xmm0
movsd 0x37b6(%rip), %xmm1     # 0x176b0
callq 0x4130
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x13f18
jp 0x13f18
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x13f24
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: num_add
static num num_add(num a, num b) {
  num ret;
  ret.is_fixnum = a.is_fixnum && b.is_fixnum;
  if (ret.is_fixnum) {
    ret.value.ivalue = a.value.ivalue + b.value.ivalue;
  } else {
    ret.value.rvalue = num_rvalue(a) + num_rvalue(b);
  }
  return ret;
}

// Assembly:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x20(%rsp)
movq %rsi, -0x18(%rsp)
movb %al, -0x30(%rsp)
movq %rcx, -0x28(%rsp)
movsbl -0x20(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rsp)
je 0x13f66
movsbl -0x30(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rsp)
movb -0x31(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x10(%rsp)
cmpb $0x0, -0x10(%rsp)
je 0x13f8b
movq -0x18(%rsp), %rax
addq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x13ff1
cmpb $0x0, -0x20(%rsp)
jne 0x13fa0
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
jmp 0x13fad
cvtsi2sdq -0x18(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x40(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
cmpb $0x0, -0x30(%rsp)
jne 0x13fce
movsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x50(%rsp)
jmp 0x13fdb
cvtsi2sdq -0x28(%rsp), %xmm0
movsd %xmm0, -0x50(%rsp)
movsd -0x48(%rsp), %xmm0
movsd -0x50(%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movb -0x10(%rsp), %al
movq -0x8(%rsp), %rdx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_number
static pointer mk_number(scheme * sc, num n) {
  if (n.is_fixnum) {
    return mk_integer(sc, n.value.ivalue);
  } else {
    return mk_real(sc, n.value.rvalue);
  }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movb %al, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
cmpb $0x0, 0x10(%rsp)
je 0x14032
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4b00
movq %rax, 0x20(%rsp)
jmp 0x14047
movq 0x8(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x4b60
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: num_div
static num num_div(num a, num b) {
  num ret;
  ret.is_fixnum =
      a.is_fixnum && b.is_fixnum
      && b.value.ivalue != 0 && a.value.ivalue % b.value.ivalue == 0;
  if (ret.is_fixnum) {
    ret.value.ivalue = a.value.ivalue / b.value.ivalue;
  } else {
    ret.value.rvalue = num_rvalue(a) / num_rvalue(b);
  }
  return ret;
}

// Assembly:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x20(%rsp)
movq %rsi, -0x18(%rsp)
movb %al, -0x30(%rsp)
movq %rcx, -0x28(%rsp)
movsbl -0x20(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rsp)
je 0x1425c
movsbl -0x30(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rsp)
je 0x1425c
xorl %eax, %eax
cmpq $0x0, -0x28(%rsp)
movb %al, -0x31(%rsp)
je 0x1425c
movq -0x18(%rsp), %rax
cqto
idivq -0x28(%rsp)
cmpq $0x0, %rdx
sete %al
movb %al, -0x31(%rsp)
movb -0x31(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x10(%rsp)
cmpb $0x0, -0x10(%rsp)
je 0x14283
movq -0x18(%rsp), %rax
cqto
idivq -0x28(%rsp)
movq %rax, -0x8(%rsp)
jmp 0x142e9
cmpb $0x0, -0x20(%rsp)
jne 0x14298
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
jmp 0x142a5
cvtsi2sdq -0x18(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x40(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
cmpb $0x0, -0x30(%rsp)
jne 0x142c6
movsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x50(%rsp)
jmp 0x142d3
cvtsi2sdq -0x28(%rsp), %xmm0
movsd %xmm0, -0x50(%rsp)
movsd -0x48(%rsp), %xmm0
movsd -0x50(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rsp)
movb -0x10(%rsp), %al
movq -0x8(%rsp), %rdx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: num_rem
static num num_rem(num a, num b) {
  num ret;
  long e1, e2, res;
  ret.is_fixnum = a.is_fixnum && b.is_fixnum;
  e1 = num_ivalue(a);
  e2 = num_ivalue(b);
  res = e1 % e2;
  /* remainder should have same sign as first operand */
  if (res > 0) {
    if (e1 < 0) {
      res -= labs(e2);
    }
  } else if (res < 0) {
    if (e1 > 0) {
      res += labs(e2);
    }
  }
  if (ret.is_fixnum) {
    ret.value.ivalue = res;
  } else {
    ret.value.rvalue = res;
  }
  return ret;
}

// Assembly:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x20(%rsp)
movq %rsi, -0x18(%rsp)
movb %al, -0x30(%rsp)
movq %rcx, -0x28(%rsp)
movsbl -0x20(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rsp)
je 0x14336
movsbl -0x30(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x49(%rsp)
movb -0x49(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x10(%rsp)
movsbl -0x20(%rsp), %eax
cmpl $0x0, %eax
je 0x14359
movq -0x18(%rsp), %rax
movq %rax, -0x58(%rsp)
jmp 0x14365
cvttsd2si -0x18(%rsp), %rax
movq %rax, -0x58(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x38(%rsp)
movsbl -0x30(%rsp), %eax
cmpl $0x0, %eax
je 0x14385
movq -0x28(%rsp), %rax
movq %rax, -0x60(%rsp)
jmp 0x14391
cvttsd2si -0x28(%rsp), %rax
movq %rax, -0x60(%rsp)
movq -0x60(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cqto
idivq -0x40(%rsp)
movq %rdx, -0x48(%rsp)
cmpq $0x0, -0x48(%rsp)
jle 0x143da
cmpq $0x0, -0x38(%rsp)
jge 0x143d8
movq -0x40(%rsp), %rcx
movq %rcx, %rax
negq %rax
cmovnsq %rax, %rcx
movq -0x48(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x48(%rsp)
jmp 0x14407
cmpq $0x0, -0x48(%rsp)
jge 0x14405
cmpq $0x0, -0x38(%rsp)
jle 0x14403
movq -0x40(%rsp), %rax
movq %rax, %rcx
negq %rcx
cmovnsq %rcx, %rax
addq -0x48(%rsp), %rax
movq %rax, -0x48(%rsp)
jmp 0x14405
jmp 0x14407
cmpb $0x0, -0x10(%rsp)
je 0x1441a
movq -0x48(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x14427
cvtsi2sdq -0x48(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movb -0x10(%rsp), %al
movq -0x8(%rsp), %rdx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: num_mod
static num num_mod(num a, num b) {
  num ret;
  long e1, e2, res;
  ret.is_fixnum = a.is_fixnum && b.is_fixnum;
  e1 = num_ivalue(a);
  e2 = num_ivalue(b);
  res = e1 % e2;
  /* modulo should have same sign as second operand */
  if ((res < 0) != (e2 < 0) && res) {
    res += e2;
  }
  if (ret.is_fixnum) {
    ret.value.ivalue = res;
  } else {
    ret.value.rvalue = res;
  }
  return ret;
}

// Assembly:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x20(%rsp)
movq %rsi, -0x18(%rsp)
movb %al, -0x30(%rsp)
movq %rcx, -0x28(%rsp)
movsbl -0x20(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rsp)
je 0x14476
movsbl -0x30(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x49(%rsp)
movb -0x49(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x10(%rsp)
movsbl -0x20(%rsp), %eax
cmpl $0x0, %eax
je 0x14499
movq -0x18(%rsp), %rax
movq %rax, -0x58(%rsp)
jmp 0x144a5
cvttsd2si -0x18(%rsp), %rax
movq %rax, -0x58(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x38(%rsp)
movsbl -0x30(%rsp), %eax
cmpl $0x0, %eax
je 0x144c5
movq -0x28(%rsp), %rax
movq %rax, -0x60(%rsp)
jmp 0x144d1
cvttsd2si -0x28(%rsp), %rax
movq %rax, -0x60(%rsp)
movq -0x60(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x38(%rsp), %rax
cqto
idivq -0x40(%rsp)
movq %rdx, -0x48(%rsp)
cmpq $0x0, -0x48(%rsp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x40(%rsp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x14524
cmpq $0x0, -0x48(%rsp)
je 0x14524
movq -0x40(%rsp), %rax
addq -0x48(%rsp), %rax
movq %rax, -0x48(%rsp)
cmpb $0x0, -0x10(%rsp)
je 0x14537
movq -0x48(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x14544
cvtsi2sdq -0x48(%rsp), %xmm0
movsd %xmm0, -0x8(%rsp)
movb -0x10(%rsp), %al
movq -0x8(%rsp), %rdx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdi
shlq $0x2, %rdi
callq *%rax
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %ecx
andl $0x7fffff, %ecx         # imm = 0x7FFFFF
shll $0x8, %ecx
orl $0x80000080, %ecx       # imm = 0x80000080
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x153be
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %edx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15387
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_bvector
INTERFACE static pointer mk_bvector(scheme * sc, int len, int val) {
  char *s;
  pointer x = get_cell(sc, sc->NIL, sc->NIL);
  typeflag(x) = (T_BYTEVECTOR | T_ATOM);
  s = (char*) sc->malloc(len);
  if (val >= 0) {
    memset(s, val, len);
  }
  strvalue(x) = s;
  strlength(x) = len;
  return x;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x400f, (%rax)         # imm = 0x400F
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x1c(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x18(%rsp)
jl 0x15464
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
movslq 0x1c(%rsp), %rdx
movzbl %al, %esi
callq 0x4100
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: string_to_utf8
static void string_to_utf8(scheme * sc, char *s, int len) {
  int i, c, d, charsize;
  char *q = sc->strbuff;
  if (IS_ASCII(*s)) {
    charsize = 1;
  } else {
    charsize = 4;
    s += 4;
  }
  for (i = 0; i < len; i++) {
    if (charsize == 1) {
      c = *s++;
    } else {
      c = *((int*) s);
      s += 4;
    }
    if (check_strbuff_size(sc, &q)) {
      if (c != 0) {
        char_to_utf8(c, q, &d);
        q += d;
      } else {
        *q++ = (char) 0xC0;
        *q++ = (char) 0x80;
      }
    }
  }
  *q = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0xea0(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
andl $-0x80, %eax
cmpl $0x0, %eax
jne 0x154cd
movl $0x1, 0x14(%rsp)
jmp 0x154e3
movl $0x4, 0x14(%rsp)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x155b3
cmpl $0x1, 0x14(%rsp)
jne 0x1551a
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rsp)
movsbl (%rax), %eax
movl %eax, 0x1c(%rsp)
jmp 0x15533
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x159b0
cmpl $0x0, %eax
je 0x155a1
cmpl $0x0, 0x1c(%rsp)
je 0x15577
movl 0x1c(%rsp), %edi
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x15830
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x1559f
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $-0x40, (%rax)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $-0x80, (%rax)
jmp 0x155a1
jmp 0x155a3
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x154eb
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
jl 0x1585d
cmpl $0x10ffff, 0x24(%rsp)   # imm = 0x10FFFF
jle 0x15865
movl $0x3f, 0x24(%rsp)
cmpl $0x80, 0x24(%rsp)
jge 0x15895
movl 0x24(%rsp), %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
jmp 0x15942
cmpl $0x800, 0x24(%rsp)      # imm = 0x800
jge 0x158a9
movl $0x2, %eax
movl %eax, (%rsp)
jmp 0x158c3
movl 0x24(%rsp), %edx
movl $0x4, %eax
movl $0x3, %ecx
cmpl $0x10000, %edx          # imm = 0x10000
cmovll %ecx, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movb $-0x80, (%rax)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
je 0x1592f
movl 0x4(%rsp), %ecx
movl $0x80, %edx
sarl %cl, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movl 0x24(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %dl
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x24(%rsp), %eax
sarl $0x6, %eax
movl %eax, 0x24(%rsp)
jmp 0x158e0
movl 0x24(%rsp), %eax
movzbl %al, %edx
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
movq 0x18(%rsp), %rdi
callq 0x40a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: procname
static const char *procname(pointer x) {
  int n = procnum(x);
  const char *name = dispatch_table[n].name;
  if (name == 0) {
    name = "ILLEGAL!";
  }
  return name;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4510
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x581d(%rip), %rax      # 0x1b1a0
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x159a4
leaq 0x2ae4(%rip), %rax      # 0x18484
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: check_strbuff_size
static int check_strbuff_size(scheme * sc, char **p) {
  char *t;
  int len = *p - sc->strbuff;
  if (len + 4 < sc->strbuff_size) {
    return 1;
  }
  sc->strbuff_size *= 2;
  if (sc->strbuff_size >= STRBUFF_MAX_SIZE) {
    sc->strbuff_size /= 2;
    return 0;
  }
  t = sc->malloc(sc->strbuff_size);
  memcpy(t, sc->strbuff, len);
  *p = t + len;
  sc->free(sc->strbuff);
  sc->strbuff = t;
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movq 0xea0(%rcx), %rcx
subq %rcx, %rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x4, %eax
movq 0x28(%rsp), %rcx
cmpl 0xea8(%rcx), %eax
jge 0x159fa
movl $0x1, 0x34(%rsp)
jmp 0x15ac8
movq 0x28(%rsp), %rax
movl 0xea8(%rax), %ecx
shll %ecx
movl %ecx, 0xea8(%rax)
movq 0x28(%rsp), %rax
cmpl $0x10000, 0xea8(%rax)   # imm = 0x10000
jl 0x15a4d
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xea8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xea8(%rax)
movl $0x0, 0x34(%rsp)
jmp 0x15ac8
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0xea8(%rcx), %rdi
callq *%rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xea0(%rax), %rsi
movslq 0x14(%rsp), %rdx
callq 0x41b0
movq 0x18(%rsp), %rcx
movslq 0x14(%rsp), %rax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0xea0(%rcx), %rdi
callq *%rax
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xea0(%rax)
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)