LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_01/strindex.c
// Function: get_line
int get_line(char line[], int lim)
{
  int i = 0, c;

  while (lim > 0 && (c = getchar()) != EOF && c != '\n')
  {
    line[i++] = c;
    --lim;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x11ed
movl %esi, %r15d
xorl %r14d, %r14d
callq 0x1060
cmpl $-0x1, %eax
je 0x11e6
cmpl $0xa, %eax
je 0x11e6
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x11c8
movl %r15d, %r14d
cmpl $0xa, %eax
je 0x11f0
jmp 0x11fa
xorl %r14d, %r14d
movl %r14d, %eax
incl %r14d
movb $0xa, (%rbx,%rax)
movslq %r14d, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_01/strindex.c
// Function: strindex
int strindex(char source[], char pattern[])
{
  int i, j, k;

  printf("line len: %lu\n", strlen(source));

  for (i = strlen(source); i >= 0; --i)
  {
    for (j = i, k = 0; pattern[k] != '\0' && source[j] == pattern[k]; ++j, ++k)
      ;

    if (k > 0 && pattern[k] == '\0')
    {
      return i;
    }
  }

  return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1040
leaq 0x11f6(%rip), %rdi      # 0x2413
movq %rax, %rsi
xorl %eax, %eax
callq 0x1050
movq %r14, %rdi
callq 0x1040
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
js 0x1279
movb (%rbx), %dl
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, %r14
testb %dl, %dl
je 0x1265
xorl %esi, %esi
movl %edx, %edi
cmpb %dil, (%r14,%rsi)
jne 0x1265
movb 0x1(%rbx,%rsi), %dil
incq %rsi
testb %dil, %dil
jne 0x124e
testb %dl, %dl
jne 0x1277
movq %rcx, %rsi
decq %rsi
decq %r14
testl %ecx, %ecx
movq %rsi, %rcx
jg 0x1246
jmp 0x1279
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/aws/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * filename_bad = "/dev/null";
	const char * filename_good = "format.key";
	char * key_id;
	char * key_secret;

	WARNP_INIT;
	(void)argc; /* UNUSED */

	/* Generate a failure. */
	fprintf(stderr, "---- Trying to find AWS keys in %s\n", filename_bad);
	if (!aws_readkeys(filename_bad, &key_id, &key_secret)) {
		warn0("That should have failed!");
		goto err0;
	}

	/* Read key info from real file. */
	fprintf(stderr, "---- Trying to find AWS keys in %s\n", filename_good);
	if (aws_readkeys(filename_good, &key_id, &key_secret)) {
		warn0("aws_readkeys");
		goto err0;
	}

	/* Display key info. */
	fprintf(stderr, "id:\t%s\n", key_id);
	fprintf(stderr, "secret:\t%s\n", key_secret);

	/* Generate a header. */
	fprintf(stderr, "---- Generate a header\n");
	if (s3_headers(key_id, key_secret))
		goto err0;

	/* Clean up */
	free(key_id);
	free(key_secret);

	/* Success! */
	exit(0);

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1430
callq 0x2520
movq 0x6bc1(%rip), %r14      # 0x7ff8
movq (%r14), %rdi
leaq 0x3bd8(%rip), %rsi      # 0x5019
leaq 0x3bbc(%rip), %rbx      # 0x5004
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1130
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x15b8
testl %eax, %eax
je 0x15a6
movq (%r14), %rdi
leaq 0x3ba5(%rip), %rsi      # 0x5019
leaq 0x3b93(%rip), %rbx      # 0x500e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1130
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x15b8
testl %eax, %eax
jne 0x15af
movq (%r14), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3bb7(%rip), %rsi      # 0x5063
xorl %eax, %eax
callq 0x1130
movq (%r14), %rdi
movq (%rsp), %rdx
leaq 0x3baa(%rip), %rsi      # 0x506b
xorl %eax, %eax
callq 0x1130
movq (%r14), %rcx
leaq 0x3ba5(%rip), %rdi      # 0x5077
movl $0x17, %esi
movl $0x1, %edx
callq 0x11d0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
subq $0x8, %rsp
leaq 0x20(%rsp), %rax
leaq 0x28(%rsp), %r10
leaq 0x18(%rsp), %r11
leaq 0x3ba2(%rip), %rbx      # 0x50a6
leaq 0x3b84(%rip), %rdx      # 0x508f
leaq 0x3b81(%rip), %rcx      # 0x5093
leaq 0x3b81(%rip), %r8       # 0x509a
leaq 0x3b81(%rip), %r9       # 0x50a1
pushq %rax
pushq %r10
pushq %r11
pushq $0x4
pushq %rbx
callq 0x1898
addq $0x30, %rsp
testl %eax, %eax
jne 0x1583
movq (%r14), %rdi
movq 0x10(%rsp), %rdx
leaq 0x3b7b(%rip), %rsi      # 0x50bf
xorl %eax, %eax
callq 0x1130
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
xorl %edi, %edi
callq 0x11c0
leaq 0x3b21(%rip), %rdi      # 0x50ab
xorl %eax, %eax
callq 0x26bf
callq 0x1060
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x11c0
leaq 0x3a90(%rip), %rdi      # 0x503d
jmp 0x158a
leaq 0x3aa0(%rip), %rdi      # 0x5056
jmp 0x158a
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: main
int main(void)
{
  struct tree_node *tree_root = NULL;
  char word[MAX_WORD_LEN];

  while (get_word(word, MAX_WORD_LEN) != EOF)
  {
    if (isalpha(word[0]))
    {
      tree_root = add_to_tree(tree_root, word);
    }
  }

  struct tree_node *tree_node_list[MAX_NR_OF_NODES] = {NULL};
  copy_tree_to_array(tree_node_list, tree_root);

  quick_sort((void **)tree_node_list, 0, nr_of_nodes - 1, (int (*)(void *, void *))tree_node_cmp);

  for (size_t i = 0; i < nr_of_nodes; ++i)
  {
    printf("%4d %s\n", tree_node_list[i]->count, tree_node_list[i]->word);
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1fb0, %rsp           # imm = 0x1FB0
movq %rsp, %rdi
movl $0x64, %esi
callq 0x1294
xorl %ebx, %ebx
cmpl $-0x1, %eax
je 0x1216
callq 0x10b0
movq %rax, %r14
movq %rsp, %r15
movq (%r14), %rax
movsbq (%rsp), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x1204
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1376
movq %rax, %rbx
movq %r15, %rdi
movl $0x64, %esi
callq 0x1294
cmpl $-0x1, %eax
jne 0x11e7
leaq 0x70(%rsp), %r14
movl $0x1f40, %edx           # imm = 0x1F40
movq %r14, %rdi
xorl %esi, %esi
callq 0x1060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13f0
movq 0x2e3c(%rip), %rdx      # 0x4078
decq %rdx
leaq 0x2a3(%rip), %rcx       # 0x14e9
movq %r14, %rdi
xorl %esi, %esi
callq 0x143a
cmpq $0x0, 0x2e20(%rip)      # 0x4078
je 0x1285
leaq 0xda3(%rip), %rbx       # 0x2004
xorl %r14d, %r14d
movq 0x70(%rsp,%r14,8), %rax
movl 0x8(%rax), %esi
movq (%rax), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1050
incq %r14
cmpq 0x2df5(%rip), %r14      # 0x4078
jb 0x1264
xorl %eax, %eax
addq $0x1fb0, %rsp           # imm = 0x1FB0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: get_word
int get_word(char *word, int max_word_len)
{
  skip_blanks();

  int c = getc(stdin);
  size_t i = 0;

  if (c != EOF)
  {
    word[i++] = c;
  }

  if (!isalpha(c) && c != '_')
  {
    word[i] = '\0';
    return c;
  }

  while ((isalnum(c = getc(stdin)) || c == '_') && i < max_word_len)
  {
    word[i++] = c;
  }
  ungetc(c, stdin);
  word[i] = '\0';

  return word[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
callq 0x1522
movq 0x2d2e(%rip), %r12      # 0x3fe0
movq (%r12), %rdi
callq 0x10a0
movl %eax, %r15d
cmpl $-0x1, %eax
je 0x12ce
movb %r15b, (%rbx)
movl $0x1, %r13d
jmp 0x12d1
xorl %r13d, %r13d
callq 0x10b0
movq %rax, %r14
movq (%rax), %rbp
cmpl $0x5f, %r15d
je 0x12f8
movslq %r15d, %rax
movzwl (%rbp,%rax,2), %eax
andl $0x400, %eax            # imm = 0x400
jne 0x12f8
movb $0x0, (%rbx,%r13)
jmp 0x1364
movq (%r12), %rdi
callq 0x10a0
movslq %eax, %rcx
testb $0x8, (%rbp,%rcx,2)
sete %dl
cmpl $0x5f, %ecx
setne %cl
andb %dl, %cl
movslq 0x4(%rsp), %r15
cmpq %r15, %r13
setae %dl
orb %cl, %dl
jne 0x1350
movb %al, (%rbx,%r13)
incq %r13
movq (%r14), %rbp
movq (%r12), %rdi
callq 0x10a0
movslq %eax, %rcx
testb $0x8, (%rbp,%rcx,2)
sete %dl
cmpl $0x5f, %ecx
setne %cl
testb %dl, %cl
jne 0x1350
cmpq %r15, %r13
jb 0x1323
movq (%r12), %rsi
movl %eax, %edi
callq 0x1090
movb $0x0, (%rbx,%r13)
movsbl (%rbx), %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: add_to_tree
struct tree_node *add_to_tree(struct tree_node *node_p, char *word)
{
  int cond;

  if (node_p == NULL)
  {
    node_p = (struct tree_node *)malloc(sizeof(struct tree_node));
    node_p->word = str_dup(word);
    node_p->count = 1;
    node_p->left = node_p->right = NULL;
  }
  else if ((cond = strcmp(word, node_p->word)) == 0)
  {
    node_p->count++;
  }
  else if (cond < 0)
  {
    node_p->left = add_to_tree(node_p->left, word);
  }
  else if (cond > 0)
  {
    node_p->right = add_to_tree(node_p->right, word);
  }

  return node_p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x13a8
movq %rdi, %rbx
movq (%rdi), %rsi
movq %r14, %rdi
callq 0x1070
testl %eax, %eax
je 0x13d0
jns 0x13d5
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1376
movq %rax, 0x10(%rbx)
jmp 0x13e5
movl $0x20, %edi
callq 0x1080
movq %rax, %rbx
movq %r14, %rdi
callq 0x14fd
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
jmp 0x13e5
incl 0x8(%rbx)
jmp 0x13e5
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1376
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: copy_tree_to_array
void copy_tree_to_array(struct tree_node *arr[], struct tree_node *tree_node_p)
{
  if (tree_node_p != NULL)
  {
    copy_tree_to_array(arr, tree_node_p->left);
    if (nr_of_nodes < MAX_NR_OF_NODES)
    {
      arr[nr_of_nodes++] = tree_node_p;
    }
    copy_tree_to_array(arr, tree_node_p->right);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x1439
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x13f0
movq 0x2c66(%rip), %rax      # 0x4078
cmpq $0x3e7, %rax            # imm = 0x3E7
ja 0x1429
leaq 0x1(%rax), %rcx
movq %rcx, 0x2c53(%rip)      # 0x4078
movq %rbx, (%r14,%rax,8)
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x13ff
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: str_dup
char *str_dup(char *src)
{
  char *dest = (char *)malloc(strlen(src) + 1);
  if (dest != NULL)
  {
    strcpy(dest, src);
  }
  return dest;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1040
leaq 0x1(%rax), %rdi
callq 0x1080
testq %rax, %rax
je 0x1520
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1030
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_04/words_frequency.c
// Function: print_tree
void print_tree(struct tree_node *node_p)
{
  if (node_p != NULL)
  {
    print_tree(node_p->left);
    printf("%4d %s\n", node_p->count, node_p->word);
    print_tree(node_p->right);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15a7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa86(%rip), %r14       # 0x2004
movq 0x10(%rbx), %rdi
callq 0x156b
movl 0x8(%rbx), %esi
movq (%rbx), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x157e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/ecc/bch.c
// Function: poly_eval
static gf13_elem_t poly_eval(const gf13_elem_t *s, gf13_elem_t x)
{
	int i;
	gf13_elem_t sum = 0;
	gf13_elem_t t = x;

	for (i = 0; i < MAX_POLY; i++) {
		const gf13_elem_t c = s[i];

		if (c)
			sum ^= gf13_mul(c, t);

		t = gf13_mul(t, x);
	}

	return sum;
}

// Assembly:
pushq %rbx
movl %esi, %eax
leaq 0x929(%rip), %rcx       # 0x2070
movzwl (%rcx,%rax,2), %edx
xorl %r8d, %r8d
movl $0xffff, %r9d           # imm = 0xFFFF
leaq 0x4915(%rip), %r10      # 0x6070
xorl %eax, %eax
movzwl (%rdi,%r8,2), %r11d
movzwl %si, %esi
testq %r11, %r11
je 0x1798
movzwl (%rcx,%rsi,2), %esi
movzwl (%rcx,%r11,2), %r11d
addw %si, %r11w
movzwl %r11w, %r11d
leal -0x1fff(%r11), %ebx
cmpl $0x1fff, %r11d          # imm = 0x1FFF
cmovbl %r11d, %ebx
movzwl %bx, %r11d
xorw (%r10,%r11,2), %ax
jmp 0x179c
movzwl (%rcx,%rsi,2), %esi
leal (%rdx,%rsi), %r11d
movl %r11d, %ebx
andl %r9d, %ebx
cmpl $0x1fff, %ebx           # imm = 0x1FFF
leal -0x1fff(%rdx,%rsi), %esi
cmovbl %r11d, %esi
andl %r9d, %esi
movzwl (%r10,%rsi,2), %esi
incq %r8
cmpq $0x10, %r8
jne 0x175d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/ecc/bch.c
// Function: poly_add
static void poly_add(gf13_elem_t *dst, const gf13_elem_t *src,
		     gf13_elem_t c, int shift)
{
	int i;

	for (i = 0; i < MAX_POLY; i++) {
		int p = i + shift;
		gf13_elem_t v = src[i];

		if (p < 0 || p >= MAX_POLY)
			continue;
		if (!v)
			continue;

		dst[p] ^= gf13_mul(v, c);
	}
}

// Assembly:
pushq %rbx
movl %edx, %eax
movslq %ecx, %rcx
leaq (%rdi,%rcx,2), %rdx
xorl %edi, %edi
leaq 0x893(%rip), %r8        # 0x2070
leaq 0x488c(%rip), %r9       # 0x6070
leaq (%rcx,%rdi), %r11
movzwl (%rsi,%rdi,2), %r10d
cmpq $0x10, %r11
setae %r11b
testw %r10w, %r10w
sete %bl
orb %r11b, %bl
jne 0x1833
movzwl %r10w, %r10d
movzwl (%r8,%rax,2), %r11d
addw (%r8,%r10,2), %r11w
movzwl %r11w, %r10d
leal -0x1fff(%r10), %r11d
cmpl $0x1fff, %r10d          # imm = 0x1FFF
cmovbl %r10d, %r11d
movzwl %r11w, %r10d
movzwl (%r9,%r10,2), %r10d
xorw %r10w, (%rdx,%rdi,2)
incq %rdi
cmpq $0x10, %rdi
jne 0x17e4
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/bch.c
// Function: main
int main(void)
{
	srandom(0);
	test_code(&bch_1bit);
	test_code(&bch_2bit);
	test_code(&bch_3bit);
	test_code(&bch_4bit);

	return 0;
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x1030
leaq 0x7b9(%rip), %rdi       # 0x2008
callq 0x187c
leaq 0x7c5(%rip), %rdi       # 0x2020
callq 0x187c
leaq 0x7d1(%rip), %rdi       # 0x2038
callq 0x187c
leaq 0x7dd(%rip), %rdi       # 0x2050
callq 0x187c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/dlbeer[P]dhara/tests/bch.c
// Function: test_code
static void test_code(const struct bch_def *def)
{
	uint8_t block[TEST_CHUNK_SIZE];
	int i;

	printf("nbits: %d\n", def->syns / 2);

	memset(block, 0xff, sizeof(block));
	test_properties(def, block);

	for (i = 0; i < 10; i++)
		test_random_block(def);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x420, %rsp            # imm = 0x420
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %esi
shrl $0x1f, %esi
addl %eax, %esi
sarl %esi
leaq 0x87cf(%rip), %rdi      # 0xa070
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x1040
leaq 0x210(%rsp), %r14
movl $0x208, %edx            # imm = 0x208
movq %r14, %rdi
movl $0xff, %esi
callq 0x1060
movq %rbx, %rdi
movq %r14, %rsi
callq 0x192b
leaq 0x200(%rsp), %r14
movq %rsp, %r15
xorl %r13d, %r13d
callq 0x1080
movb %al, (%rsp,%r13)
incq %r13
cmpq $0x200, %r13            # imm = 0x200
jne 0x18de
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x119c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x192b
incl %r12d
cmpl $0xa, %r12d
jne 0x18db
addq $0x420, %rsp            # imm = 0x420
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a80
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 0x19c3
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 0x1983
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
movq %r12, %rsi
leaq 0x200(%rsp), %rcx
callq 0x11fc
testl %eax, %eax
jns 0x1a11
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 0x1a61
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1090
testl %eax, %eax
jne 0x1a42
incl %ebp
cmpl $0x14, %ebp
jne 0x196a
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8632(%rip), %rdi      # 0xa07b
leaq 0x862e(%rip), %rsi      # 0xa07e
leaq 0x8671(%rip), %rcx      # 0xa0c8
movl $0x35, %edx
callq 0x1050
leaq 0x8613(%rip), %rdi      # 0xa07b
leaq 0x860f(%rip), %rsi      # 0xa07e
leaq 0x8652(%rip), %rcx      # 0xa0c8
movl $0x31, %edx
callq 0x1050
leaq 0x85f4(%rip), %rdi      # 0xa07b
leaq 0x85f0(%rip), %rsi      # 0xa07e
leaq 0x85f5(%rip), %rcx      # 0xa08a
movl $0x3e, %edx
callq 0x1050
// File: /workspace/github_c_makefile_star2_O3/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 0x1227
movq %r15, %rdi
callq 0x1030
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12a8
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_O3/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 0x120b
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
je 0x120d
jmp 0x1215
xorl %ebp, %ebp
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_O3/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
jle 0x483e
cmpb $0x0, (%rbx)
js 0x4847
movl %r15d, %ecx
movl $0x1, %eax
movq %rax, %rdx
cmpq %rax, %rcx
je 0x4851
leaq 0x1(%rdx), %rax
cmpb $0x0, (%rbx,%rdx)
jns 0x4825
movl $0x4, %eax
jmp 0x4856
movl $0x1, %eax
xorl %ebp, %ebp
jmp 0x485d
movl $0x4, %eax
movb $0x1, %bpl
jmp 0x485d
movl $0x1, %eax
cmpq %rcx, %rdx
setb %bpl
leal 0x1(%r15), %ecx
imull %eax, %ecx
movslq %ecx, %rdi
callq *(%r12)
testq %rax, %rax
je 0x48cd
movq %rax, %r14
testq %rbx, %rbx
je 0x48fd
movslq %r15d, %r12
testb %bpl, %bpl
je 0x48e0
testl %r15d, %r15d
jle 0x48f5
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 0x48b4
movq %rbx, %rdi
callq 0x643e
movslq %ebp, %rcx
incl %ebp
movl %eax, (%r14,%rcx,4)
incq %rbx
cmpq %r12, %rbx
jb 0x4891
shll $0x8, %ebp
addl $0x7fffff00, %ebp       # imm = 0x7FFFFF00
orl $0x80000080, %ebp       # imm = 0x80000080
jmp 0x48fa
movb $0x1, 0xa99(%r12)
movq 0xea0(%r12), %r14
jmp 0x48fd
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x41d0
movb $0x0, (%r14,%r12)
jmp 0x48fd
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_O3/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 0x493b
cmpq 0x90(%r14), %rax
je 0x4929
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x49cf
// File: /workspace/github_c_makefile_star2_O3/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 0x4970
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 0x495c
jmp 0x4972
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 0x49bd
movq 0x8(%r12), %r14
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x41a0
testl %eax, %eax
je 0x49c0
movq 0x10(%r12), %r12
jmp 0x4998
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
jne 0x4acd
movq 0x90(%rbx), %rax
jmp 0x4b26
leaq 0x89c4(%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 0x493b
movq %rax, %rcx
movq 0x90(%rbx), %rax
cmpq %rax, %rcx
je 0x4b1b
movq 0xed8(%rbx), %rcx
incq %rcx
movq %rcx, 0xed8(%rbx)
cmpq %r12, %rcx
jne 0x4ad7
jmp 0x4b26
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x49cf
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4b9a
movb (%rbx), %al
testb %al, %al
je 0x4b94
movq %rdi, %r14
incq %rbx
movq 0x18(%r15), %rcx
cmpq 0x10(%r15), %rcx
je 0x4b6d
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r15)
movb %al, (%rcx)
jmp 0x4b8b
testb $0x4, (%r15)
je 0x4b8b
movq %r14, %rdi
movq %r15, %rsi
callq 0x4bab
testl %eax, %eax
je 0x4b8b
movb -0x1(%rbx), %al
movq 0x18(%r15), %rcx
jmp 0x4b61
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x4b57
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_O3/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 0x4c26
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 0x4c28
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_O3/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 0x4c66
movq 0x18(%r14), %rcx
cmpq 0x10(%r14), %rcx
je 0x4c78
leaq 0x1(%rcx), %rax
movq %rax, 0x18(%r14)
movb %bl, (%rcx)
jmp 0x4c96
movq 0x8(%r14), %rsi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4170
testb $0x4, %al
je 0x4c96
movq %r14, %rsi
callq 0x4bab
testl %eax, %eax
je 0x4c96
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_O3/RodionGork[P]tinyscheme/scheme.c
// Function: long_to_str
void long_to_str(long v, char *s, int base) {
  char *p;
  char c;
  if (v < 0) {
    *s++ = '-';
    v = -v;
  }
  p = s;
  if (v == 0) {
    *s++ = '0';
  }
  while (v > 0) {
    c = (char) (v % base);
    v /= base;
    if (c < 10) {
      c += '0';
    } else {
      c += 'A' - 10;
    }
    *s++ = c;
  }
  *s-- = '\0';
  while (s > p) {
    c = *p;
    *p++ = *s;
    *s-- = c;
  }
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
js 0x4cb1
jne 0x4cba
leaq 0x1(%rsi), %rcx
movb $0x30, (%rsi)
jmp 0x4ce6
movb $0x2d, (%rsi)
incq %rsi
negq %rax
movslq %edx, %rdi
movl $0x30, %r8d
movq %rsi, %rcx
cqto
idivq %rdi
cmpb $0xa, %dl
movl $0x37, %r9d
cmovll %r8d, %r9d
addb %dl, %r9b
movb %r9b, (%rcx)
incq %rcx
testq %rax, %rax
jg 0x4cc6
movb $0x0, (%rcx)
decq %rcx
cmpq %rsi, %rcx
jbe 0x4d0d
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 0x4cf4
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d41
leaq 0x82e7(%rip), %rcx      # 0xd008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x1, %eax
jne 0x4daa
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x4dde
cmpq %rsi, %rdi
jmp 0x4dde
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x4, %eax
jne 0x4daa
cmpb $0x0, 0x8(%rdi)
je 0x4dc3
movq 0x10(%rdi), %rax
jmp 0x4dc9
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x2, %eax
jne 0x4daa
movb 0x8(%rdi), %dl
cmpb 0x8(%rsi), %dl
jne 0x4daa
movq 0x10(%rdi), %rax
movq 0x10(%rsi), %rcx
testb %dl, %dl
jne 0x4ddb
movq %rax, %xmm0
movq %rcx, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
jmp 0x4de1
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0x9, %eax
jne 0x4daa
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x4dde
xorl %eax, %eax
jmp 0x4de1
movl (%rsi), %eax
andl $0x1f, %eax
cmpl $0xa, %eax
sete %cl
cmpq %rsi, %rdi
sete %al
andb %cl, %al
jmp 0x4de1
cvttsd2si 0x10(%rdi), %rax
cmpb $0x0, 0x8(%rsi)
je 0x4dd5
movq 0x10(%rsi), %rcx
jmp 0x4ddb
cvttsd2si 0x10(%rsi), %rcx
cmpq %rcx, %rax
sete %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e02
cmpq %rcx, %rsi
sete %al
jmp 0x4e30
testb %dil, %dil
je 0x4e0e
cvtsi2sd %rsi, %xmm0
jmp 0x4e13
movq %rsi, %xmm0
testb %dl, %dl
je 0x4e1e
cvtsi2sd %rcx, %xmm1
jmp 0x4e23
movq %rcx, %xmm1
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
andl $0x1, %eax
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e77
movl (%rdx), %edi
andl $0x1f, %edi
cmpl $0x5, %edi
jne 0x4e78
movq 0x10(%rdx), %rdx
cmpq %rcx, %rdx
je 0x4e7f
movl (%rdx), %edi
andl $0x1f, %edi
cmpl $0x5, %edi
jne 0x4e82
addl $0x2, %eax
movq 0x10(%rdx), %rdx
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdx
jne 0x4e40
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
jmp 0x4e87
incl %eax
retq
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
subl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe13f(%rip), %rsi      # 0x12fe0
movq 0xe108(%rip), %rdx      # 0x12fb0
movq %rax, %rdi
callq 0x4f0f
testl %eax, %eax
jne 0x4ebe
movq %rbx, %rdi
callq 0x4310
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f0f
testl %eax, %eax
jne 0x4f06
movq %rbx, %rdi
callq *%r14
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x54e8
movq %rbx, %rdi
movl $0x1cd, %esi            # imm = 0x1CD
callq 0x6480
movq %rax, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4689
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_O3/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 0x5574
movq %rax, %rbx
orb $0x1, %bpl
movb %bpl, (%rax)
movq %r15, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq 0x90(%r14), %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x4689
movl $0x400a, (%rax)         # imm = 0x400A
movq %rbx, 0x8(%rax)
jmp 0x557b
movq 0x90(%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x55f1
movq %rax, %rbx
orb $0x2, %bpl
movb %bpl, (%rax)
movq %r12, 0x8(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x10(%rax)
movq 0x90(%r14), %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x4689
movl $0x400a, (%rax)         # imm = 0x400A
movq %rbx, 0x8(%rax)
jmp 0x55f8
movq 0x90(%r14), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5686
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 0x56ab
movl $0x4000, (%rcx)         # imm = 0x4000
movq %rax, 0x180(%rbx)
movq 0x188(%rbx), %rcx
movl (%rcx), %edx
andl $0x1f, %edx
cmpl $0xa, %edx
jne 0x56c9
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 0x576b
cmpl $0x0, 0x28(%rbx)
js 0x5718
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 0x5700
movq 0x20(%rbx), %rdi
callq *0x8(%rbx)
movq 0x18(%rbx), %rdi
callq *0x8(%rbx)
movl 0xa90(%rbx), %eax
testl %eax, %eax
js 0x5765
leaq 0x1a8(%rbx), %r14
movq $-0x1, %r15
testb $0x1, -0x18(%r14)
je 0x5756
movq (%r14), %rdi
testq %rdi, %rdi
je 0x5756
callq *0x8(%rbx)
movl 0xa90(%rbx), %eax
movslq %eax, %rcx
incq %r15
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x573e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5a91
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 0xd5fa(%rip), %rax      # 0x12fd0
movq (%rax), %rax
cmpq %r15, %rax
jne 0x59f9
cmpb $0x2d, (%r14)
jne 0x59f2
cmpb $0x2d, 0x1(%r14)
jne 0x59f2
cmpb $0x0, 0x2(%r14)
je 0x59f9
movl $0x1, 0x50(%rbx)
movl $0x0, 0x1a4(%rbx)
cmpq %r15, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x5a2a
movq %r14, %rdi
callq 0x40c0
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x4803
jmp 0x5a2c
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 0x5a98
movq 0x188(%rbx), %rax
movl $0x4000, (%rax)         # imm = 0x4000
cmpl $0x0, 0x10(%rbx)
jne 0x5a88
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 0x5a88
// File: /workspace/github_c_makefile_star2_O3/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 0x5de8
cmpq 0x90(%r12), %rax
je 0x5dcc
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 0x5e7f
// File: /workspace/github_c_makefile_star2_O3/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
je 0x5e7b
movq %rdx, %r8
movq 0x8(%rsi), %r9
movl (%r9), %eax
andl $0x1f, %eax
cmpl $0xb, %eax
jne 0x5e69
movq 0x8(%r8), %rax
movq 0x8(%rax), %rdx
movb (%rdx), %r10b
testb %r10b, %r10b
je 0x5e36
incq %rdx
xorl %eax, %eax
roll $0x5, %eax
movsbl %r10b, %r10d
xorl %r10d, %eax
movb (%rdx), %r10b
incq %rdx
testb %r10b, %r10b
jne 0x5e1f
jmp 0x5e38
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
jmp 0x5e69
movq 0x8(%r9), %rax
cmpq %r8, 0x8(%rax)
je 0x5e7e
movq 0x10(%r9), %r9
cmpq %rdi, %r9
jne 0x5e5b
testl %ecx, %ecx
je 0x5e7b
movq 0x10(%rsi), %rsi
cmpq %rdi, %rsi
jne 0x5dfb
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/RodionGork[P]tinyscheme/scheme.c
// Function: new_slot_spec_in_env
static INLINE void new_slot_spec_in_env(scheme * sc, pointer env,
    pointer variable, pointer value) {
  pointer slot = immutable_cons(sc, variable, value);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %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 0x5eef
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdx
movl 0x10(%r15), %ecx
movb (%rdx), %sil
testb %sil, %sil
je 0x5f12
incq %rdx
xorl %eax, %eax
roll $0x5, %eax
movsbl %sil, %esi
xorl %esi, %eax
movb (%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x5ed9
jmp 0x5f14
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 0x5f58
xorl %eax, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %r12d
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
cltq
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %r13
andl $0x1, %r12d
movq 0x20(%r13,%r12,8), %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)
movq %rax, 0x20(%r13,%r12,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x75f3(%rip), %rdi      # 0xd593
callq 0x4040
testq %rax, %rax
je 0x5fb4
movq %rax, %rdi
callq 0x4270
jmp 0x5fb9
movl $0x4e20, %eax           # imm = 0x4E20
movl %eax, 0xd1dd(%rip)      # 0x1319c
leaq 0x75da(%rip), %rdi      # 0xd5a0
callq 0x4040
testq %rax, %rax
je 0x5fda
movq %rax, %rdi
callq 0x4270
jmp 0x5fdf
movl $0xc, %eax
movl %eax, 0xd1b3(%rip)      # 0x13198
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x63d4
movq 0x10(%rax), %rcx
movq %rcx, 0x160(%rbx)
decq 0x168(%rbx)
jmp 0x63e1
cmpb $0x0, 0xa99(%rbx)
je 0x63e9
movq 0x70(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movslq 0x28(%rbx), %r14
shlq $0x3, %r14
movq %rbx, %rdi
callq 0x576b
cmpq %r14, 0x168(%rbx)
jl 0x6412
movq 0x160(%rbx), %rax
cmpq 0x90(%rbx), %rax
jne 0x63c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x536b
movl %eax, %ecx
movq 0x160(%rbx), %rax
testl %ecx, %ecx
jne 0x63c0
cmpq 0x90(%rbx), %rax
jne 0x63c0
movb $0x1, 0xa99(%rbx)
jmp 0x63dd