LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_pick_hash_wk
uint8_t bloom_pick_hash_wk(uint8_t width, uint8_t hashes) {
  if (hashes < 1 || width < 8 || width > 48) { // invalid parameters
    return 255;
  } else if (hashes <= hash1sN && width >= 8 && width <= 16) { // hash1s
    return BFS_TYPE_OFFSET + hashes;
  } else if (hashes <= hash2bN && width >  8 && width <= 16) { // hash2b
    return BFS_TYPE_OFFSET + hash1sN + hashes;
  } else if (hashes <= hash2sN && width > 16 && width <= 32) { // hash2s
    return BFS_TYPE_OFFSET + hash1sN + hash2bN + hashes;
  } else if (hashes <= hash3sN && width > 32 && width <= 48) { // hash3s
    return BFS_TYPE_OFFSET + hash1sN + hash2bN + hash2sN + hashes;
  } else { // no suitable hash found
    return 255;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0x1, %eax
jl 0x93eb
movzbl -0x2(%rbp), %eax
cmpl $0x8, %eax
jl 0x93eb
movzbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jle 0x93f4
movb $-0x1, -0x1(%rbp)
jmp 0x9506
movzbl -0x3(%rbp), %eax
leaq 0x4efb(%rip), %rcx      # 0xe2fa
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x9427
movzbl -0x2(%rbp), %eax
cmpl $0x8, %eax
jl 0x9427
movzbl -0x2(%rbp), %eax
cmpl $0x10, %eax
jg 0x9427
movzbl -0x3(%rbp), %eax
addl $0x1, %eax
movb %al, -0x1(%rbp)
jmp 0x9506
movzbl -0x3(%rbp), %eax
leaq 0x4ed3(%rip), %rcx      # 0xe305
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x9466
movzbl -0x2(%rbp), %eax
cmpl $0x8, %eax
jle 0x9466
movzbl -0x2(%rbp), %eax
cmpl $0x10, %eax
jg 0x9466
leaq 0x4ea8(%rip), %rax      # 0xe2fa
movzbl (%rax), %eax
addl $0x1, %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x9506
movzbl -0x3(%rbp), %eax
leaq 0x4e1f(%rip), %rcx      # 0xe290
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x94ae
movzbl -0x2(%rbp), %eax
cmpl $0x10, %eax
jle 0x94ae
movzbl -0x2(%rbp), %eax
cmpl $0x20, %eax
jg 0x94ae
leaq 0x4e69(%rip), %rax      # 0xe2fa
movzbl (%rax), %eax
addl $0x1, %eax
leaq 0x4e67(%rip), %rcx      # 0xe305
movzbl (%rcx), %ecx
addl %ecx, %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x9506
movzbl -0x3(%rbp), %eax
leaq 0x4ca7(%rip), %rcx      # 0xe160
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jg 0x9502
movzbl -0x2(%rbp), %eax
cmpl $0x20, %eax
jle 0x9502
movzbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jg 0x9502
leaq 0x4e21(%rip), %rax      # 0xe2fa
movzbl (%rax), %eax
addl $0x1, %eax
leaq 0x4e1f(%rip), %rcx      # 0xe305
movzbl (%rcx), %ecx
addl %ecx, %eax
leaq 0x4d9e(%rip), %rcx      # 0xe290
movzbl (%rcx), %ecx
addl %ecx, %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x9506
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/hex.c
// Function: hex
unsigned char *
hex(unsigned char *buf, size_t buf_sz,
    unsigned char *hexed, size_t hexed_sz) {
  unsigned int i, j;
  --hexed_sz;
  for (i = j = 0; i < buf_sz && j < hexed_sz; ++i, j += 2) {
    snprintf(hexed+j, 3, "%02x", buf[i]);
  }
  hexed[j] = 0; // null terminate
  return hexed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x29(%rbp)
jae 0x9a2f
movl -0x28(%rbp), %eax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x9a38
jmp 0x9a74
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
movl $0x3, %esi
leaq 0x26bf(%rip), %rdx      # 0xc118
movb $0x0, %al
callq 0x10c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x9a12
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/mmapf.c
// Function: _bloomslice_mmapf_strerror
char * mmapf_strerror(int errnum) {
  if (errnum < MMAPF_EXFIRST) {
    return strerror(errnum);
  } else if (errnum < MMAPF_EXLAST) {
    return errstr[errnum-MMAPF_EXFIRST];
  } else {
    return errstr[0];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jge 0x9ab2
movl -0xc(%rbp), %edi
callq 0x1270
movq %rax, -0x8(%rbp)
jmp 0x9ae2
cmpl $0x3eb, -0xc(%rbp)      # imm = 0x3EB
jge 0x9ad7
movl -0xc(%rbp), %eax
subl $0x3e8, %eax            # imm = 0x3E8
movslq %eax, %rcx
leaq 0x5103(%rip), %rax      # 0xebd0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x9ae2
movq 0x50f2(%rip), %rax      # 0xebd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ryancdotorg[P]bloomslice/mmapf.c
// Function: _bloomslice_munmapf
int munmapf(mmapf_ctx *ctx) {
  // TODO error checking
  if (ctx->fd >= 0) {
    msync(ctx->mem, ctx->file_sz, MS_SYNC);
    fsync(ctx->fd);
    close(ctx->fd);
  }
  if (ctx->mem != NULL) {
    munmap(ctx->mem, ctx->mmap_sz);
  }
  ctx->file_sz = 0;
  ctx->mmap_sz = 0;
  ctx->mem = NULL;
  ctx->fd = -1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jl 0x9b37
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x4, %edx
callq 0x1090
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x11e0
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x10f0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9b55
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x11b0
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/tests/test_verify_traces.c
// Function: diff_array
static inline int diff_array(
        unsigned long s1Len,
        unsigned long s2Len,
        int8_t *a,
        int8_t *b_,
        parasail_result_t *result)
{
    unsigned long i = 0;
    unsigned long size = s1Len * s2Len;
    if ((result->flag & PARASAIL_FLAG_TRACE)
            && ((result->flag & PARASAIL_FLAG_STRIPED)
            ||  (result->flag & PARASAIL_FLAG_SCAN))) {
        int *b = parasail_striped_unwind(s1Len, s2Len, result, b_);
        for (i=0; i<size; ++i) {
            if (a[i] != b[i]) return 1;
        }
        free(b);
    }
    else {
        for (i=0; i<size; ++i) {
            if (a[i] != b_[i]) return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0x12aa04
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x12a998
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x12aa04
movq -0x10(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1fe9d0
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x12a9f9
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x12a9e9
movl $0x1, -0x4(%rbp)
jmp 0x12aa54
jmp 0x12a9eb
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x12a9bd
movq -0x48(%rbp), %rdi
callq 0x129140
jmp 0x12aa4d
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x12aa4b
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x12aa3b
movl $0x1, -0x4(%rbp)
jmp 0x12aa54
jmp 0x12aa3d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x12aa0c
jmp 0x12aa4d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/whoami.c
// Function: main
int main(int argc, char **argv){
    struct passwd *pw = getpwuid(geteuid());
    if(pw == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    puts(pw->pw_name);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1060
movl %eax, %edi
callq 0x1050
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1204
movq 0x2e34(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1080
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0xe10(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x1217
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_cond.c
// Function: alarm_insert
void alarm_insert(struct alarm *a)
{
	struct alarm **last, *next;

	last = &g_alarm_list;
	next = *last;
	while (next)
	{
		if (next->time >= a->time)
		{
			a->link = next;
			*last = a;
			break;
		}
		last = &next->link;
		next = next->link;
	}
	/* if hit end of list */
	if (!next)
	{
		*last = a;
		a->link = NULL;
	}

	/* if a new earlier alarm has come in, or if
	 * the alarm thread is idle, wake it up */
	if (g_current_alarm == 0 || a->time < g_current_alarm)
	{
		g_current_alarm = a->time;
		pthread_cond_signal(&g_alarm_cond);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2e75(%rip), %rax      # 0x40a8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1288
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x1273
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1288
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1242
cmpq $0x0, -0x18(%rbp)
jne 0x12a5
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x2e5b(%rip)      # 0x4108
je 0x12c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq 0x2e4a(%rip), %rax      # 0x4108
jge 0x12db
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2e39(%rip)      # 0x4108
leaq 0x2e02(%rip), %rdi      # 0x40d8
callq 0x10a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_cond.c
// Function: alarm_thread
void *alarm_thread(void *arg)
{
	struct alarm *a;
	struct timespec cond_time = {0};
	time_t now;
	bool expired;

	(void)arg;
	pthread_mutex_lock(&g_alarm_mutex);
	while (1)
	{
		g_current_alarm = 0;
		while (g_alarm_list == NULL)
			pthread_cond_wait(&g_alarm_cond, &g_alarm_mutex);

		a = g_alarm_list;
		g_alarm_list = a->link;
		now = time(NULL);
		expired = false;
		
		if (a->time > now)
		{
			cond_time.tv_sec = a->time;
			g_current_alarm = a->time;
			while (g_current_alarm == a->time)
			{
				int s = pthread_cond_timedwait(
					&g_alarm_cond, &g_alarm_mutex, &cond_time);
				if (s == ETIMEDOUT)
				{
					expired = true;
					break;
				}
			}
			if (!expired)
				alarm_insert(a);
		}
		else
			expired = true;

		if (expired)
		{
			printf("(%d) %s\n", a->seconds, a->message);
			free(a);
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
leaq 0x2d9d(%rip), %rdi      # 0x40b0
callq 0x1110
movq $0x0, 0x2de5(%rip) # 0x4108
cmpq $0x0, 0x2d7d(%rip)      # 0x40a8
jne 0x1342
leaq 0x2da4(%rip), %rdi      # 0x40d8
leaq 0x2d75(%rip), %rsi      # 0x40b0
callq 0x1040
jmp 0x1323
movq 0x2d5f(%rip), %rax      # 0x40a8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x2d4d(%rip)      # 0x40a8
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jle 0x13df
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x2d73(%rip)      # 0x4108
movq 0x2d6c(%rip), %rax      # 0x4108
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x13ce
leaq 0x2d2b(%rip), %rdi      # 0x40d8
leaq 0x2cfc(%rip), %rsi      # 0x40b0
leaq -0x20(%rbp), %rdx
callq 0x1100
movl %eax, -0x30(%rbp)
cmpl $0x6e, -0x30(%rbp)
jne 0x13cc
movb $0x1, -0x29(%rbp)
jmp 0x13ce
jmp 0x1395
testb $0x1, -0x29(%rbp)
jne 0x13dd
movq -0x10(%rbp), %rdi
callq 0x1220
jmp 0x13e3
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x140f
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rdx
addq $0x14, %rdx
leaq 0xc05(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x1318
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_cond.c
// Function: main
int main(void)
{
	int status;
	char line[128];
	struct alarm *a;
	pthread_t thread;

	status = pthread_create(&thread, NULL, alarm_thread, NULL);
	while (printf("Alarm> ") && fgets(line, sizeof(line), stdin))
	{
		if (strlen(line) <= 1)
			continue;

		if (!(a = malloc(sizeof(*a))))
		{
			fputs("Failed to allocate alarm\n", stderr);
			return EXIT_FAILURE;
		}
		if (sscanf(line, "%d %64[^\n]", &a->seconds, a->message) < 2)
		{
			fputs("Bad command\n", stderr);
			free(a);
		}
		else
		{
			pthread_mutex_lock(&g_alarm_mutex);
			a->time = time(NULL) + a->seconds;
			alarm_insert(a);
			pthread_mutex_unlock(&g_alarm_mutex);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x154(%rip), %rdx      # 0x12f0
movq %rcx, %rsi
callq 0x10f0
movl %eax, -0x8(%rbp)
leaq 0xbb7(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1060
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa1(%rbp)
je 0x1494
leaq -0x90(%rbp), %rdi
movq 0x2b5e(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movl $0x80, %esi
callq 0x1090
cmpq $0x0, %rax
setne %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x14a3
jmp 0x1592
leaq -0x90(%rbp), %rdi
callq 0x1050
cmpq $0x1, %rax
ja 0x14b7
jmp 0x144f
movl $0x58, %edi
callq 0x10d0
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
jne 0x14f0
movq 0x2b23(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xb36(%rip), %rdi       # 0x2015
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x1592
leaq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
addq $0x10, %rdx
movq -0x98(%rbp), %rcx
addq $0x14, %rcx
leaq 0xb1b(%rip), %rsi       # 0x202f
movb $0x0, %al
callq 0x10e0
cmpl $0x2, %eax
jge 0x1544
movq 0x2ad1(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xb09(%rip), %rdi       # 0x203a
callq 0x1070
movq -0x98(%rbp), %rdi
callq 0x1030
jmp 0x158d
leaq 0x2b65(%rip), %rdi      # 0x40b0
callq 0x1110
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq %rax, %rcx
movq -0x98(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x98(%rbp), %rdi
callq 0x1220
leaq 0x2b28(%rip), %rdi      # 0x40b0
callq 0x10c0
jmp 0x144f
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_08/date_conversion.c
// Function: main
int main(void)
{
  int day = day_of_year(2020, 10, 30);
  printf("day of the year: %d\n", day);

  int month_invalid = day_of_year(2020, 13, 1);
  if (month_invalid == -1)
  {
    printf("Warning: invalid month detected.\n");
  }

  int day_invalid = day_of_year(202, 12, 32);
  if (day_invalid == -2)
  {
    printf("Warning: invalid day detected.\n");
  }

  int month;
  int day_month;

  month_day(2020, 304, &month, &day_month);
  printf("month: %d, day: %d\n", month, day_month);

  month_day(2020, 366, &month, &day_month);
  printf("month: %d, day: %d\n", month, day_month);

  month_day(2020, 367, &month, &day_month);
  printf("month: %d, day: %d\n", month, day_month);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x7e4, %edi            # imm = 0x7E4
movl $0xa, %esi
movl $0x1e, %edx
callq 0x1260
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xe94(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0x7e4, %edi            # imm = 0x7E4
movl $0xd, %esi
movl $0x1, %edx
callq 0x1260
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x11a2
leaq 0xe7e(%rip), %rdi       # 0x2019
movb $0x0, %al
callq 0x1030
movl $0xca, %edi
movl $0xc, %esi
movl $0x20, %edx
callq 0x1260
movl %eax, -0x10(%rbp)
cmpl $-0x2, -0x10(%rbp)
jne 0x11cd
leaq 0xe75(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1030
movl $0x7e4, %edi            # imm = 0x7E4
movl $0x130, %esi            # imm = 0x130
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1380
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xe6a(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
movl $0x7e4, %edi            # imm = 0x7E4
movl $0x16e, %esi            # imm = 0x16E
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1380
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xe3f(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
movl $0x7e4, %edi            # imm = 0x7E4
movl $0x16f, %esi            # imm = 0x16F
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x1380
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
leaq 0xe14(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/paeq128/ref/encrypt.cpp
// Function: crypto_aead_encrypt_no_nonce(unsigned char*, unsigned long long*, unsigned char const*, unsigned long long, unsigned char const*, unsigned long long, unsigned char const*, unsigned char*, unsigned char const*)
int crypto_aead_encrypt_no_nonce(
		 unsigned char *c, unsigned long long *clen,
		 const unsigned char *m, unsigned long long mlen,
		 const unsigned char *ad, unsigned long long adlen,
		 const unsigned char *nsec,
		 unsigned char *npub,
		 const unsigned char *k
		 )
		 //Generates nonce out of plaintext and AD and put it into npub

	 {
		 Init();//Initializing GF(256) multiplication table for AES

		 if (clen == NULL)
			 return -1;
		 if ((mlen == 0) && (adlen == 0))
		 {
			 *clen = 0;
			 return 0;
		 }

		 //Assume that we do encryption and/or authentication so we need a key and a ciphertext pointer valid
		 if ((k == NULL) || (c == NULL))
			 return -2;

		 GenerateNonceRef(npub, m, mlen, ad, adlen, k);
		 return PAEQ128_ref_encrypt(c, clen, m, mlen, ad, adlen, npub, k);
	 }

// Assembly:
subq $0x48, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
callq 0x1070
cmpq $0x0, 0x30(%rsp)
jne 0x291b
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x29b8
cmpq $0x0, 0x20(%rsp)
jne 0x2941
cmpq $0x0, 0x10(%rsp)
jne 0x2941
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x44(%rsp)
jmp 0x29b8
cmpq $0x0, 0x60(%rsp)
je 0x2951
cmpq $0x0, 0x38(%rsp)
jne 0x295b
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
jmp 0x29b8
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x1050
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x58(%rsp), %r10
movq 0x60(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1080
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch5/lua_pcall.c
// Function: main
int main() {

  lua_State *L = luaL_newstate();
  luaL_openlibs(L);

  lua_register(L, "my_error_handler", my_error_handler);
  lua_register(L, "fn_that_throws",   fn_that_throws);
  lua_register(L, "middle_fn",        middle_fn);

  // Call middle_fn().
  lua_pushcfunction(L, my_error_handler);
  lua_getglobal(L, "middle_fn");
  int status = lua_pcall(L, 0, 0, -2);
  if (status != LUA_OK) {
    // Print the error.
    printf("Looks like lua_pcall() caught an error:\n%s\n",
           lua_tostring(L, -1));
    // Pop the error message from the stack.
    lua_pop(L, 1);
  }

  printf("Done!\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x21470
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21830
movq -0x10(%rbp), %rdi
leaq -0xec(%rip), %rsi       # 0x55e0
xorl %edx, %edx
callq 0x6b60
movq -0x10(%rbp), %rdi
leaq 0x2d947(%rip), %rsi     # 0x33025
callq 0x74a0
movq -0x10(%rbp), %rdi
leaq -0xbe(%rip), %rsi       # 0x5630
xorl %edx, %edx
callq 0x6b60
movq -0x10(%rbp), %rdi
leaq 0x2d916(%rip), %rsi     # 0x33016
callq 0x74a0
movq -0x10(%rbp), %rdi
leaq -0xb0(%rip), %rsi       # 0x5660
xorl %edx, %edx
callq 0x6b60
movq -0x10(%rbp), %rdi
leaq 0x2d914(%rip), %rsi     # 0x33036
callq 0x74a0
movq -0x10(%rbp), %rdi
leaq -0x152(%rip), %rsi      # 0x55e0
xorl %edx, %edx
callq 0x6b60
movq -0x10(%rbp), %rdi
leaq 0x2d8f2(%rip), %rsi     # 0x33036
callq 0x6d70
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %eax, %eax
movl %eax, %r9d
movl %edx, %esi
movq %r9, %r8
callq 0x7ed0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x579d
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x6490
movq %rax, %rsi
leaq 0x2d8b8(%rip), %rdi     # 0x33040
movb $0x0, %al
callq 0x5170
movq -0x10(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x5a80
leaq 0x2d8c8(%rip), %rdi     # 0x3306c
movb $0x0, %al
callq 0x5170
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0x2/sign_main.c
// Function: main
int main(void)
{
#define WORDMAX 100
	char word[WORDMAX], sig[WORDMAX];

	while (scanf("%s", word) != EOF) {
		sign(word, strlen(word), sig);
		printf("%s %s\n", sig, word);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rsi
leaq 0xcd7(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1080
cmpl $-0x1, %eax
je 0x137d
leaq -0x70(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1030
movq -0xe8(%rbp), %rdi
movl %eax, %esi
leaq -0xe0(%rbp), %rdx
callq 0x11a0
leaq -0xe0(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq 0xc93(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1040
jmp 0x1322
xorl %eax, %eax
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/chunk.c
// Function: init_chunk
void init_chunk(Chunk* chunk) {
    chunk->count = 0;
    chunk->capacity = 0;
    chunk->code = NULL;
    chunk->lines = NULL;
    init_value_array(&chunk->constants);
    chunk->labels = NULL;
    chunk->labels_count = 0;
    chunk->labels_capacity = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x9a80
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/chunk.c
// Function: write_chunk
void write_chunk(Chunk* chunk, size_t add_size, uint8_t* bytes, size_t line) {
    if (chunk->capacity < chunk->count + add_size) {
        size_t old_capacity = chunk->capacity;
        chunk->capacity = GROW_CAPACITY(old_capacity);
        chunk->code = GROW_ARRAY(uint8_t, chunk->code,
            old_capacity, chunk->capacity);
        chunk->lines = GROW_ARRAY(size_t, chunk->lines,
            old_capacity, chunk->capacity);
    }

    for (int i = (int) add_size - 1; i >= 0; i--) {
        chunk->lines[chunk->count] = line;
        chunk->code[chunk->count] = bytes[i];
        chunk->count++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
addq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x43c1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x4352
movl $0x8, %eax
movq %rax, -0x38(%rbp)
jmp 0x435d
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x0, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x0, %rdx
callq 0x79e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x79e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x441e
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x43cb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/chunk.c
// Function: free_chunk
void free_chunk(Chunk* chunk) {
    FREE_ARRAY(uint8_t, chunk->code, chunk->capacity);
    FREE_ARRAY(size_t, chunk->lines, chunk->capacity);
    free_value_array(&chunk->constants);
    init_chunk(chunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x79e0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x79e0
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x9b80
movq -0x8(%rbp), %rdi
callq 0x4280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/chunk.c
// Function: set_chunk_label_offset
void set_chunk_label_offset(Chunk* chunk, size_t label, int32_t offset) {
    if (label > UINT16_MAX) {
        fprintf(stderr, "Label too large\n");
    }

    while (chunk->labels_capacity < label + 1) {
        size_t old_capacity = chunk->labels_capacity;
        chunk->labels_capacity = GROW_CAPACITY(old_capacity);
        chunk->labels = GROW_ARRAY(int32_t, chunk->labels,
            old_capacity, chunk->labels_capacity);
    }

    chunk->labels[label] = offset;

    if (chunk->labels_count <= label) {
        chunk->labels_count = label + 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jbe 0x4515
movq 0x14aec(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0x7af6(%rip), %rsi      # 0xc004
movb $0x0, %al
callq 0x40f0
jmp 0x4517
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x458f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x454a
movl $0x8, %eax
movq %rax, -0x28(%rbp)
jmp 0x4555
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x2, %rsi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdx
shlq $0x2, %rdx
callq 0x79e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0x4517
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x10(%rbp), %rax
ja 0x45bf
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/common.c
// Function: read_file_ex
size_t read_file_ex(const char* path, uint8_t** dst_buf, size_t dst_buf_size, size_t dst_buf_offset, bool binary) {
    FILE* fd = fopen(path, binary ? "rb" : "r");
    if (fd == NULL) {
        fprintf(stderr, "Failed to open file\n");
        return 0;
    }

    uint8_t* cursor = *dst_buf + dst_buf_offset;
    size_t read_target_size = 0x1000;
    size_t buf_size = dst_buf_size;
    size_t read_size = 0;

    do {
        buf_size += read_target_size;
        *dst_buf = realloc(*dst_buf, buf_size);
        cursor = *dst_buf + dst_buf_offset + buf_size - dst_buf_size - read_target_size;
        read_size = fread(cursor, 1, read_target_size, fd);
    } while (read_size == read_target_size);

    return buf_size - dst_buf_size - read_target_size + read_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
movb -0x29(%rbp), %cl
leaq 0x85a1(%rip), %rsi      # 0xcb9f
leaq 0x7a10(%rip), %rax      # 0xc015
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x4140
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4641
movq 0x149cd(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0x79eb(%rip), %rsi      # 0xc018
movb $0x0, %al
callq 0x40f0
movq $0x0, -0x8(%rbp)
jmp 0x46eb
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x1000, -0x48(%rbp)    # imm = 0x1000
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0x4130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq -0x28(%rbp), %rax
addq -0x50(%rbp), %rax
xorl %ecx, %ecx
subq -0x20(%rbp), %rcx
addq %rcx, %rax
xorl %ecx, %ecx
subq -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x4070
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x4668
movq -0x50(%rbp), %rax
subq -0x20(%rbp), %rax
subq -0x48(%rbp), %rax
addq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/common.c
// Function: write_file
size_t write_file(const char* path, uint8_t* src_buf, size_t src_buf_size, bool binary) {
    FILE* fd = fopen(path, binary ? "wb" : "w");
    if (fd == NULL) {
        fprintf(stderr, "Failed to open file\n");
        return 0;
    }

    uint8_t* cursor = src_buf;
    size_t write_block_size = 0x1000;
    size_t write_size = 0;

    if (src_buf_size < write_block_size) {
        write_block_size = src_buf_size;
    }

    do {
        cursor = src_buf + write_size;
        write_size = fwrite(cursor, write_block_size, 1, fd) * write_block_size;
    } while (write_size == write_block_size && (size_t) (cursor - src_buf) < src_buf_size);

    return (size_t) (cursor - src_buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %cl
leaq 0x91e4(%rip), %rsi      # 0xd94d
leaq 0x78bd(%rip), %rax      # 0xc02d
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x4140
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x47ac
movq 0x14862(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0x7880(%rip), %rsi      # 0xc018
movb $0x0, %al
callq 0x40f0
movq $0x0, -0x8(%rbp)
jmp 0x483d
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x1000, -0x40(%rbp)    # imm = 0x1000
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x47d6
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x47d8
movq -0x18(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl $0x1, %edx
callq 0x4170
imulq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x49(%rbp)
jne 0x4827
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x47d8
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: unary
static void unary(bool can_assign) {
    UNUSED(can_assign);

    TokenType operator_type = parser.previous.type;

    parse_precedence(PREC_UNARY);

    switch (operator_type) {
        case TOKEN_BANG: {
            int ret = alloc_register();
            uint8_t reg = (uint8_t) ret;

            if (ret < 0) {
                error_alloc_register();
            } else {
                emit_stack_pop(reg);
                emit_opcode(OP_REV);
                emit_register(reg);
                emit_stack_push(reg);

                free_register(reg);
            }
            break;
        }
        case TOKEN_MINUS: {
            int ret = alloc_register();
            uint8_t reg = (uint8_t) ret;
            
            if (ret < 0) {
                error_alloc_register();
            } else {
                emit_stack_pop(reg);
                emit_opcode(OP_MULI);
                emit_register(reg);
                emit_dword(-1);
                emit_stack_push(reg);

                free_register(reg);
            }
            break;
        }
        default:
            return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl 0x1490a(%rip), %eax     # 0x195d0
movl %eax, -0x8(%rbp)
movl $0x8, %edi
callq 0x5820
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x5, %eax
je 0x4d39
jmp 0x4ce0
movl -0x1c(%rbp), %eax
subl $0xc, %eax
jne 0x4d8e
jmp 0x4cee
callq 0x5bc0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x4d09
callq 0x5c30
jmp 0x4d37
movzbl -0xd(%rbp), %edi
callq 0x5cb0
movl $0x12, %edi
callq 0x5ce0
movzbl -0xd(%rbp), %edi
callq 0x5d80
movzbl -0xd(%rbp), %edi
callq 0x5b30
movzbl -0xd(%rbp), %edi
callq 0x5c50
jmp 0x4d90
callq 0x5bc0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x15(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x4d54
callq 0x5c30
jmp 0x4d8c
movzbl -0x15(%rbp), %edi
callq 0x5cb0
movl $0x1d, %edi
callq 0x5ce0
movzbl -0x15(%rbp), %edi
callq 0x5d80
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x5ef0
movzbl -0x15(%rbp), %edi
callq 0x5b30
movzbl -0x15(%rbp), %edi
callq 0x5c50
jmp 0x4d90
jmp 0x4d90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: and_
static void and_(bool can_assign) {
    UNUSED(can_assign);

    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;
    size_t label = take_label();

    emit_stack_pop(reg);

    emit_conditional_jump_ri(OP_JMPI_EQ, reg, CONSTANT_FALSE, label);

    parse_precedence(PREC_AND);

    set_label_here(label);

    free_register(reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
callq 0x5bc0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x5275
callq 0x5c30
jmp 0x52bf
movl -0x8(%rbp), %eax
movb %al, -0x9(%rbp)
callq 0x5f80
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %edi
callq 0x5cb0
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rcx
movl $0x2d, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x6080
movl $0x3, %edi
callq 0x5820
movq -0x18(%rbp), %rdi
callq 0x6040
movzbl -0x9(%rbp), %edi
callq 0x5c50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: or_
static void or_(bool can_assign) {
    UNUSED(can_assign);

    int ret = alloc_register();

    if (ret < 0) {
        error_alloc_register();
        return;
    }

    uint8_t reg = (uint8_t) ret;
    size_t label = take_label();

    emit_stack_peek(reg);

    emit_conditional_jump_ri(OP_JMPI_NEQ, reg, CONSTANT_FALSE, label);

    emit_stack_pop(reg);

    parse_precedence(PREC_OR);

    set_label_here(label);

    free_register(reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
callq 0x5bc0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x52f5
callq 0x5c30
jmp 0x5348
movl -0x8(%rbp), %eax
movb %al, -0x9(%rbp)
callq 0x5f80
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %edi
callq 0x60d0
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rcx
movl $0x2f, %edi
xorl %edx, %edx
movzbl %al, %esi
callq 0x6080
movzbl -0x9(%rbp), %edi
callq 0x5cb0
movl $0x2, %edi
callq 0x5820
movq -0x18(%rbp), %rdi
callq 0x6040
movzbl -0x9(%rbp), %edi
callq 0x5c50
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: literal
static void literal(bool can_assign) {
    UNUSED(can_assign);

    switch (parser.previous.type) {
        case TOKEN_FALSE:
            emit_stack_push_value(CONSTANT_FALSE);
            break;
        case TOKEN_TRUE:
            emit_stack_push_value(CONSTANT_TRUE);
            break;
        default:
            error("Unknown literal token");
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl 0x141ca(%rip), %eax     # 0x195d0
movl %eax, -0x8(%rbp)
subl $0x1f, %eax
je 0x541a
jmp 0x5410
movl -0x8(%rbp), %eax
subl $0x26, %eax
je 0x5423
jmp 0x542f
xorl %edi, %edi
callq 0x5e00
jmp 0x543b
movl $0x1, %edi
callq 0x5e00
jmp 0x543b
leaq 0x6f66(%rip), %rdi      # 0xc39c
callq 0x57b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: advance
static void advance(void) {
    parser.previous2 = parser.previous;
    parser.previous = parser.current;

    while (true) {
        parser.current = scan_token();

        if (parser.current.type != TOKEN_ERROR) {
            break;
        }

        error_at_current(parser.current.start);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x13f09(%rip), %rsi     # 0x195a8
movq %rsi, %rdi
addq $0x50, %rdi
addq $0x28, %rsi
movl $0x28, %edx
callq 0x4110
leaq 0x13eed(%rip), %rsi     # 0x195a8
movq %rsi, %rdi
addq $0x28, %rdi
movl $0x28, %edx
callq 0x4110
leaq -0x28(%rbp), %rdi
callq 0x8b00
leaq 0x13ecc(%rip), %rdi     # 0x195a8
leaq -0x28(%rbp), %rsi
movl $0x28, %edx
callq 0x4110
cmpl $0x29, 0x13eb7(%rip)    # 0x195a8
je 0x56f5
jmp 0x5703
movq 0x13eb4(%rip), %rdi     # 0x195b0
callq 0x5910
jmp 0x56cc
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: match
static bool match(TokenType type) {
    if (!check(type)) {
        return false;
    }

    advance();
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x5e80
testb $0x1, %al
jne 0x572d
movb $0x0, -0x1(%rbp)
jmp 0x5736
callq 0x5690
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: declaration
static void declaration(void) {
    if (match(TOKEN_FUNCTION)) {
        function_declaration();
    } else if (match(TOKEN_LET)) {
        let_declaration();
    } else {
        statement();
    }

    if (parser.panic_mode) {
        synchronize();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x21, %edi
callq 0x5710
testb $0x1, %al
jne 0x5764
jmp 0x576b
callq 0x6350
jmp 0x5789
movl $0x27, %edi
callq 0x5710
testb $0x1, %al
jne 0x577b
jmp 0x5782
callq 0x6370
jmp 0x5787
callq 0x6420
jmp 0x5789
testb $0x1, 0x13e91(%rip)     # 0x19621
je 0x5797
callq 0x64d0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: consume
static void consume(TokenType type, const char* message) {
    if (parser.current.type == type) {
        advance();
        return;
    }

    error_at_current(message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x13da3(%rip), %eax     # 0x195a8
cmpl -0x4(%rbp), %eax
jne 0x5811
callq 0x5690
jmp 0x581a
movq -0x10(%rbp), %rdi
callq 0x5910
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: parse_precedence
static void parse_precedence(Precedence precedence) {
    advance();
    ParseFn prefix_rule = get_rule(parser.previous.type)->prefix;
    if (prefix_rule == NULL) {
        error("Expected expression");
        return;
    }

    bool can_assign = precedence <= PREC_ASSIGNMENT;
    prefix_rule(can_assign);

    while (precedence <= get_rule(parser.current.type)->precedence) {
        advance();
        ParseFn infix_rule = get_rule(parser.previous.type)->infix;
        infix_rule(can_assign);
    }

    if (can_assign && match(TOKEN_EQUAL)) {
        error("Invalid target for assignment");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
callq 0x5690
movl 0x13d9a(%rip), %edi     # 0x195d0
callq 0x58f0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x585a
leaq 0x6952(%rip), %rdi      # 0xc1a2
callq 0x57b0
jmp 0x58dc
cmpl $0x1, -0x4(%rbp)
setbe %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %edi
callq *%rax
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl 0x13d27(%rip), %edi     # 0x195a8
callq 0x58f0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl 0x10(%rcx), %eax
ja 0x58ba
callq 0x5690
movl 0x13d34(%rip), %edi     # 0x195d0
callq 0x58f0
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %edi
callq *%rax
jmp 0x5875
testb $0x1, -0x11(%rbp)
je 0x58dc
movl $0xe, %edi
callq 0x5710
testb $0x1, %al
jne 0x58d0
jmp 0x58dc
leaq 0x68df(%rip), %rdi      # 0xc1b6
callq 0x57b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: error_at
static void error_at(Token* token, const char* message) {
    if (parser.panic_mode) {
        return;
    }

    parser.panic_mode = true;

    fprintf(stderr, "[%lu:%lu] Error", token->line, token->column);

    if (token->type == TOKEN_EOF) {
        fprintf(stderr, " at end");
    } else if (token->type == TOKEN_ERROR) {
        // Nothing
    } else {
        fprintf(stderr, " at '%.*s'", (int) token->length, token->start);
    }

    fprintf(stderr, ": %s\n", message);
    parser.had_error = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, 0x13cca(%rip)     # 0x19621
je 0x595e
jmp 0x5a0a
movb $0x1, 0x13cbc(%rip)     # 0x19621
movq 0x13684(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0x684e(%rip), %rsi      # 0xc1d4
movb $0x0, %al
callq 0x40f0
movq -0x8(%rbp), %rax
cmpl $0x2a, (%rax)
jne 0x59b0
movq 0x13653(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0x683d(%rip), %rsi      # 0xc1e4
movb $0x0, %al
callq 0x40f0
jmp 0x59e7
movq -0x8(%rbp), %rax
cmpl $0x29, (%rax)
jne 0x59bb
jmp 0x59e5
movq 0x1362e(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x680e(%rip), %rsi      # 0xc1ec
movb $0x0, %al
callq 0x40f0
jmp 0x59e7
movq 0x13602(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x67fb(%rip), %rsi      # 0xc1f7
movb $0x0, %al
callq 0x40f0
movb $0x1, 0x13c16(%rip)     # 0x19620
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: get_opcode_definition_from_token
static const OpcodeDefinition* get_opcode_definition_from_token(Token* name) {
    char str[64];
    size_t len = name->length > 63 ? 63 : name->length;
    strncpy(str, name->start, len);
    str[len] = '\0';
    return get_opcode_definition_by_name(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3f, 0x10(%rax)
jbe 0x5a32
movl $0x3f, %eax
movq %rax, -0x60(%rbp)
jmp 0x5a3e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x58(%rbp), %rdx
callq 0x4040
movq -0x58(%rbp), %rax
movb $0x0, -0x50(%rbp,%rax)
leaq -0x50(%rbp), %rdi
callq 0x7c60
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jtuu[P]quesler/src/compiler.c
// Function: resolve_function
static Function* resolve_function(Token* name) {
    for (size_t i = 0; i < parser.functions_count; i++) {
        if (parser.functions[i]->name.length == name->length) {
            if (!strncmp(parser.functions[i]->name.start, name->start, name->length)) {
                return parser.functions[i];
            }
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x13ca1(%rip), %rax     # 0x19740
jae 0x5b12
movq 0x13c90(%rip), %rax     # 0x19738
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x5b02
movq 0x13c73(%rip), %rax     # 0x19738
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x4050
cmpl $0x0, %eax
jne 0x5b00
movq 0x13c46(%rip), %rax     # 0x19738
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5b1a
jmp 0x5b02
jmp 0x5b04
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5a94
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)