LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/tests/bch.c
// Function: test_properties
static void test_properties(const struct bch_def *def,
			    const uint8_t *block)
{
	int i;

	i = bch_verify(def, block, BCH_CHUNK_SIZE, block + BCH_CHUNK_SIZE);
	assert(!i);

	for (i = 0; i < 20; i++)
		flip_test(def, block);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x200(%rsi), %rcx
movl $0x200, %edx            # imm = 0x200
callq 0x11fc
testl %eax, %eax
jne 0x1a54
xorl %ebp, %ebp
movq %rsp, %r12
movabsq $0xfc0fc0fc0fc0fc1, %r13 # imm = 0xFC0FC0FC0FC0FC1
movl $0x208, %edx            # imm = 0x208
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1070
cmpl $0x0, (%r14)
jle 0x1997
xorl %r15d, %r15d
callq 0x1080
movq %rax, %rcx
imulq %r13
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x8, %rdx
addq %rax, %rdx
imulq $0x1040, %rdx, %rax     # imm = 0x1040
subq %rax, %rcx
movl %ecx, %eax
sarl $0x3, %eax
andb $0x7, %cl
movl $0x1, %edx
shll %cl, %edx
cltq
xorb %dl, (%rsp,%rax)
addl $0x2, %r15d
cmpl (%r14), %r15d
jl 0x1957
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
leaq 0x200(%rsp), %rcx
callq 0x11fc
testl %eax, %eax
jns 0x19e5
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
leaq 0x200(%rsp), %r15
movq %r15, %rcx
callq 0x1289
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0x11fc
testl %eax, %eax
jne 0x1a35
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1090
testl %eax, %eax
jne 0x1a16
incl %ebp
cmpl $0x14, %ebp
jne 0x193e
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x865e(%rip), %rdi      # 0xa07b
leaq 0x865a(%rip), %rsi      # 0xa07e
leaq 0x869d(%rip), %rcx      # 0xa0c8
movl $0x35, %edx
callq 0x1050
leaq 0x863f(%rip), %rdi      # 0xa07b
leaq 0x863b(%rip), %rsi      # 0xa07e
leaq 0x867e(%rip), %rcx      # 0xa0c8
movl $0x31, %edx
callq 0x1050
leaq 0x8620(%rip), %rdi      # 0xa07b
leaq 0x861c(%rip), %rsi      # 0xa07e
leaq 0x8621(%rip), %rcx      # 0xa08a
movl $0x3e, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_02/escape.c
// Function: main
int main(void)
{
  char src[MAXLEN];
  char dest[MAXLEN];

  get_line(src, MAXLEN);
  printf("%s", src);

  escape(dest, src);
  printf("%s\n", dest);

  unescape(dest, src);
  printf("%s", dest);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x7e0, %rsp            # imm = 0x7E0
leaq 0x3f0(%rsp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11ce
leaq 0xedc(%rip), %r14       # 0x2060
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x122c
movq %r15, %rdi
callq 0x1030
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12ac
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_02/escape.c
// Function: get_line
int get_line(char line[], unsigned int limit)
{
  int i, c;
  for (i = 0; i < limit - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
decl %ebp
je 0x120c
movl %ebp, %r15d
xorl %r14d, %r14d
callq 0x1050
cmpl $-0x1, %eax
je 0x1201
cmpl $0xa, %eax
je 0x1201
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x11e4
jmp 0x1204
movl %r14d, %ebp
cmpl $0xa, %eax
sete %al
jmp 0x120e
xorl %ebp, %ebp
testb $0x1, %al
je 0x121a
movl %ebp, %eax
incl %ebp
movb $0xa, (%rbx,%rax)
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/readpass_file/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * filename;
	char * passwd;

	WARNP_INIT;

	/* Process arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_readpass_file FILENAME\n");
		goto err0;
	}
	filename = argv[1];

	/* Read passphrase. */
	if (readpass_file(&passwd, filename))
		goto err0;

	/* Print passphrase. */
	printf("%s\n", passwd);

	/* Clean up. */
	insecure_memzero(passwd, strlen(passwd));
	free(passwd);

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x13e1
callq 0x1670
cmpl $0x2, %ebp
je 0x1410
movq 0x2c0b(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xc0d(%rip), %rdi       # 0x2004
movl $0x23, %esi
movl $0x1, %edx
callq 0x1180
movl $0x1, %edi
callq 0x1170
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x146c
testl %eax, %eax
jne 0x1406
movq (%rsp), %rdi
callq 0x1070
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x10b0
leaq 0x2cac(%rip), %rcx      # 0x40e8
movq (%rcx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *%rcx
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1170
nop
// File: /workspace/github_c_makefile_star2_O1/ryancdotorg[P]bloomslice/pcalc.c
// Function: log2i
uint8_t log2i(uint64_t v) {
    static const uint64_t b[] = {
        0xaaaaaaaaaaaaaaaa,
        0xcccccccccccccccc,
        0xf0f0f0f0f0f0f0f0,
        0xff00ff00ff00ff00,
        0xffff0000ffff0000,
        0xffffffff00000000
    };
    register uint64_t r = (v & b[0]) != 0;
    r |= ((v & b[5]) != 0) << 5;
    r |= ((v & b[4]) != 0) << 4;
    r |= ((v & b[3]) != 0) << 3;
    r |= ((v & b[2]) != 0) << 2;
    r |= ((v & b[1]) != 0) << 1;
    return r;
}

// Assembly:
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
testq %rax, %rdi
setne %al
movq %rdi, %rcx
shrq $0x20, %rcx
setne %cl
shlb $0x5, %cl
orb %al, %cl
movabsq $-0xffff00010000, %rax  # imm = 0xFFFF0000FFFF0000
testq %rax, %rdi
setne %al
shlb $0x4, %al
orb %cl, %al
movabsq $-0xff00ff00ff0100, %rcx # imm = 0xFF00FF00FF00FF00
testq %rcx, %rdi
setne %cl
shlb $0x3, %cl
orb %al, %cl
movabsq $-0xf0f0f0f0f0f0f10, %rax # imm = 0xF0F0F0F0F0F0F0F0
testq %rax, %rdi
setne %dl
shlb $0x2, %dl
orb %cl, %dl
movabsq $-0x3333333333333334, %rax # imm = 0xCCCCCCCCCCCCCCCC
testq %rax, %rdi
setne %al
addb %al, %al
orb %dl, %al
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: is_integer
int is_integer(pointer p) {
  if (!is_number(p))
    return 0;
  if (num_is_integer(p) || (double) ivalue(p) == rvalue(p))
    return 1;
  return 0;
}

// Assembly:
movl (%rdi), %ecx
andl $0x1f, %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
jne 0x44db
movl $0x1, %eax
cmpb $0x0, 0x8(%rdi)
je 0x44dc
retq
movsd 0x10(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
jne 0x44f3
jnp 0x44db
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
callq 0x4689
xorl %ecx, %ecx
testl %ebx, %ebx
setne %cl
shll $0xd, %ecx
orl $0x5, %ecx
movl %ecx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x644c
movq %rax, %r12
movl $0x5, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0x90(%r15), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x644c
movl $0x2005, (%rax)         # imm = 0x2005
movq %r12, 0x8(%rax)
movq 0x70(%r15), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x70(%r15), %rcx
movq %rax, 0x8(%rcx)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rbx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4689
movl $0x4008, (%rax)         # imm = 0x4008
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl %esi, %ebx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4689
movl $0x4009, (%rax)         # imm = 0x4009
movslq %ebx, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rbx
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4689
movl $0x4002, (%rax)         # imm = 0x4002
movq %rbx, 0x10(%rax)
movb $0x1, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rax
movsd %xmm0, (%rsp)
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4689
movl $0x4002, (%rax)         # imm = 0x4002
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movb $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
movq 0x90(%rdi), %rdx
movq %rdx, %rsi
callq 0x4689
movq %rax, %r14
movl $0x4001, (%rax)         # imm = 0x4001
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x4803
movq %rax, 0x8(%r14)
cmpb $0x0, (%rax)
jns 0x47f0
movl (%rax), %ebx
shrl $0x8, %ebx
andl $0x7fffff, %ebx         # imm = 0x7FFFFF
movl %ebx, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: store_string
static char *store_string(scheme * sc, int len, const char *str) {
  char *q;
  const char *end;
  int char_size = 1;
  int i;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r12
testl %esi, %esi
setg %bpl
jle 0x4842
cmpb $0x0, (%rbx)
js 0x4849
movl %r15d, %ecx
movl $0x1, %eax
movq %rax, %rdx
cmpq %rax, %rcx
je 0x4850
leaq 0x1(%rdx), %rax
cmpb $0x0, (%rbx,%rdx)
jns 0x4829
movl $0x4, %eax
jmp 0x4855
movl $0x1, %eax
jmp 0x485c
movl $0x4, %eax
jmp 0x485c
movl $0x1, %eax
cmpq %rcx, %rdx
setb %bpl
leal 0x1(%r15), %ecx
imull %eax, %ecx
movslq %ecx, %rdi
callq *(%r12)
testq %rax, %rax
je 0x48cc
movq %rax, %r14
testq %rbx, %rbx
je 0x48fc
movslq %r15d, %r12
testb %bpl, %bpl
je 0x48df
testl %r15d, %r15d
jle 0x48f4
addq %rbx, %r12
movl $0x1, %ebp
movb (%rbx), %al
testb %al, %al
sets %cl
andb $-0x20, %al
cmpb $-0x40, %al
setne %al
testb %al, %cl
jne 0x48b3
movq %rbx, %rdi
callq 0x64fa
movslq %ebp, %rcx
incl %ebp
movl %eax, (%r14,%rcx,4)
incq %rbx
cmpq %r12, %rbx
jb 0x4890
shll $0x8, %ebp
addl $0x7fffff00, %ebp       # imm = 0x7FFFFF00
orl $0x80000080, %ebp       # imm = 0x80000080
jmp 0x48f9
movb $0x1, 0xa99(%r12)
movq 0xea0(%r12), %r14
jmp 0x48fc
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x41d0
movb $0x0, (%r14,%r12)
jmp 0x48fc
movl $0x80000080, %ebp       # imm = 0x80000080
movl %ebp, (%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: mk_symbol
INTERFACE pointer mk_symbol(scheme * sc, const char *name) {
  pointer x;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xf8(%rdi), %rcx
movl 0x10(%rcx), %esi
movb (%rbx), %dl
testb %dl, %dl
je 0x496f
leaq 0x1(%rbx), %r8
xorl %eax, %eax
roll $0x5, %eax
movsbl %dl, %edx
xorl %edx, %eax
movb (%r8), %dl
incq %r8
testb %dl, %dl
jne 0x495b
jmp 0x4971
xorl %eax, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
andl $0x1, %edx
movq 0x90(%rdi), %r15
movq 0x20(%rax,%rdx,8), %r12
cmpq %r15, %r12
je 0x49bc
movq 0x8(%r12), %r14
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x41a0
testl %eax, %eax
je 0x49bf
movq 0x10(%r12), %r12
jmp 0x4997
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: oblist_add_by_name
static pointer oblist_add_by_name(scheme * sc, const char *name) {
  pointer x;
  int location;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x40c0
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x47a7
movq %rax, %r12
movq 0x90(%rbx), %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x4689
movq %rax, %r14
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movl $0x3, (%rax)
orb $0x20, 0x1(%r12)
movq 0xf8(%rbx), %rcx
movq 0x10(%rcx), %rsi
movb (%r15), %dl
testb %dl, %dl
je 0x4a4c
incq %r15
xorl %eax, %eax
roll $0x5, %eax
movsbl %dl, %edx
xorl %edx, %eax
movb (%r15), %dl
incq %r15
testb %dl, %dl
jne 0x4a38
jmp 0x4a4e
xorl %eax, %eax
xorl %edx, %edx
divl %esi
movl %edx, %r15d
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %r13
andl $0x1, %r15d
movq 0x20(%r13,%r15,8), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4689
movl $0x2005, (%rax)         # imm = 0x2005
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x20(%r13,%r15,8)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: gensym
INTERFACE pointer gensym(scheme * sc) {
  pointer x;
  char name[40];

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

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

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

  return sc->NIL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
movq 0xed8(%rdi), %rcx
cmpq %r12, %rcx
je 0x4b09
leaq 0x89ce(%rip), %r14      # 0xd498
movq %rsp, %r15
movl $0x28, %esi
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x40e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x493a
cmpq 0x90(%rbx), %rax
je 0x4b12
movq 0xed8(%rbx), %rcx
incq %rcx
movq %rcx, 0xed8(%rbx)
cmpq %r12, %rcx
jne 0x4acd
movq 0x90(%rbx), %rax
jmp 0x4b1d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x49ce
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: putstr
INTERFACE void putstr(scheme * sc, const char *s) {
  port *pt = sc->outport->_object._port;
  if (pt->kind & port_file) {
    fputs(s, pt->rep.stdio.file);
  } else {
    for (; *s; s++) {
      if (pt->rep.string.curr != pt->rep.string.past_the_end) {
        *pt->rep.string.curr++ = *s;
      } else if (pt->kind & port_srfi6 && realloc_port_string(sc, pt)) {
        *pt->rep.string.curr++ = *s;
      }
    }
  }
}

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

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

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

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
jns 0x4ca6
movb $0x2d, (%rsi)
incq %rsi
negq %rax
movq %rsi, %rcx
testq %rax, %rax
jne 0x4cb5
leaq 0x1(%rsi), %rcx
movb $0x30, (%rsi)
testq %rax, %rax
jle 0x4ce3
movslq %edx, %rdi
movl $0x30, %r8d
cqto
idivq %rdi
cmpb $0xa, %dl
movl $0x37, %r9d
cmovll %r8d, %r9d
addb %dl, %r9b
movb %r9b, (%rcx)
incq %rcx
testq %rax, %rax
jg 0x4cc3
movb $0x0, (%rcx)
decq %rcx
cmpq %rsi, %rcx
jbe 0x4d0a
incq %rsi
movb -0x1(%rsi), %al
movb (%rcx), %dl
movb %dl, -0x1(%rsi)
movb %al, (%rcx)
decq %rcx
leaq 0x1(%rsi), %rax
cmpq %rsi, %rcx
movq %rax, %rsi
ja 0x4cf1
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: eqv
int eqv(pointer a, pointer b) {
  if (is_string(a)) {
    if (is_string(b))
      return (strvalue(a) == strvalue(b));
    else
      return (0);
  } else if (is_number(a)) {
    if (is_number(b)) {
      if (num_is_integer(a) == num_is_integer(b))
        return num_eq(nvalue(a), nvalue(b));
    }
    return (0);
  } else if (is_character(a)) {
    if (is_character(b))
      return charvalue(a) == charvalue(b);
    else
      return (0);
  } else if (is_port(a)) {
    if (is_port(b))
      return a == b;
    else
      return (0);
  } else if (is_proc(a)) {
    if (is_proc(b))
      return procnum(a) == procnum(b);
    else
      return (0);
  } else {
    return (a == b);
  }
}

// Assembly:
movl (%rdi), %eax
andl $0x1f, %eax
decl %eax
cmpl $0x9, %eax
ja 0x4d3e
leaq 0x82ea(%rip), %rcx      # 0xd008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x1, %eax
jne 0x4da5
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x4dd9
cmpq %rsi, %rdi
jmp 0x4dd9
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x4, %eax
jne 0x4da5
cmpb $0x0, 0x8(%rdi)
je 0x4dbe
movq 0x10(%rdi), %rax
jmp 0x4dc4
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x2, %eax
jne 0x4da5
movb 0x8(%rdi), %r8b
movb 0x8(%rsi), %cl
cmpb %cl, %r8b
jne 0x4da5
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rax
testb %r8b, %r8b
sete %sil
testb %cl, %cl
sete %dil
orb %sil, %dil
jne 0x4de0
cmpq %rax, %rdx
jmp 0x4dd9
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x9, %eax
jne 0x4da5
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x4dd9
xorl %eax, %eax
jmp 0x4ddc
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0xa, %eax
sete %cl
cmpq %rsi, %rdi
sete %al
andb %cl, %al
jmp 0x4ddc
cvttsd2si 0x10(%rdi), %rax
cmpb $0x0, 0x8(%rsi)
je 0x4dd0
movq 0x10(%rsi), %rcx
jmp 0x4dd6
cvttsd2si 0x10(%rsi), %rcx
cmpq %rcx, %rax
sete %al
movzbl %al, %eax
retq
testb %r8b, %r8b
je 0x4dec
cvtsi2sd %rdx, %xmm0
jmp 0x4df1
movq %rdx, %xmm0
testb %cl, %cl
je 0x4dfc
cvtsi2sd %rax, %xmm1
jmp 0x4e01
movq %rax, %xmm1
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x4ddc
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: num_eq
static int num_eq(num a, num b) {
  int ret;
  int is_fixnum = a.is_fixnum && b.is_fixnum;
  if (is_fixnum) {
    ret = a.value.ivalue == b.value.ivalue;
  } else {
    ret = num_rvalue(a) == num_rvalue(b);
  }
  return ret;
}

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

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

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

// Assembly:
movq 0x90(%rdi), %rcx
xorl %eax, %eax
movq %rsi, %rdx
cmpq %rcx, %rdx
je 0x4ea2
movl (%rdx), %edi
andl $0x1f, %edi
cmpl $0x5, %edi
jne 0x4ea3
movq 0x10(%rdx), %rdx
cmpq %rcx, %rdx
je 0x4eaa
movl (%rdx), %edi
andl $0x1f, %edi
cmpl $0x5, %edi
jne 0x4ead
addl $0x2, %eax
movq 0x10(%rdx), %rdx
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdx
jne 0x4e6b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x4eb2
incl %eax
retq
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
subl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_init_new
scheme *scheme_init_new() {
  scheme *sc = (scheme *) malloc(sizeof(scheme));
  if (!scheme_init(sc)) {
    free(sc);
    return 0;
  } else {
    return sc;
  }
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xef8, %edi            # imm = 0xEF8
callq *%r15
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4f3a
testl %eax, %eax
jne 0x4f31
movq %rbx, %rdi
callq *%r14
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: new_frame_in_env
static void new_frame_in_env(scheme * sc, pointer old_env) {
  pointer new_frame;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %edi
callq *(%r14)
testq %rax, %rax
je 0x55a6
movq %rax, %rbx
orb $0x1, %bpl
movb %bpl, (%rax)
movq %r15, 0x8(%rax)
movl $0x0, 0x10(%rax)
jmp 0x55a8
xorl %ebx, %ebx
movq 0x90(%r14), %rax
testq %rbx, %rbx
je 0x55cc
movq %r14, %rdi
movq %rax, %rsi
movq %rax, %rdx
callq 0x4689
movl $0x400a, (%rax)         # imm = 0x400A
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: port_from_string
static pointer port_from_string(scheme * sc, char *start, char *past_the_end,
    int prop) {
  port *pt;
  pt = port_rep_from_string(sc, start, past_the_end, prop);
  if (pt == 0) {
    return sc->NIL;
  }
  return mk_port(sc, pt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x20, %edi
callq *(%r14)
testq %rax, %rax
je 0x5626
movq %rax, %rbx
orb $0x2, %bpl
movb %bpl, (%rax)
movq %r12, 0x8(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x10(%rax)
jmp 0x5628
xorl %ebx, %ebx
movq 0x90(%r14), %rax
testq %rbx, %rbx
je 0x564c
movq %r14, %rdi
movq %rax, %rsi
movq %rax, %rdx
callq 0x4689
movl $0x400a, (%rax)         # imm = 0x400A
movq %rbx, 0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_deinit
void scheme_deinit(scheme * sc) {
  int i;

#if SHOW_ERROR_LINE
  char *fname;
#endif

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0x170(%rdi), %rcx
movq %rax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqu %xmm0, 0x40(%rdi)
movdqu %xmm0, 0x30(%rdi)
movq %rax, 0xec0(%rdi)
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x56da
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x170(%rbx)
movq %rax, 0x178(%rbx)
movq 0x180(%rbx), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x56ff
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x180(%rbx)
movq 0x188(%rbx), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x571d
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x188(%rbx)
movq 0xea0(%rbx), %rdi
callq *0x8(%rbx)
movb $0x0, 0xa98(%rbx)
movq 0x90(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x57bc
cmpl $0x0, 0x28(%rbx)
js 0x576c
movq $-0x1, %r14
movq 0x18(%rbx), %rax
movq 0x8(%rax,%r14,8), %rdi
callq *0x8(%rbx)
movslq 0x28(%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0x5754
movq 0x20(%rbx), %rdi
callq *0x8(%rbx)
movq 0x18(%rbx), %rdi
callq *0x8(%rbx)
cmpl $0x0, 0xa90(%rbx)
js 0x57b6
leaq 0x1a8(%rbx), %r14
movq $-0x1, %r15
testb $0x1, -0x18(%r14)
je 0x57a3
movq (%r14), %rdi
testq %rdi, %rdi
je 0x57a3
callq *0x8(%rbx)
movslq 0xa90(%rbx), %rax
incq %r15
addq $0x20, %r14
cmpq %rax, %r15
jl 0x5791
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x5af1
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x90(%rdi), %rdx
movq 0x100(%rdi), %rax
movq %rdx, 0x48(%rdi)
movq %rax, 0x38(%rdi)
xorl %ebp, %ebp
movl %ebp, 0xa90(%rdi)
leaq 0x190(%rdi), %r12
movb $0x11, 0x190(%rdi)
movq %rsi, 0x198(%rdi)
movq %rdx, %rsi
callq 0x4689
movl $0x400a, (%rax)         # imm = 0x400A
movq %r12, 0x8(%rax)
movq %rax, 0x188(%rbx)
movl %ebp, 0x10(%rbx)
movq 0xd599(%rip), %rax      # 0x12fd0
movq (%rax), %r12
cmpq %r15, %r12
jne 0x5a59
leaq 0x7b34(%rip), %rsi      # 0xd57a
movq %r14, %rdi
callq 0x41a0
testl %eax, %eax
je 0x5a59
movl $0x1, 0x50(%rbx)
movl $0x0, 0x1a4(%rbx)
cmpq %r15, %r12
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x5a8a
movq %r14, %rdi
callq 0x40c0
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x4803
jmp 0x5a8c
xorl %eax, %eax
movq %rax, 0x1a8(%rbx)
movslq 0xa90(%rbx), %r14
movq 0x90(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4689
movl $0x4002, (%rax)         # imm = 0x4002
movq %r14, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x5af8
movq 0x188(%rbx), %rax
movl $0x4000, (%rax)         # imm = 0x4000
cmpl $0x0, 0x10(%rbx)
jne 0x5ae8
xorl %eax, %eax
cmpl $0x0, 0xa94(%rbx)
setne %al
movl %eax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x4330
jmp 0x5ae8
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_load_string
void scheme_load_string(scheme * sc, const char *cmd) {
  dump_stack_reset(sc);
  sc->envir = sc->global_env;
  sc->file_i = 0;
  sc->load_stack[0].kind = port_input | port_string;
  sc->load_stack[0].rep.string.start = (char *) cmd;    /* This func respects const */
  sc->load_stack[0].rep.string.past_the_end = (char *) cmd + strlen(cmd);
  sc->load_stack[0].rep.string.curr = (char *) cmd;
  sc->loadport = mk_port(sc, sc->load_stack);
  sc->retcode = 0;
  sc->interactive_repl = 0;
  sc->args = mk_integer(sc, sc->file_i);
  Eval_Cycle(sc, OP_T0LVL);
  typeflag(sc->loadport) = T_ATOM;
  if (sc->retcode == 0) {
    sc->retcode = sc->nesting != 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %r15
movq 0x100(%rdi), %rax
movq %r15, 0x48(%rdi)
movq %rax, 0x38(%rdi)
xorl %ebp, %ebp
movl %ebp, 0xa90(%rdi)
leaq 0x190(%rdi), %r12
movb $0x12, 0x190(%rdi)
movq %rsi, 0x198(%rdi)
movq %rsi, %rdi
callq 0x40c0
addq %r14, %rax
movq %rax, 0x1a0(%rbx)
movq %r14, 0x1a8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x4689
movl $0x400a, (%rax)         # imm = 0x400A
movq %r12, 0x8(%rax)
movq %rax, 0x188(%rbx)
movl %ebp, 0x10(%rbx)
movl %ebp, 0x50(%rbx)
movslq 0xa90(%rbx), %r14
movq 0x90(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4689
movl $0x4002, (%rax)         # imm = 0x4002
movq %r14, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x5af8
movq 0x188(%rbx), %rax
movl $0x4000, (%rax)         # imm = 0x4000
cmpl %ebp, 0x10(%rbx)
jne 0x5e04
xorl %eax, %eax
cmpl $0x0, 0xa94(%rbx)
setne %al
movl %eax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: scheme_define
void scheme_define(scheme * sc, pointer envir, pointer symbol, pointer value) {
  pointer x;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x5e5e
cmpq 0x90(%r12), %rax
je 0x5e42
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5f14
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x90(%rdi), %rdi
cmpq %rsi, %rdi
sete %r10b
je 0x5f06
movq %rdx, %r8
movq 0x8(%rsi), %r9
movl (%r9), %eax
andl $0x1f, %eax
cmpl $0xb, %eax
jne 0x5ed3
movq 0x8(%r8), %rax
movq 0x8(%rax), %rdx
movb (%rdx), %r11b
testb %r11b, %r11b
je 0x5eb0
incq %rdx
xorl %eax, %eax
roll $0x5, %eax
movsbl %r11b, %r11d
xorl %r11d, %eax
movb (%rdx), %r11b
incq %rdx
testb %r11b, %r11b
jne 0x5e99
jmp 0x5eb2
xorl %eax, %eax
xorl %edx, %edx
divl 0x10(%r9)
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%r9,%rax,8), %rax
andl $0x1, %edx
movq 0x20(%rax,%rdx,8), %r9
cmpq %rdi, %r9
sete %al
je 0x5eef
movq 0x8(%r9), %rdx
cmpq %r8, 0x8(%rdx)
je 0x5eeb
movq 0x10(%r9), %r9
jmp 0x5ed3
testb %al, %al
je 0x5f06
testl %ecx, %ecx
je 0x5f10
movq 0x10(%rsi), %rsi
cmpq %rdi, %rsi
sete %r10b
jne 0x5e75
jmp 0x5f06
testb $0x1, %r10b
jne 0x5f10
movq 0x8(%r9), %rdi
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: new_slot_spec_in_env
static INLINE void new_slot_spec_in_env(scheme * sc, pointer env,
    pointer variable, pointer value) {
  pointer slot = immutable_cons(sc, variable, value);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x4689
movq %rax, %rbx
movl $0x2005, (%rax)         # imm = 0x2005
movq %r13, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x8(%r12), %r15
movl (%r15), %eax
andl $0x1f, %eax
cmpl $0xb, %eax
jne 0x5f86
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdx
movl 0x10(%r15), %ecx
movb (%rdx), %sil
testb %sil, %sil
je 0x5fa9
incq %rdx
xorl %eax, %eax
roll $0x5, %eax
movsbl %sil, %esi
xorl %esi, %eax
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x5f70
jmp 0x5fab
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4689
movl $0x2005, (%rax)         # imm = 0x2005
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%r12)
jmp 0x6004
xorl %eax, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %ebp
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
testb $0x1, %bpl
cltq
leaq (%rax,%rax,2), %rax
leaq 0x20(%r15,%rax,8), %r12
leaq 0x28(%r15,%rax,8), %r13
movq %r13, %rax
cmoveq %r12, %rax
movq (%rax), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4689
movl $0x2005, (%rax)         # imm = 0x2005
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
testb $0x1, %bpl
jne 0x6000
movq %rax, (%r12)
jmp 0x6004
movq %rax, (%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: initFromEnv
void initFromEnv() {
    char* val = getenv("CELL_SEGSIZE");
    cell_segsize = val != NULL ? atoi(val) : CELL_SEGSIZE;
    val = getenv("CELL_NSEGMENT");
    cell_nsegment = val != NULL ? atoi(val) : CELL_NSEGMENT;
#ifdef EVAL_LIMIT
    val = getenv("EVAL_LIMIT");
    eval_limit = val != NULL ? atol(val) : EVAL_LIMIT;
#endif
}

// Assembly:
pushq %rax
leaq 0x752e(%rip), %rdi      # 0xd594
callq 0x4040
testq %rax, %rax
je 0x607a
movq %rax, %rdi
callq 0x4270
jmp 0x607f
movl $0x4e20, %eax           # imm = 0x4E20
movl %eax, 0xd117(%rip)      # 0x1319c
leaq 0x7515(%rip), %rdi      # 0xd5a1
callq 0x4040
testq %rax, %rax
je 0x60a0
movq %rax, %rdi
callq 0x4270
jmp 0x60a5
movl $0xc, %eax
movl %eax, 0xd0ed(%rip)      # 0x13198
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: get_cell_x
static INLINE pointer get_cell_x(scheme * sc, pointer a, pointer b) {
  if (sc->free_cell != sc->NIL) {
    pointer x = sc->free_cell;
    sc->free_cell = cdr(x);
    --sc->fcells;
    return (x);
  }
  return _get_cell(sc, a, b);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x160(%rdi), %rax
cmpq 0x90(%rdi), %rax
je 0x6477
movq 0x10(%rax), %rcx
movq %rcx, 0x160(%rbx)
decq 0x168(%rbx)
jmp 0x64d3
cmpb $0x0, 0xa99(%rbx)
je 0x6486
movq 0x70(%rbx), %rax
jmp 0x64d3
movslq 0x28(%rbx), %r14
shlq $0x3, %r14
movq %rbx, %rdi
callq 0x57bc
cmpq %r14, 0x168(%rbx)
jl 0x64b3
movq 0x160(%rbx), %rax
cmpq 0x90(%rbx), %rax
je 0x64b3
movb $0x1, %cl
jmp 0x64c6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x53b2
movb $0x1, %cl
testl %eax, %eax
je 0x64db
testb %cl, %cl
je 0x64d3
movq 0x160(%rbx), %rax
jmp 0x6463
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x160(%rbx), %rdx
cmpq 0x90(%rbx), %rdx
jne 0x64c6
movb $0x1, 0xa99(%rbx)
movq 0x70(%rbx), %rax
xorl %ecx, %ecx
jmp 0x64c6
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: utf8_decode
static int utf8_decode(const char *p) {
  int bytes;
  int c;
  unsigned char *s = (unsigned char*) p;
  if (IS_ASCII(*s)) {
    return *s;
  }
  bytes = (*s < 0xE0) ? 2 : ((*s < 0xF0) ? 3 : 4);
  c = *s & ((0x100 >> bytes) - 1);
  while (--bytes) {
    c = (c << 6) | (*(++s) & 0x3F);
  }
  return c;
}

// Assembly:
movsbl (%rdi), %eax
testl %eax, %eax
jns 0x653b
cmpb $-0x10, %al
movl $0x4, %edx
sbbl $0x0, %edx
cmpb $-0x20, %al
movl $0x2, %ecx
cmovael %edx, %ecx
movl $0x100, %edx            # imm = 0x100
shrl %cl, %edx
decl %edx
andl %eax, %edx
movzbl %dl, %eax
movl $0x1, %edx
shll $0x6, %eax
movzbl (%rdi,%rdx), %esi
andl $0x3f, %esi
orl %esi, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x6528
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb 0x8(%rdi), %al
testb %al, %al
je 0x6657
movq 0x10(%rdi), %rdx
jmp 0x665d
cvttsd2si 0x10(%rdi), %rdx
movq %rdx, %rcx
shrq $0x3f, %rcx
addq %rdx, %rcx
sarq %rcx
testb %al, %al
je 0x6674
movq 0x10(%rdi), %rax
jmp 0x667a
cvttsd2si 0x10(%rdi), %rax
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
subq %rdx, %rax
addq %rcx, %rax
testl %eax, %eax
jle 0x66b2
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq $0x28, %rdi
movl $0x2005, -0x10(%rdi)    # imm = 0x2005
movq %rsi, -0x8(%rdi)
movq %rsi, (%rdi)
addq $0x18, %rdi
decq %rax
jne 0x669b
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x90(%rdi), %rcx
movq 0x160(%rdi), %rax
cmpq %rcx, %rax
je 0x672d
pushq %rbx
leaq 0x160(%rdi), %rdx
cmpl $0x2, %esi
movl $0x1, %r8d
cmovgel %esi, %r8d
leal 0x1(%r8), %r9d
negl %r8d
movq %rax, %r11
movl $0x1, %r10d
movq %r11, %rbx
movq 0x10(%r11), %r11
addq $0x18, %rbx
cmpq %rbx, %r11
jne 0x670c
leal (%r8,%r10), %ebx
incl %ebx
incl %r10d
cmpl $0x1, %ebx
jne 0x66eb
movl %r9d, %r10d
cmpl %esi, %r10d
jge 0x6731
movslq %r10d, %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %rdx
addq $-0x8, %rdx
movq (%rdx), %rax
cmpq %rcx, %rax
jne 0x66e2
movq %rcx, %rax
jmp 0x6747
movq %rcx, %rax
retq
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rsi
movq -0x8(%rax,%rsi,8), %rsi
movq %rsi, (%rdx)
subq %rcx, 0x168(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movslq 0xa90(%rdi), %rax
testq %rax, %rax
je 0xb151
pushq %rbx
movq %rdi, %rbx
movl 0x990(%rdi,%rax,4), %eax
movl %eax, 0xa94(%rdi)
movq 0x188(%rdi), %rsi
movl $0x10, %edx
callq 0xb56f
movslq 0xa90(%rbx), %rax
decq %rax
movl %eax, 0xa90(%rbx)
shlq $0x5, %rax
addq %rbx, %rax
addq $0x190, %rax            # imm = 0x190
movq 0x188(%rbx), %rcx
movq %rax, 0x8(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/RodionGork[P]tinyscheme/scheme.c
// Function: s_return
static pointer _s_return(scheme * sc, pointer a) {
  sc->value = (a);
  if (sc->dump == sc->NIL)
    return sc->NIL;
  sc->op = ivalue(car(sc->dump));
  sc->args = cadr(sc->dump);
  sc->envir = caddr(sc->dump);
  sc->code = cadddr(sc->dump);
  sc->dump = cddddr(sc->dump);
  return sc->T;
}

// Assembly:
movq %rsi, 0xec0(%rdi)
movq 0x48(%rdi), %rcx
movq 0x90(%rdi), %rax
cmpq %rax, %rcx
je 0xb1d0
movq 0x8(%rcx), %rax
cmpb $0x0, 0x8(%rax)
je 0xb179
movq 0x10(%rax), %rax
jmp 0xb17f
cvttsd2si 0x10(%rax), %rax
movl %eax, 0xec8(%rdi)
movq 0x10(%rcx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rdi)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rdi)
movq 0xb0(%rdi), %rax
retq