LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/integer.c
// Function: gen_exp10
void gen_exp10(int e)
{
	char *s = malloc(e+2);
	memset(s+1, '0', e);
	s[0] = '1';
	s[e+1] = '\0';

	struct tt_int *ti = tt_int_alloc();
	tt_int_from_string(ti, s);

	int c = 0;
	_tt_word sh = 0;
	const int shift = _tt_word_bits - _tt_int_word_bits(ti->buf[ti->msb-1]);
	printf("#define dec9_shift_%d\t%d\n", e/9, shift);

#ifdef _TT_LP64_
	printf("static const uint64_t dec9_norm_%d[] = {", e/9);
	for (int i = 0; i < ti->msb; i++) {
		if (c == 0)
			printf("\n\t");
		printf("0x%016llX,",
				((ti->buf[i] << shift) | sh) & ~(1ULL << 63));
		sh = ti->buf[i] >> (63 - shift);
		c++;
		if (c == 3)
			c = 0;
		else
			printf(" ");
	}
#else
	printf("static const uint dec9_norm_%d[] = {", e/9);
	for (int i = 0; i < ti->msb; i++) {
		if (c == 0)
			printf("\n\t");
		printf("0x%08X,", ((ti->buf[i] << shift) | sh) & ~(1 << 31));
		sh = ti->buf[i] >> (31 - shift);
		c++;
		if (c == 6)
			c = 0;
		else
			printf(" ");
	}
#endif
	printf("\n};\n\n");
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2190
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0x1, %rdi
movslq 0x34(%rsp), %rdx
movl $0x30, %esi
callq 0x20f0
movq 0x28(%rsp), %rax
movb $0x31, (%rax)
movq 0x28(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
callq 0x7a50
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x82e0
movl $0x0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7cf0
movl %eax, %ecx
movl $0x3f, %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0x34(%rsp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %eax, %esi
movl 0xc(%rsp), %edx
leaq 0x10ae5(%rip), %rdi     # 0x13004
movb $0x0, %al
callq 0x20c0
movl 0x34(%rsp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0x10ae3(%rip), %rdi     # 0x1301e
movb $0x0, %al
callq 0x20c0
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x260d
cmpl $0x0, 0x1c(%rsp)
jne 0x2571
leaq 0x10add(%rip), %rdi     # 0x13047
movb $0x0, %al
callq 0x20c0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movl 0xc(%rsp), %eax
movl %eax, %ecx
shlq %cl, %rsi
orq 0x10(%rsp), %rsi
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq %rax, %rsi
leaq 0x10aa5(%rip), %rdi     # 0x1304a
movb $0x0, %al
callq 0x20c0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x3f, %ecx
subl 0xc(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x3, 0x1c(%rsp)
jne 0x25ed
movl $0x0, 0x1c(%rsp)
jmp 0x25fb
leaq 0x1d690(%rip), %rdi     # 0x1fc84
movb $0x0, %al
callq 0x20c0
jmp 0x25fd
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x254a
leaq 0x10a41(%rip), %rdi     # 0x13055
movb $0x0, %al
callq 0x20c0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/integer.c
// Function: gen_int_str
static char *gen_int_str(int *radix)
{
	const int _radix[] = { 2, 8, 10, 16, 10 };
	const char *prefix[] = { "0b", "0", "", "0x", "" };

	const int sign = rand() & 1;
	const int ridx = rand() % 5;
	const int digs = rand() % MAX_DIGS + 1;

	char *str = malloc(sign + strlen(prefix[ridx]) + digs + 1);
	char *s = str;
	if (sign)
		*s++ = '-';
	*s = '\0';
	strcat(s, prefix[ridx]);
	s += strlen(prefix[ridx]);

	*s = bin2asc[rand() % _radix[ridx]];
	if (*s == '0')
		*s = '1';
	s++;
	for (int i = 1; i < digs; i++)
		*s++ = bin2asc[rand() % _radix[ridx]];
	*s = '\0';

	*radix = _radix[ridx];
	return str;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x1033a(%rip), %rax     # 0x132d0
movq %rax, 0x60(%rsp)
movq 0x10336(%rip), %rax     # 0x132d8
movq %rax, 0x68(%rsp)
movl 0x10333(%rip), %eax     # 0x132e0
movl %eax, 0x70(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x1fcb3(%rip), %rsi     # 0x22c70
movl $0x28, %edx
callq 0x2160
callq 0x2200
andl $0x1, %eax
movl %eax, 0x2c(%rsp)
callq 0x2200
movl $0x5, %ecx
cltd
idivl %ecx
movl %edx, 0x28(%rsp)
callq 0x2200
movl $0x1388, %ecx           # imm = 0x1388
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, 0x24(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, (%rsp)
movslq 0x28(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdi
callq 0x20b0
movq (%rsp), %rdi
addq %rax, %rdi
movslq 0x24(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
callq 0x2190
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x3052
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x2d, (%rax)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rdi
movslq 0x28(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rsi
callq 0x21d0
movslq 0x28(%rsp), %rax
movq 0x30(%rsp,%rax,8), %rdi
callq 0x20b0
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x2200
movslq 0x28(%rsp), %rcx
cltd
idivl 0x60(%rsp,%rcx,4)
movslq %edx, %rcx
leaq 0x10250(%rip), %rax     # 0x132f0
movb (%rax,%rcx), %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x30bf
movq 0x10(%rsp), %rax
movb $0x31, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x311b
callq 0x2200
movslq 0x28(%rsp), %rcx
cltd
idivl 0x60(%rsp,%rcx,4)
movslq %edx, %rcx
leaq 0x101f8(%rip), %rax     # 0x132f0
movb (%rax,%rcx), %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x30d5
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movslq 0x28(%rsp), %rax
movl 0x60(%rsp,%rax,4), %ecx
movq 0x80(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rafa9811[P]theIndiependenceGame/m_background.c
// Function: printScreen
int printScreen(char *draw){
    char line[SCREEN_LINE*2],*ini;
    int i=0,linenumber=0;
    ini=draw;
    while(linenumber<SCREENY){
      draw = ini + i;
      memcpy(line,draw,SCREEN_LINE);
      printf("%s\n",line);
      i+=SCREEN_LINE;
      linenumber++;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xbc(%rbp)
movl $0x0, -0xc0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpl $0x2a, -0xc0(%rbp)
jge 0x1306
movq -0xb8(%rbp), %rax
movslq -0xbc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x50, %edx
callq 0x1100
leaq -0xb0(%rbp), %rsi
leaq 0x7180(%rip), %rdi      # 0x845f
movb $0x0, %al
callq 0x1090
movl -0xbc(%rbp), %eax
addl $0x50, %eax
movl %eax, -0xbc(%rbp)
movl -0xc0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc0(%rbp)
jmp 0x129e
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_init
hashtab_t *ht_init(size_t size, int (*hash_func) (void *, size_t, size_t))
{
    hashtab_t *new_ht = (hashtab_t *) malloc(sizeof(hashtab_t));

    new_ht->arr =
	(hashtab_node_t **) malloc(sizeof(hashtab_node_t *) * size);

    new_ht->size = size;
    new_ht->count = 0;

    /* all entries are empty */
    int i = 0;
    for (i = 0; i < (int) size; i++) {
	new_ht->arr[i] = NULL;
    }

    if (hash_func == NULL)
	new_ht->hash_func = &ht_hash;
    else
	new_ht->hash_func = hash_func;

    return new_ht;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x20, %edi
callq 0x1170
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, 0xc(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl %ecx, %eax
jge 0x138f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1360
cmpq $0x0, 0x18(%rsp)
jne 0x13a9
movq 0x10(%rsp), %rax
leaq 0x2d(%rip), %rcx        # 0x13d0
movq %rcx, 0x18(%rax)
jmp 0x13b7
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_hash
int ht_hash(void *key, size_t keylen, size_t hashtab_size)
{
    int sum = 0;

    /* very simple hash function for now */
    int i;
    for (i = 0; i < (int) keylen; i++) {
	sum += ((unsigned char *) key)[i] * (i + 1);
    }

    return (sum % (int) hashtab_size);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movq -0x10(%rsp), %rcx
cmpl %ecx, %eax
jge 0x1429
movq -0x8(%rsp), %rax
movslq -0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl -0x20(%rsp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
addl -0x1c(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x13ef
movl -0x1c(%rsp), %eax
movq -0x18(%rsp), %rcx
cltd
idivl %ecx
movl %edx, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_search
void *ht_search(hashtab_t * hashtable, void *key, size_t keylen)
{
    int index = ht_hash(key, keylen, hashtable->size);

    if (hashtable->arr[index] == NULL)
	return NULL;

    hashtab_node_t *last_node = hashtable->arr[index];
    while (last_node != NULL) {
	/* only compare matching keylens */
	if (last_node->keylen == keylen) {
	    /* compare keys */
	    if (memcmp(key, last_node->key, keylen) == 0) {
		return last_node->value;
	    }
	}

	last_node = last_node->next;
    }

    return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x13d0
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x148e
movq $0x0, 0x30(%rsp)
jmp 0x1503
movq 0x28(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x14fa
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x14ea
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x1110
cmpl $0x0, %eax
jne 0x14e8
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1503
jmp 0x14ea
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x14a4
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_remove
void ht_remove(hashtab_t * hashtable, void *key, size_t keylen)
{
    hashtab_node_t *last_node, *next_node;
    int index = ht_hash(key, keylen, hashtable->size);
    next_node = hashtable->arr[index];
    last_node = NULL;

    while (next_node != NULL) {
	if (next_node->keylen == keylen) {
	    /* compare keys */
	    if (memcmp(key, next_node->key, keylen) == 0) {
		/* free node memory */
		free(next_node->value);
		free(next_node->key);

		/* adjust the list pointers */
		if (last_node != NULL)
		    last_node->next = next_node->next;
		else
		    hashtable->arr[index] = next_node->next;

		/* free the node */
		free(next_node);
		break;
	    }
	}

	last_node = next_node;
	next_node = next_node->next;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x13d0
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x18a2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x1885
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x1110
cmpl $0x0, %eax
jne 0x1883
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
cmpq $0x0, 0x18(%rsp)
je 0x185d
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x1877
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rdi
callq 0x1030
jmp 0x18a2
jmp 0x1885
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x17ee
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_grow
void *ht_grow(hashtab_t * old_ht, size_t new_size)
{
    /* create new hashtable */
    hashtab_t *new_ht = ht_init(new_size, old_ht->hash_func);
    if (new_ht == NULL)
	return NULL;

    void *ret;			/* captures return values */

    /* Iterate through the old hashtable. */
    hashtab_iter_t ii;
    ht_iter_init(old_ht, &ii);
    for (; ii.key != NULL; ht_iter_inc(&ii)) {
	ret = ht_insert(new_ht, ii.key, ii.keylen, ii.value, ii.vallen);
	if (ret == NULL) {
	    /* Insert failed. Destroy new hashtable and return. */
	    ht_destroy(new_ht);
	    return NULL;
	}
    }

    /* Destroy the old hashtable. */
    ht_destroy(old_ht);

    return new_ht;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x1300
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x18e9
movq $0x0, 0x60(%rsp)
jmp 0x1962
movq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1970
cmpq $0x0, 0x8(%rsp)
je 0x194e
movq 0x48(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x1510
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x1940
movq 0x48(%rsp), %rdi
callq 0x19c0
movq $0x0, 0x60(%rsp)
jmp 0x1962
jmp 0x1942
leaq 0x8(%rsp), %rdi
callq 0x1a70
jmp 0x18f8
movq 0x58(%rsp), %rdi
callq 0x19c0
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_iter_init
void ht_iter_init(hashtab_t * hashtable, hashtab_iter_t * ii)
{
    /* stick in initial bookeeping data */
    ii->internal.hashtable = hashtable;
    ii->internal.node = NULL;
    ii->internal.index = -1;

    /* have iterator point to first element */
    ht_iter_inc(ii);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rdi
callq 0x1a70
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/hashtab.c
// Function: ht_destroy
void ht_destroy(hashtab_t * hashtable)
{
    hashtab_node_t *next_node, *last_node;

    /* Free each linked list in hashtable. */
    int i;
    for (i = 0; i < (int) hashtable->size; i++) {
	next_node = hashtable->arr[i];
	while (next_node != NULL) {
	    /* destroy node */
	    free(next_node->key);
	    free(next_node->value);
	    last_node = next_node;
	    next_node = next_node->next;
	    free(last_node);
	}
    }

    free(hashtable->arr);
    free(hashtable);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jge 0x1a4e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1a3f
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1030
jmp 0x19f8
jmp 0x1a41
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x19d1
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: skip_whitespace
static void skip_whitespace(Lex* lex) {
    while (!is_at_end(lex)) {
        const char c = peek(lex);
        switch (c) {
            case ' ':
            case '\t':
            case '\r':
                advance(lex);
                break;
            case '\n':
                newline(lex);
                break;
            case '/':
                if (peek_next(lex) == '/') {
                    skip_until_char(lex, '\n');
                } else {
                    return;
                }
                break;
            case '#':
                if (peek_next(lex) == '!') {
                    skip_until_char(lex, '\n');
                } else {
                    return;
                }
                break;
            default:
                return;
        }
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2170
xorb $-0x1, %al
testb $0x1, %al
jne 0x20be
jmp 0x2160
movq 0x10(%rsp), %rdi
callq 0x2650
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x26, %eax
ja 0x2159
movq (%rsp), %rax
leaq 0x909a(%rip), %rcx      # 0xb184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
callq 0x2210
jmp 0x215b
movq 0x10(%rsp), %rdi
callq 0x2670
jmp 0x215b
movq 0x10(%rsp), %rdi
callq 0x26b0
movsbl %al, %eax
cmpl $0x2f, %eax
jne 0x212e
movq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0x2700
jmp 0x2130
jmp 0x2160
jmp 0x215b
movq 0x10(%rsp), %rdi
callq 0x26b0
movsbl %al, %eax
cmpl $0x21, %eax
jne 0x2155
movq 0x10(%rsp), %rdi
movl $0xa, %esi
callq 0x2700
jmp 0x2157
jmp 0x2160
jmp 0x215b
jmp 0x2160
jmp 0x20a9
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: init_token
static void init_token(const Lex* lex, Token* token, TokenType type,
                       const Lex* start_lex) {
    token->line = start_lex->line;
    token->column = start_lex->column;
    token->type = type;
    token->source = &lex->source[start_lex->pos];
    token->source_len = lex->pos - start_lex->pos;
    LOG("type=%s line=%zu column=%zu source=`%.*s` source_len=%zu\n",
        token_type_str[type], token->line, token->column,
        (int)token->source_len, token->source, token->source_len);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x20(%rsp), %rax
addq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rsp), %rax
subq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x2209
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: number
static void number(Lex* lex, Token* token, const Lex* start_lex) {
    while (!is_at_end(lex) && isdigit(peek(lex))) {
        advance(lex);
    }

    if (!is_at_end(lex) && peek(lex) == '.' && isdigit(peek_next(lex))) {
        // Consume the dot
        advance(lex);

        while (!is_at_end(lex) && isdigit(peek(lex))) {
            advance(lex);
        }
    }

    init_token(lex, token, TOKEN_NUMBER, start_lex);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2170
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x2f(%rsp)
jne 0x22b1
callq 0x11f0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2650
movb %al, %cl
movq 0x20(%rsp), %rax
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x22bb
jmp 0x22c7
movq 0x40(%rsp), %rdi
callq 0x2210
jmp 0x2263
movq 0x40(%rsp), %rdi
callq 0x2170
testb $0x1, %al
jne 0x2391
movq 0x40(%rsp), %rdi
callq 0x2650
movsbl %al, %eax
cmpl $0x2e, %eax
jne 0x2391
callq 0x11f0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x26b0
movb %al, %cl
movq 0x18(%rsp), %rax
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2391
movq 0x40(%rsp), %rdi
callq 0x2210
movq 0x40(%rsp), %rdi
callq 0x2170
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x2379
callq 0x11f0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2650
movb %al, %cl
movq 0x8(%rsp), %rax
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x2383
jmp 0x238f
movq 0x40(%rsp), %rdi
callq 0x2210
jmp 0x232b
jmp 0x2391
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rcx
movl $0x16, %edx
callq 0x2190
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: identifier
static void identifier(Lex* lex, Token* token, const Lex* start_lex) {
    while (!is_at_end(lex) && isalnum(peek(lex))) {
        advance(lex);
    }

    const char* s = &start_lex->source[start_lex->pos];
    const size_t s_len = lex->pos - start_lex->pos;

    init_token(lex, token, identifier_type(s, s_len), start_lex);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2170
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x240f
callq 0x11f0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2650
movb %al, %cl
movq 0x10(%rsp), %rax
movsbl %cl, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x2419
jmp 0x2425
movq 0x40(%rsp), %rdi
callq 0x2210
jmp 0x23c3
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x20(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
subq 0x20(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2760
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl %eax, %edx
movq 0x30(%rsp), %rcx
callq 0x2190
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: match
static bool match(Lex* lex, char c) {
    if (is_at_end(lex)) {
        return false;
    }

    if (lex->source[lex->pos] != c) {
        return false;
    }

    advance(lex);
    return true;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x8(%rsp)
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2170
testb $0x1, %al
jne 0x24b0
jmp 0x24b7
movb $0x0, 0x17(%rsp)
jmp 0x24eb
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x7(%rsp), %ecx
cmpl %ecx, %eax
je 0x24dc
movb $0x0, 0x17(%rsp)
jmp 0x24eb
movq 0x8(%rsp), %rdi
callq 0x2210
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: string
static void string(Lex* lex, Token* token) {
    const Lex start_lex = *lex;
    while (!is_at_end(lex) && peek(lex) != '"') {
        if (peek(lex) == '\n') {
            newline(lex);
        } else {
            advance(lex);
        }
    }

    if (is_at_end(lex)) {
        init_token_err(lex, token, "Unterminated string");
        return;
    }
    init_token(lex, token, TOKEN_STRING, &start_lex);

    // Consume closing quote
    advance(lex);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movl $0x28, %edx
callq 0x1160
movq 0x40(%rsp), %rdi
callq 0x2170
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x2550
movq 0x40(%rsp), %rdi
callq 0x2650
movsbl %al, %eax
cmpl $0x22, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x255a
jmp 0x2584
movq 0x40(%rsp), %rdi
callq 0x2650
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x2578
movq 0x40(%rsp), %rdi
callq 0x2670
jmp 0x2582
movq 0x40(%rsp), %rdi
callq 0x2210
jmp 0x2522
movq 0x40(%rsp), %rdi
callq 0x2170
testb $0x1, %al
jne 0x2594
jmp 0x25ac
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
leaq 0x90a0(%rip), %rdx      # 0xb645
callq 0x25e0
jmp 0x25cf
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x15, %edx
leaq 0x10(%rsp), %rcx
callq 0x2190
movq 0x40(%rsp), %rdi
callq 0x2210
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/lex.c
// Function: init_token_err
static void init_token_err(const Lex* lex, Token* token, const char err[]) {
    token->line = lex->line;
    token->column = lex->column;
    token->type = TOKEN_ERROR;
    token->source = err;
    token->source_len = strlen(err);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x27, 0x20(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rdi
callq 0x1090
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/main.c
// Function: main
int main(int argc, const char* argv[]) {
    if (argc == 2 && strcmp(argv[1], "repl") == 0) {
        vm_repl();
    } else if (argc == 3) {
        char* source = NULL;
        size_t source_len = 0;
        if (strcmp(argv[2], "-") == 0) {
            read_stdin(&source, &source_len);
        } else {
            read_file(argv[2], &source, &source_len);
        }

        if (strcmp(argv[1], "dump") == 0) {
            return (int)vm_interpret(source, source_len, vm_dump);
        }
        if (strcmp(argv[1], "run") == 0) {
            return (int)vm_interpret(source, source_len, vm_run_bytecode);
        }
    } else {
        cli_help(argv);
    }
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x2, 0x20(%rsp)
jne 0x2bb0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x8abd(%rip), %rsi      # 0xb659
callq 0x1120
cmpl $0x0, %eax
jne 0x2bb0
callq 0xa5d0
jmp 0x2c8a
cmpl $0x3, 0x20(%rsp)
jne 0x2c7e
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x8a81(%rip), %rsi      # 0xb65e
callq 0x1120
cmpl $0x0, %eax
jne 0x2bf8
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6210
jmp 0x2c10
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x6330
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x8a40(%rip), %rsi      # 0xb660
callq 0x1120
cmpl $0x0, %eax
jne 0x2c46
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x4075(%rip), %rdx      # 0x6cb0
callq 0x9b60
movl %eax, 0x24(%rsp)
jmp 0x2c8a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x8a0f(%rip), %rsi      # 0xb665
callq 0x1120
cmpl $0x0, %eax
jne 0x2c7c
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x47bf(%rip), %rdx      # 0x7430
callq 0x9b60
movl %eax, 0x24(%rsp)
jmp 0x2c8a
jmp 0x2c88
movq 0x18(%rsp), %rdi
callq 0x2ca0
jmp 0x2c8a
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: parser_compile
Result parser_compile(char* source, size_t source_len, ObjFunction** fn,
                      Vm* vm) {
    LOG("source_len=%zu source=`%.*s`\n", source_len, (int)source_len, source);

    Parser parser = {.lex = {
                         .source = source,
                         .source_len = source_len,
                         .line = 1,
                         .column = 1,
                         .pos = 0,
                     }};

    Compiler compiler;
    memset(&compiler, 0, sizeof(compiler));
    compiler_init(&compiler, TYPE_SCRIPT, &parser);

    advance(&parser);

    while (!match(&parser, TOKEN_EOF)) {
        declaration(&parser, vm);
    }

    if (parser.state == PARSER_STATE_OK) {
        *fn = compiler_end(&parser);
    }

    free(source);

    return parser.state == PARSER_STATE_OK ? RES_OK : RES_PARSE_ERR;
}

// Assembly:
subq $0x30d8, %rsp           # imm = 0x30D8
movq %rdi, 0x30d0(%rsp)
movq %rsi, 0x30c8(%rsp)
movq %rdx, 0x30c0(%rsp)
movq %rcx, 0x30b8(%rsp)
jmp 0x2cf9
leaq 0x3030(%rsp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x10f0
movq 0x30d0(%rsp), %rax
movq %rax, 0x3038(%rsp)
movq 0x30c8(%rsp), %rax
movq %rax, 0x3040(%rsp)
movq $0x1, 0x3048(%rsp)
movq $0x1, 0x3050(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x3028, %edx           # imm = 0x3028
callq 0x10f0
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0x3030(%rsp), %rdx
callq 0x2e00
leaq 0x3030(%rsp), %rdi
callq 0x2f50
leaq 0x3030(%rsp), %rdi
movl $0x28, %esi
callq 0x2fc0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d94
jmp 0x2dab
movq 0x30b8(%rsp), %rsi
leaq 0x3030(%rsp), %rdi
callq 0x3000
jmp 0x2d7a
cmpl $0x0, 0x3030(%rsp)
jne 0x2dd0
leaq 0x3030(%rsp), %rdi
callq 0x3090
movq %rax, %rcx
movq 0x30c0(%rsp), %rax
movq %rcx, (%rax)
movq 0x30d0(%rsp), %rdi
callq 0x1030
movl 0x3030(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x30d8, %rsp           # imm = 0x30D8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: compiler_init
static void compiler_init(Compiler* c, FunctionType type, Parser* p) {
    const char* const fn_name =
        type == TYPE_SCRIPT ? "<script>" : p->previous.source;
    const size_t fn_name_len = type == TYPE_SCRIPT ? 8 : p->previous.source_len;
    LOG("fn_name=`%.*s` fn_name_len=%zu\n", (int)fn_name_len, fn_name,
        fn_name_len);

    c->enclosing = p->compiler;
    c->fn = NULL;
    c->fn_type = type;
    c->locals_len = 0;
    c->scope_depth = 0;
    c->fn = value_make_fn(fn_name, fn_name_len);

    p->compiler = c;

    Local* const local = &c->locals[c->locals_len++];
    local->depth = 0;
    local->name.source = "";
    local->name.source_len = 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
cmpl $0x1, 0x3c(%rsp)
jne 0x2e27
leaq 0x8960(%rip), %rax      # 0xb780
movq %rax, 0x10(%rsp)
jmp 0x2e35
movq 0x30(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x1, 0x3c(%rsp)
jne 0x2e52
movl $0x8, %eax
movq %rax, 0x8(%rsp)
jmp 0x2e60
movq 0x30(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2e6c
movq 0x30(%rsp), %rax
movq 0x80(%rax), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x3020(%rax)
movq 0x40(%rsp), %rax
movq $0x0, 0x3010(%rax)
movl 0x3c(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0x3018(%rax)
movq 0x40(%rsp), %rax
movl $0x0, 0x3000(%rax)
movq 0x40(%rsp), %rax
movq $0x0, 0x3008(%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x67e0
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x3010(%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x40(%rsp), %rax
movq 0x40(%rsp), %rdx
movl 0x3000(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x3000(%rdx)
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x18(%rsp), %rax
leaq 0xa72f(%rip), %rcx      # 0xd663
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: advance
static void advance(Parser* parser) {
    parser->previous = parser->current;

    while (true) {
        lex_scan_token(&parser->lex, &parser->current);
        if (parser->current.type != TOKEN_ERROR) {
            return;
        }

        error(parser, &parser->current, parser->current.source,
              parser->current.source_len);
    }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x58, %rdi
movq (%rsp), %rsi
addq $0x30, %rsi
movl $0x28, %edx
callq 0x1160
movq (%rsp), %rdi
addq $0x8, %rdi
movq (%rsp), %rsi
addq $0x30, %rsi
callq 0x1c60
movq (%rsp), %rax
cmpl $0x27, 0x50(%rax)
je 0x2f90
popq %rax
retq
movq (%rsp), %rdi
movq (%rsp), %rsi
addq $0x30, %rsi
movq (%rsp), %rax
movq 0x40(%rax), %rdx
movq (%rsp), %rax
movq 0x48(%rax), %rcx
callq 0x3100
jmp 0x2f6f
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: match
static bool match(Parser* parser, TokenType type) {
    if (!peek(parser, type)) {
        return false;
    }

    advance(parser);
    return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x31d0
testb $0x1, %al
jne 0x2fe6
movb $0x0, 0x17(%rsp)
jmp 0x2ff5
movq 0x8(%rsp), %rdi
callq 0x2f50
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: declaration
static void declaration(Parser* parser, Vm* vm) {
    if (match(parser, TOKEN_VAR)) {
        var_declaration(parser, vm);
    } else if (match(parser, TOKEN_FUN)) {
        fn_declaration(parser, vm);
    } else {
        statement(parser, vm);
    }

    if (parser->state == PARSER_STATE_PANIC_MODE) {
        sync(parser);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x25, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x3023
jmp 0x3034
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x31f0
jmp 0x306b
movq 0x10(%rsp), %rdi
movl $0x1c, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x3049
jmp 0x305a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3280
jmp 0x3069
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x32e0
jmp 0x306b
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
jne 0x307f
movq 0x10(%rsp), %rdi
callq 0x3410
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: compiler_end
static ObjFunction* compiler_end(Parser* parser) {
    emit_byte(parser, OP_NIL);
    emit_byte(parser, OP_RETURN);

    ObjFunction* const fn = parser->compiler->fn;
    parser->compiler = parser->compiler->enclosing;

    return fn;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x7, %esi
callq 0x3530
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x3530
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x3010(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
movq 0x3020(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: error
static void error(Parser* parser, const Token* token, const char* err,
                  size_t err_len) {
    switch (parser->state) {
        case PARSER_STATE_OK:
            LOG("new parser error, entering error mode err=`%.*s`\n",
                (int)err_len, err);
            parser->state = PARSER_STATE_ERROR;

            fprintf(stderr, "%zu:%zu:%.*s, got: `%.*s`\n", token->line,
                    token->column, (int)err_len, err, (int)token->source_len,
                    token->source);
            return;
        case PARSER_STATE_ERROR:
            LOG("new parser error, entering panic mode err=`%.*s`\n",
                (int)err_len, err);
            parser->state = PARSER_STATE_PANIC_MODE;
            return;
        case PARSER_STATE_PANIC_MODE:
        case PARSER_STATE_SYNCED:
            LOG("new parser error in panic mode, skipping err=`%.*s`\n",
                (int)err_len, err);
            return;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x3142
jmp 0x3129
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x31a7
jmp 0x3134
movl 0x14(%rsp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x31b8
jmp 0x31be
jmp 0x3144
jmp 0x3146
movq 0x30(%rsp), %rax
movl $0x1, (%rax)
movq 0xce98(%rip), %rax      # 0xfff0
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movl %eax, %r8d
movq 0x20(%rsp), %r9
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movl %eax, %r10d
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
leaq 0x85f4(%rip), %rsi      # 0xb789
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1140
jmp 0x31be
jmp 0x31a9
jmp 0x31ab
movq 0x30(%rsp), %rax
movl $0x2, (%rax)
jmp 0x31be
jmp 0x31ba
jmp 0x31bc
jmp 0x31be
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: var_declaration
static void var_declaration(Parser* parser, Vm* vm) {
    const uint8_t arg = variable_name(parser, vm, "Expected variable name");

    if (match(parser, TOKEN_EQUAL)) {
        expression(parser, vm);
    } else {
        emit_byte(parser, OP_NIL);
    }

    expect(parser, TOKEN_SEMICOLON,
           "Expected semicolon after variable declaration");

    define_variable(parser, arg);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x8595(%rip), %rdx      # 0xb7a4
callq 0x3490
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
movl $0xe, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x322d
jmp 0x323e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3500
jmp 0x324d
movq 0x10(%rsp), %rdi
movl $0x7, %esi
callq 0x3530
movq 0x10(%rsp), %rdi
movl $0x9, %esi
leaq 0x855d(%rip), %rdx      # 0xb7bb
callq 0x3980
movq 0x10(%rsp), %rdi
movzbl 0x7(%rsp), %esi
callq 0x39d0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: fn_declaration
static void fn_declaration(Parser* parser, Vm* vm) {
    const uint8_t global_i =
        variable_name(parser, vm, "Expected function name");
    compiler_local_mark_initialized(parser);
    LOG("localCount=%d\n", parser->compiler->locals_len);

    function(parser, vm, TYPE_FUNCTION);
    define_variable(parser, global_i);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x87e8(%rip), %rdx      # 0xba87
callq 0x3490
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5710
jmp 0x32b4
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x5770
movq 0x10(%rsp), %rdi
movzbl 0x7(%rsp), %esi
callq 0x39d0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: statement
static void statement(Parser* parser, Vm* vm) {
    if (match(parser, TOKEN_PRINT)) {
        print_stmt(parser, vm);
    } else if (match(parser, TOKEN_LEFT_BRACE)) {
        begin_scope(parser);
        block(parser, vm);
        end_scope(parser);
    } else if (match(parser, TOKEN_IF)) {
        if_stmt(parser, vm);
    } else if (match(parser, TOKEN_WHILE)) {
        while_stmt(parser, vm);
    } else if (match(parser, TOKEN_FOR)) {
        for_stmt(parser, vm);
    } else if (match(parser, TOKEN_RETURN)) {
        return_stmt(parser, vm);
    } else {
        expr_stmt(parser, vm);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x3303
jmp 0x3317
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5a20
jmp 0x3408
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x332c
jmp 0x3354
movq 0x10(%rsp), %rdi
callq 0x5890
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x59a0
movq 0x10(%rsp), %rdi
callq 0x5a70
jmp 0x3406
movq 0x10(%rsp), %rdi
movl $0x1d, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x3369
jmp 0x337d
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5b40
jmp 0x3404
movq 0x10(%rsp), %rdi
movl $0x26, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x3392
jmp 0x33a3
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5c30
jmp 0x3402
movq 0x10(%rsp), %rdi
movl $0x1b, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x33b8
jmp 0x33c9
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5d30
jmp 0x3400
movq 0x10(%rsp), %rdi
movl $0x21, %esi
callq 0x2fc0
testb $0x1, %al
jne 0x33de
jmp 0x33ef
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5f90
jmp 0x33fe
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6030
jmp 0x3400
jmp 0x3402
jmp 0x3404
jmp 0x3406
jmp 0x3408
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: sync
static void sync(Parser* parser) {
    parser->state = PARSER_STATE_SYNCED;

    while (parser->current.type != TOKEN_EOF) {
        if (parser->previous.type == TOKEN_SEMICOLON) {
            return;
        }

        switch (parser->current.type) {
            case TOKEN_CLASS:
            case TOKEN_FUN:
            case TOKEN_VAR:
            case TOKEN_FOR:
            case TOKEN_IF:
            case TOKEN_WHILE:
            case TOKEN_PRINT:
            case TOKEN_RETURN:
                return;
            default:
                // Do nothing.
                ;
        }

        advance(parser);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x3, (%rax)
movq 0x10(%rsp), %rax
cmpl $0x28, 0x50(%rax)
je 0x3489
movq 0x10(%rsp), %rax
cmpl $0x9, 0x78(%rax)
jne 0x343c
jmp 0x3489
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x18, %eax
je 0x3479
jmp 0x344f
movl 0xc(%rsp), %eax
addl $-0x1b, %eax
subl $0x3, %eax
jb 0x3479
jmp 0x345d
movl 0xc(%rsp), %eax
addl $-0x20, %eax
subl $0x2, %eax
jb 0x3479
jmp 0x346b
movl 0xc(%rsp), %eax
addl $-0x25, %eax
subl $0x1, %eax
ja 0x347b
jmp 0x3479
jmp 0x3489
jmp 0x347d
movq 0x10(%rsp), %rdi
callq 0x2f50
jmp 0x3424
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: variable_name
static uint8_t variable_name(Parser* parser, Vm* vm, const char err[]) {
    expect(parser, TOKEN_IDENTIFIER, err);

    declare_variable(parser);
    // Globals are resolved at runtime
    if (parser->compiler->scope_depth > 0) {
        return 0;
    }

    return make_identifier_constant(parser, vm);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x14, %esi
callq 0x3980
movq 0x18(%rsp), %rdi
callq 0x3a20
movq 0x18(%rsp), %rax
movq 0x80(%rax), %rax
cmpq $0x0, 0x3008(%rax)
jle 0x34de
movb $0x0, 0x27(%rsp)
jmp 0x34f1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3b30
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: expect
static void expect(Parser* parser, TokenType type, const char err[]) {
    if (parser->current.type == type) {
        advance(parser);
        return;
    }

    error_str_nul(parser, &parser->current, err);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0x39ab
movq 0x10(%rsp), %rdi
callq 0x2f50
jmp 0x39c2
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x30, %rsi
movq (%rsp), %rdx
callq 0x3bb0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: define_variable
static void define_variable(Parser* parser, uint8_t global_i) {
    // Skip locals
    if (parser->compiler->scope_depth > 0) {
        compiler_local_mark_initialized(parser);
        return;
    }
    emit_byte2(parser, OP_DEFINE_GLOBAL, global_i);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rax
cmpq $0x0, 0x3008(%rax)
jle 0x3a02
movq 0x10(%rsp), %rdi
callq 0x5710
jmp 0x3a16
movq 0x10(%rsp), %rdi
movl $0x10, %esi
movzbl 0xf(%rsp), %edx
callq 0x4ae0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: declare_variable
static void declare_variable(Parser* parser) {
    if (parser->compiler->scope_depth == 0) {
        return;
    }

    const Token* const name = &parser->previous;
    LOG("declaring var=%.*s\n", (int)name->source_len, name->source);

    // Prevent shadowing in the same scope
    for (int i = parser->compiler->locals_len - 1; i >= 0; i--) {
        Local* const local = &parser->compiler->locals[i];
        LOG("scope_depth=%jd local=%.*s local_i=%d\n",
            parser->compiler->scope_depth, (int)name->source_len, name->source,
            i);

        if (local->depth != -1 &&
            local->depth < parser->compiler->scope_depth) {
            break;
        }

        if (str_eq(local->name.source, local->name.source_len, name->source,
                   name->source_len)) {
            error_str_nul(
                parser, name,
                "Variable shadowing: existing variable in the same scope");
            return;
        }
    }

    compiler_add_local(parser, name);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rax
cmpq $0x0, 0x3008(%rax)
jne 0x3a44
jmp 0x3b2b
movq 0x20(%rsp), %rax
addq $0x58, %rax
movq %rax, 0x18(%rsp)
jmp 0x3a54
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rax
movl 0x3000(%rax), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x3b1c
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rax
movslq 0x14(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x3a97
movq 0x8(%rsp), %rax
cmpq $-0x1, 0x28(%rax)
je 0x3ac3
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
movq 0x80(%rcx), %rcx
cmpq 0x3008(%rcx), %rax
jge 0x3ac3
jmp 0x3b1c
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
callq 0x6500
testb $0x1, %al
jne 0x3af2
jmp 0x3b0a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x7ce6(%rip), %rdx      # 0xb7e9
callq 0x3bb0
jmp 0x3b2b
jmp 0x3b0c
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3a6d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3c10
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/gaultier[P]lox-c/parse.c
// Function: make_identifier_constant
static uint8_t make_identifier_constant(Parser* parser, Vm* vm) {
    ObjString* const os =
        value_make_string(&vm->objects, parser->previous.source_len);
    memcpy(os->s, parser->previous.source, os->len);

    return make_constant(parser, OBJ_VAL(os));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x40008, %rdi          # imm = 0x40008
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rsi
callq 0x6730
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rax
movq 0x68(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x1160
movq 0x20(%rsp), %rdi
movl $0x3, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x3cb0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)