LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/output.cc
// Function: Output::setFunction(std::ostream*, Function const*)
void Output::setFunction(std::ostream *f, const Function *func) {
  w32(f, func->arguments.size());
  for (auto &arg : func->arguments) {
    setArgument(f, arg);
  }
  setRef(f, &func->retType);
  w32(f, func->signature.size());
  for (auto sig : func->signature) {
    w32(f, sig);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rax
subq (%rdx), %rax
shrq $0x4, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3290
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x8e7b
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8fdc
addq $0x50, %r12
jmp 0x8e62
leaq 0x18(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8cf4
movq 0x50(%r14), %rax
subq 0x48(%r14), %rax
movl %eax, %ecx
shrl $0x2, %ecx
leaq 0xc(%rsp), %rsi
movb %cl, (%rsi)
movl %eax, %ecx
shrl $0xa, %ecx
movb %cl, 0x1(%rsi)
movl %eax, %ecx
shrl $0x12, %ecx
movb %cl, 0x2(%rsi)
shrq $0x1a, %rax
movb %al, 0x3(%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3290
movq 0x48(%r14), %r15
movq 0x50(%r14), %r12
cmpq %r12, %r15
je 0x8ef4
leaq 0x4(%rsp), %r14
movl (%r15), %eax
movl %eax, 0x4(%rsp)
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
addq $0x4, %r15
cmpq %r12, %r15
jne 0x8ed4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/output.cc
// Function: Output::setField(std::ostream*, Field const&)
void Output::setField(std::ostream *f, const Field &field) {
  ws(f, field.key);
  w8(f, field.kind);
  w32(f, field.size);
  switch (field.kind) {
    case isRef:
      setRef(f, field.ref);
      break;
    case isStruct:
      setStruct(f, field.theStruct);
      break;
    case isUnion:
      setStruct(f, field.theStruct);
      break;
    default:
      std::cerr << "Unknown field type" << std::endl;
      exit(-1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rax
movl $0xff, %r12d
cmpq %r12, %rax
cmovbq %rax, %r12
leaq 0x2(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
movq (%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3290
movb 0x20(%r15), %al
leaq 0x3(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
movl 0x24(%r15), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3290
movl 0x20(%r15), %eax
cmpl $0x3, %eax
je 0x8f9b
cmpl $0x4, %eax
je 0x8f9b
cmpl $0x5, %eax
jne 0x8fb6
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8cf4
jmp 0x8faa
movq 0x28(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8dbc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5033(%rip), %rdi      # 0xdff0
leaq 0x14a6(%rip), %rsi      # 0xa46a
callq 0x31e0
movq %rax, %rdi
callq 0x3120
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3250
nop
// File: /workspace/github_c_makefile_star2_O3/ryancdotorg[P]bloomslice/bfstool.c
// Function: chkmalloc
static void * _chkmalloc(size_t size, unsigned char *file, unsigned int line) {
  void *ptr = malloc(size);
  if (ptr == NULL) {
    bail(1, "[!] malloc(%zu) failed at %s:%u: %s\n", size, file, line, strerror(errno));
  }
  return ptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1170
testq %rax, %rax
je 0x2b54
popq %rbx
retq
movq %rbx, %rdi
callq 0x1b8e
// File: /workspace/github_c_makefile_star2_O3/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_width_to_mask
uint64_t bloom_width_to_mask(uint8_t width) {
  if (width == BFS_TYPE_LEGACY) {
      return 1;
  } else if (width == BFS_TYPE_SINGLE) {
      return 1;
  } else if (width < 8 || width > 48) {
      return 0;
  } else {
      return (1ULL<<width) - 1;
  }
}

// Assembly:
movl $0x1, %eax
cmpb $0x2, %dil
jb 0x5c91
leal -0x31(%rdi), %eax
cmpb $-0x29, %al
jae 0x5c82
xorl %eax, %eax
retq
movq $-0x1, %rax
movl %edi, %ecx
shlq %cl, %rax
notq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_size_to_mask
uint64_t bloom_size_to_mask(size_t sz) {
  size_t bz = sz - FOOTER_BYTES;
  if (sz == LEGACY_BYTES) {
    return 1;
  } else if (sz == SINGLE_BYTES) {
    return 1;
  } else if (bz & (bz - 1)) {
    return 0;
  } else {
    return (bz<<3) - 1;
  }
}

// Assembly:
movl $0x1, %eax
cmpq $0x1d, %rdi
je 0x5cbe
cmpq $0x20000000, %rdi       # imm = 0x20000000
je 0x5cbe
leaq -0x9(%rdi), %rax
addq $-0xa, %rdi
testq %rdi, %rax
je 0x5cb6
xorl %eax, %eax
retq
leaq -0x1(,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
sete %al
leal -0x31(%rdi), %ecx
cmpb $-0x29, %cl
setb %cl
orb %al, %cl
movb $-0x1, %al
je 0x5d2e
retq
leaq 0x55c5(%rip), %rcx      # 0xb2fa
movb (%rcx), %cl
cmpb %sil, %cl
setb %dl
cmpb $0x11, %dil
setae %r8b
orb %dl, %r8b
je 0x5d98
leaq 0x55b4(%rip), %rdx      # 0xb305
movb (%rdx), %dl
cmpb %sil, %dl
setb %r8b
leal -0x9(%rdi), %r9d
cmpb $0x8, %r9b
setae %r9b
orb %r8b, %r9b
jne 0x5d70
addb %cl, %sil
jmp 0x5d98
leaq 0x5519(%rip), %r8       # 0xb290
movb (%r8), %r8b
cmpb %sil, %r8b
setb %r9b
leal -0x11(%rdi), %r10d
cmpb $0x10, %r10b
setae %r10b
orb %r9b, %r10b
jne 0x5d9e
addb %cl, %sil
addb %dl, %sil
incb %sil
movl %esi, %eax
retq
cmpb $0x21, %dil
jb 0x5d2d
leaq 0x53b5(%rip), %rdi      # 0xb160
cmpb %sil, (%rdi)
jb 0x5d2d
addb %cl, %sil
addb %r8b, %dl
addb %sil, %dl
incb %dl
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ryancdotorg[P]bloomslice/bloomutl.c
// Function: bloom_pick_hash_wi
uint8_t bloom_pick_hash_wi(uint8_t width, uint64_t items, uint8_t *k) {
  double bits = 1ULL<<width;
  unsigned int opt = round((log(2.0) * bits) / (double)items);
  uint8_t kOpt = opt < 256 ? (opt > 0 ? opt : 1) : 255;

  if (width < 8 || width > 48) { // invalid parameters
    return 255;
  } else if (kOpt <= hash1sN && width >= 8 && width <= 16) { // hash1s
    *k = kOpt;
    return bloom_pick_hash_wk(width, kOpt);
  } else if (width == 8) {
    *k = hash1sN;
    return bloom_pick_hash_wk(width, hash1sN);
  } else if (kOpt <= hash2bN && width >  8 && width <= 16) { // hash2b
    *k = kOpt;
    return bloom_pick_hash_wk(width, kOpt);
  } else if (width <= 16) {
    *k = hash2bN;
    return bloom_pick_hash_wk(width, hash2bN);
  } else if (kOpt <= hash2sN && width > 16 && width <= 32) { // hash2s
    *k = kOpt;
    return bloom_pick_hash_wk(width, kOpt);
  } else if (width <= 32) {
    *k = hash2sN;
    return bloom_pick_hash_wk(width, hash2sN);
  } else if (kOpt <= hash3sN && width > 32 && width <= 48) { // hash3s
    *k = kOpt;
    return bloom_pick_hash_wk(width, kOpt);
  } else if (width <= 48) {
    *k = hash3sN;
    return bloom_pick_hash_wk(width, hash3sN);
  } else { // no suitable hash found
    return 255;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %edi, %ebx
movq %rbx, %rax
shlq $0x34, %rax
movabsq $0x3fe62e42fefa39ef, %rcx # imm = 0x3FE62E42FEFA39EF
addq %rax, %rcx
movq %rcx, %xmm0
movq %rsi, %xmm1
punpckldq 0x123f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1247(%rip), %xmm1     # 0x7040
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
callq 0x1050
cvttsd2si %xmm0, %rcx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovael %ecx, %eax
movl $0xff, %ecx
cmpl %ecx, %eax
cmovael %ecx, %eax
leal -0x31(%rbx), %ecx
cmpb $-0x29, %cl
jae 0x5e3a
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x54b9(%rip), %rcx      # 0xb2fa
movb (%rcx), %dl
cmpb $0x10, %bl
ja 0x5e5a
movzbl %dl, %esi
cmpl %esi, %eax
ja 0x5e5a
movb %al, (%r14)
movzbl %bl, %edi
movzbl %al, %esi
jmp 0x5e8f
cmpb $0x8, %bl
jne 0x5e6c
movb %dl, (%r14)
movzbl (%rcx), %esi
movl $0x8, %edi
jmp 0x5e8f
leaq 0x5492(%rip), %rcx      # 0xb305
movb (%rcx), %dl
cmpb $0x10, %bl
ja 0x5e81
movzbl %dl, %esi
cmpl %esi, %eax
jbe 0x5e4f
cmpb $0x10, %bl
ja 0x5e9b
movb %dl, (%r14)
movzbl (%rcx), %esi
movzbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d19
leaq 0x53ee(%rip), %rcx      # 0xb290
movb (%rcx), %dl
cmpb $0x20, %bl
ja 0x5eb0
movzbl %dl, %esi
cmpl %esi, %eax
jbe 0x5e4f
cmpb $0x20, %bl
jbe 0x5e86
leaq 0x52a4(%rip), %rcx      # 0xb160
movzbl (%rcx), %edx
cmpl %edx, %eax
jbe 0x5e4f
movb %dl, (%r14)
jmp 0x5e89
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
testq %rsi, %rsi
sete %al
decq %r14
sete %cl
orb %al, %cl
jne 0x6110
movq %rsi, %r15
movq %rdi, %r12
movl $0x2, %ebp
movl $0x1, %r13d
xorl %edi, %edi
xorl %eax, %eax
addq %rbx, %rdi
movzbl (%r12,%rax), %ecx
movl $0x3, %esi
leaq 0x1fc6(%rip), %rdx      # 0x80b8
xorl %eax, %eax
callq 0x10d0
movl %r13d, %eax
movl %ebp, %edi
cmpq %r15, %rax
jae 0x6112
addl $0x2, %ebp
incl %r13d
cmpq %rdi, %r14
ja 0x60de
jmp 0x6112
xorl %edi, %edi
movb $0x0, (%rbx,%rdi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x3e7, %edi            # imm = 0x3E7
jg 0x6135
jmp 0x1270
cmpl $0x3ea, %edi            # imm = 0x3EA
ja 0x6152
addl $0xfffffc18, %edi       # imm = 0xFFFFFC18
leaq 0x1f76(%rip), %rcx      # 0x80c0
movslq (%rcx,%rdi,4), %rax
addq %rcx, %rax
retq
leaq 0x1f77(%rip), %rax      # 0x80d0
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
js 0x6185
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
movl $0x4, %edx
callq 0x10a0
movl 0x18(%rbx), %edi
callq 0x11e0
movl 0x18(%rbx), %edi
callq 0x1110
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6196
movq 0x8(%rbx), %rsi
callq 0x11b0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
leaq 0x2ddf(%rip), %r14      # 0x40a8
movq %r14, %rdi
callq 0x1100
leaq 0x2df8(%rip), %r15      # 0x40d0
leaq 0xd25(%rip), %r12       # 0x2004
movq $0x0, 0x2e16(%rip) # 0x4100
movq 0x2daf(%rip), %r13      # 0x40a0
testq %r13, %r13
jne 0x1303
movq %r15, %rdi
movq %r14, %rsi
callq 0x1040
jmp 0x12ea
movq (%r13), %rax
movq %rax, 0x2d92(%rip)      # 0x40a0
xorl %edi, %edi
callq 0x10a0
movq 0x8(%r13), %rcx
cmpq %rax, %rcx
jle 0x1349
movq %rcx, (%rsp)
movq %rcx, 0x2dd7(%rip)      # 0x4100
movq 0x2dd0(%rip), %rax      # 0x4100
cmpq 0x8(%r13), %rax
jne 0x1368
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10f0
cmpl $0x6e, %eax
jne 0x1329
movl 0x10(%r13), %esi
leaq 0x14(%r13), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x1060
movq %r13, %rdi
callq 0x1030
jmp 0x12df
movq %r13, %rdi
callq 0x124c
jmp 0x12df
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
leaq -0xe1(%rip), %rdx       # 0x12ac
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10e0
leaq 0xc68(%rip), %rdi       # 0x200d
xorl %eax, %eax
callq 0x1060
testl %eax, %eax
je 0x147e
movq 0x2c1d(%rip), %rbp      # 0x3fd8
leaq 0x10(%rsp), %rbx
leaq 0xc46(%rip), %r14       # 0x200d
leaq 0xc61(%rip), %r15       # 0x202f
leaq 0x2cd3(%rip), %r12      # 0x40a8
movq (%rbp), %rdx
movq %rbx, %rdi
movl $0x80, %esi
callq 0x1080
testq %rax, %rax
je 0x147b
movq %rbx, %rdi
callq 0x1050
cmpq $0x2, %rax
jb 0x145a
movl $0x58, %edi
callq 0x10c0
testq %rax, %rax
je 0x1493
movq %rax, %r13
leaq 0x10(%rax), %rdx
movq %rax, %rcx
addq $0x14, %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10d0
cmpl $0x1, %eax
jle 0x1471
movq %r12, %rdi
callq 0x1100
xorl %edi, %edi
callq 0x10a0
movslq 0x10(%r13), %rcx
addq %rax, %rcx
movq %rcx, 0x8(%r13)
movq %r13, %rdi
callq 0x124c
movq %r12, %rdi
callq 0x10b0
xorl %r13d, %r13d
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
testl %eax, %eax
jne 0x13d5
jmp 0x147e
movq %r13, %rdi
callq 0x1120
jmp 0x145a
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1144
movl $0x1, %r13d
jmp 0x147e
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
callq 0x1060
testq %r13, %r13
je 0x1de7
movq %rbx, %rax
orq %r15, %rax
je 0x1dee
movq 0x50(%rsp), %r9
testq %r9, %r9
sete %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jne 0x1df8
movq 0x48(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1040
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
callq 0x1070
addq $0x18, %rsp
jmp 0x1dfc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1df8
movq $0x0, (%r13)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x14bcd
movq %rax, %rbx
movq %rax, %rdi
callq 0x14dd0
leaq -0xad(%rip), %r14       # 0x47ac
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x53c4
leaq 0x1c7b8(%rip), %rsi     # 0x21025
movq %rbx, %rdi
callq 0x5808
leaq -0x9c(%rip), %rsi       # 0x47e0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x53c4
leaq 0x1c789(%rip), %rsi     # 0x21016
movq %rbx, %rdi
callq 0x5808
leaq -0x93(%rip), %rsi       # 0x4809
movq %rbx, %rdi
xorl %edx, %edx
callq 0x53c4
leaq 0x1c789(%rip), %r15     # 0x21036
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5808
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x53c4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5493
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5ceb
testl %eax, %eax
je 0x4918
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x5075
leaq 0x1c73f(%rip), %rdi     # 0x21040
movq %rax, %rsi
xorl %eax, %eax
callq 0x4170
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4a69
leaq 0x1c74d(%rip), %rdi     # 0x2106c
callq 0x40c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0xd7f(%rip), %rdi       # 0x2004
movq %rsp, %rsi
xorl %eax, %eax
callq 0x1080
cmpl $-0x1, %eax
je 0x12e1
movq %rsp, %rbx
leaq 0x70(%rsp), %r14
leaq 0xd64(%rip), %r15       # 0x2007
leaq 0xd5a(%rip), %r12       # 0x2004
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x119c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1040
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
cmpl $-0x1, %eax
jne 0x12aa
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x8890
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %r13
movq (%rdi), %rax
addq %rsi, %rax
cmpq %rax, %r13
jae 0x45d3
leaq (,%r13,2), %rax
cmpq $0x8, %r13
movl $0x8, %edx
cmovaeq %rax, %rdx
movq %rdx, 0x8(%r12)
movq 0x10(%r12), %rdi
movq %r13, %rsi
callq 0x75a4
movq %rax, 0x10(%r12)
movq 0x8(%r12), %rdx
movq 0x18(%r12), %rdi
shlq $0x3, %r13
shlq $0x3, %rdx
movq %r13, %rsi
callq 0x75a4
movq %rax, 0x18(%r12)
testl %r15d, %r15d
jle 0x4614
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
movq (%r12), %rax
incq %r15
movq 0x18(%r12), %rcx
movq %rbx, (%rcx,%rax,8)
movb -0x2(%r14,%r15), %al
movq (%r12), %rcx
movq 0x10(%r12), %rdx
movb %al, (%rdx,%rcx)
movq (%r12), %rax
incq %rax
movq %rax, (%r12)
decq %r15
cmpq $0x1, %r15
ja 0x45e6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
xorl %edx, %edx
callq 0x75a4
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
shlq $0x3, %rsi
xorl %edx, %edx
callq 0x75a4
leaq 0x20(%rbx), %r14
movq %r14, %rdi
callq 0x8903
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %r14, %rdi
callq 0x8890
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x10000, %rsi          # imm = 0x10000
jae 0x4706
leaq 0x1(%r14), %r15
movq 0x38(%rbx), %rax
movq 0x48(%rbx), %rsi
cmpq %r15, %rsi
jae 0x46ef
movl $0x8, %r12d
leaq (%rsi,%rsi), %rdx
cmpq $0x8, %rsi
cmovbq %r12, %rdx
movq %rdx, 0x48(%rbx)
shlq $0x2, %rsi
shlq $0x2, %rdx
movq %rax, %rdi
callq 0x75a4
movq %rax, 0x38(%rbx)
movq 0x48(%rbx), %rsi
cmpq %r15, %rsi
jb 0x46c2
movl %ebp, (%rax,%r14,4)
cmpq %r14, 0x40(%rbx)
ja 0x46fd
movq %r15, 0x40(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x4190
jmp 0x46ab
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x5906(%rip), %rax      # 0xa031
leaq 0x646d(%rip), %rsi      # 0xab9f
testl %r8d, %r8d
cmovneq %rax, %rsi
callq 0x4140
testq %rax, %rax
je 0x479d
movq %rax, %r12
addq $0x1000, %r14           # imm = 0x1000
xorl %r13d, %r13d
movl $0x1000, %ebp           # imm = 0x1000
leaq (%r14,%r13), %rsi
movq (%r15), %rdi
callq 0x4130
movq %rax, (%r15)
leaq (%rbx,%r13), %rdi
addq %rax, %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r12, %rcx
callq 0x4080
addq %rbp, %r13
cmpq %rbp, %rax
je 0x4755
addq %r13, %rax
addq $-0x1000, %rax          # imm = 0xF000
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x41ac
xorl %eax, %eax
jmp 0x478e
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x5881(%rip), %rax      # 0xa049
leaq 0x717e(%rip), %rsi      # 0xb94d
testl %ecx, %ecx
cmovneq %rax, %rsi
callq 0x4140
testq %rax, %rax
je 0x4826
movq %rax, %r15
movl $0x1000, %r12d          # imm = 0x1000
cmpq %r12, %rbx
cmovbq %rbx, %r12
xorl %ecx, %ecx
movq %rcx, %r13
leaq (%r14,%rcx), %rdi
movl $0x1, %edx
movq %r12, %rsi
movq %r15, %rcx
callq 0x4170
cmpq %rbx, %r13
jae 0x4819
imulq %r12, %rax
movq %r12, %rcx
cmpq %r12, %rax
je 0x47f1
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x41c8
xorl %r13d, %r13d
jmp 0x4819
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x12801(%rip), %ebx     # 0x175d0
movl $0x8, %edi
callq 0x5ff5
cmpl $0xc, %ebx
je 0x4e07
cmpl $0x5, %ebx
jne 0x4f41
xorl %r14d, %r14d
leaq 0x127b7(%rip), %r15     # 0x175a8
cmpb $0x0, 0x7a(%r14,%r15)
jne 0x4e45
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x4df1
jmp 0x4e29
xorl %r14d, %r14d
leaq 0x12797(%rip), %r15     # 0x175a8
cmpb $0x0, 0x7a(%r14,%r15)
jne 0x4ebc
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x4e11
leaq 0x127a0(%rip), %rdi     # 0x175d0
leaq 0x54c5(%rip), %rsi      # 0xa2fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x608e
movb $0x0, 0x7a(%r14,%r15)
incl 0x12747(%rip)           # 0x17598
movzbl %r14b, %ebx
movl %ebx, %edi
callq 0x6150
leaq 0xa(%rsp), %rdx
movb $0x1d, (%rdx)
movq 0x12735(%rip), %rdi     # 0x175a0
movq 0x12776(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0xb(%rsp), %rdx
movb %r14b, (%rdx)
movq 0x12715(%rip), %rdi     # 0x175a0
movq 0x12756(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0xc(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
movq 0x126f2(%rip), %rdi     # 0x175a0
movq 0x12733(%rip), %rcx     # 0x175e8
movl $0x4, %esi
jmp 0x4f0e
movb $0x0, 0x7a(%r14,%r15)
incl 0x126d0(%rip)           # 0x17598
movzbl %r14b, %ebx
movl %ebx, %edi
callq 0x6150
leaq 0x8(%rsp), %rdx
movb $0x12, (%rdx)
movq 0x126be(%rip), %rdi     # 0x175a0
movq 0x126ff(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0x9(%rsp), %rdx
movb %r14b, (%rdx)
movq 0x1269e(%rip), %rdi     # 0x175a0
movq 0x126df(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
movl %ebx, %edi
callq 0x6104
cmpb $0x0, 0x7a(%r14,%r15)
je 0x4f35
leaq 0x126a7(%rip), %rdi     # 0x175d0
leaq 0x53e8(%rip), %rsi      # 0xa318
callq 0x608e
movb $0x1, 0x7a(%r14,%r15)
decl 0x12657(%rip)           # 0x17598
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
leaq 0x11f57(%rip), %r15     # 0x175a8
cmpb $0x0, 0x7a(%r14,%r15)
jne 0x5682
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x5651
leaq 0x11f64(%rip), %rdi     # 0x175d0
leaq 0x4c89(%rip), %rsi      # 0xa2fc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x608e
movb $0x0, 0x7a(%r14,%r15)
incl 0x11f0a(%rip)           # 0x17598
movq 0x12093(%rip), %rbx     # 0x17728
incq %rbx
movq %rbx, 0x12089(%rip)     # 0x17728
cmpq $0xffff, %rbx           # imm = 0xFFFF
jbe 0x56bb
leaq 0x11f21(%rip), %rdi     # 0x175d0
leaq 0x4c85(%rip), %rsi      # 0xa33b
callq 0x608e
movzbl %r14b, %ebp
movl %ebp, %edi
callq 0x6150
movl $0x2d, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x63a0
movl $0x3, %edi
callq 0x5ff5
movq 0x11eba(%rip), %rdi     # 0x175a0
movswl (%rdi), %edx
movq %rbx, %rsi
callq 0x4692
cmpb $0x1, 0x7a(%r14,%r15)
jne 0x570c
leaq 0x11ed0(%rip), %rdi     # 0x175d0
leaq 0x4c11(%rip), %rsi      # 0xa318
callq 0x608e
movb $0x1, 0x7a(%r14,%r15)
decl 0x11e80(%rip)           # 0x17598
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
leaq 0x11e74(%rip), %r15     # 0x175a8
cmpb $0x0, 0x7a(%r14,%r15)
jne 0x5765
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x5734
leaq 0x11e81(%rip), %rdi     # 0x175d0
leaq 0x4ba6(%rip), %rsi      # 0xa2fc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x608e
movb $0x0, 0x7a(%r14,%r15)
incl 0x11e27(%rip)           # 0x17598
movq 0x11fb0(%rip), %rbx     # 0x17728
incq %rbx
movq %rbx, 0x11fa6(%rip)     # 0x17728
cmpq $0xffff, %rbx           # imm = 0xFFFF
jbe 0x579e
leaq 0x11e3e(%rip), %rdi     # 0x175d0
leaq 0x4ba2(%rip), %rsi      # 0xa33b
callq 0x608e
movzbl %r14b, %ebp
movl %ebp, %edi
callq 0x6150
movl %ebp, %edi
callq 0x6104
movl $0x2f, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x63a0
movl %ebp, %edi
callq 0x6150
movl $0x2, %edi
callq 0x5ff5
movq 0x11dc9(%rip), %rdi     # 0x175a0
movswl (%rdi), %edx
movq %rbx, %rsi
callq 0x4692
cmpb $0x1, 0x7a(%r14,%r15)
jne 0x57fd
leaq 0x11ddf(%rip), %rdi     # 0x175d0
leaq 0x4b20(%rip), %rsi      # 0xa318
callq 0x608e
movb $0x1, 0x7a(%r14,%r15)
decl 0x11d8f(%rip)           # 0x17598
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq 0x11aef(%rip), %rax     # 0x175f0
movq %rax, 0x11b10(%rip)     # 0x17618
movups 0x11ad1(%rip), %xmm0    # 0x175e0
movups %xmm0, 0x11af2(%rip)    # 0x17608
movups 0x11ab3(%rip), %xmm0    # 0x175d0
movups %xmm0, 0x11ad4(%rip)    # 0x175f8
movups 0x11a7d(%rip), %xmm0    # 0x175a8
movups %xmm0, 0x11a9e(%rip)    # 0x175d0
movups 0x11a7f(%rip), %xmm0    # 0x175b8
movups %xmm0, 0x11aa0(%rip)    # 0x175e0
movq 0x11a81(%rip), %rax     # 0x175c8
movq %rax, 0x11aa2(%rip)     # 0x175f0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x7efa
movq 0x20(%rbx), %rax
movq %rax, 0x11a64(%rip)     # 0x175c8
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x11a46(%rip)    # 0x175b8
movups %xmm0, 0x11a2f(%rip)    # 0x175a8
cmpl $0x29, 0x11a28(%rip)    # 0x175a8
jne 0x5bcf
leaq 0x11a1f(%rip), %rbx     # 0x175a8
movq %rsp, %r14
movq 0x11a1d(%rip), %rsi     # 0x175b0
movq %rbx, %rdi
callq 0x608e
movq %r14, %rdi
callq 0x7efa
movq 0x20(%rsp), %rax
movq %rax, 0x11a19(%rip)     # 0x175c8
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups %xmm1, 0x119f9(%rip)    # 0x175b8
movups %xmm0, 0x119e2(%rip)    # 0x175a8
cmpl $0x29, 0x119db(%rip)    # 0x175a8
je 0x5b8c
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x5af3
movl 0x115ca(%rip), %eax     # 0x175d0
leaq (%rax,%rax,2), %rax
leaq 0x110cf(%rip), %r14     # 0x170e0
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0x6075
xorl %edi, %edi
cmpl $0x2, %ebx
setb %dil
callq *%rax
movl 0x1157d(%rip), %eax     # 0x175a8
leaq (%rax,%rax,2), %rcx
cmpl %ebx, 0x10(%r14,%rcx,8)
jb 0x6057
xorl %ebp, %ebp
cmpl $0x2, %ebx
setb %bpl
callq 0x5af3
movl 0x11586(%rip), %eax     # 0x175d0
leaq (%rax,%rax,2), %rax
movl %ebp, %edi
callq *0x8(%r14,%rax,8)
jmp 0x6025
cmpl $0x2, %ebx
setae %cl
cmpl $0xe, %eax
setne %al
orb %cl, %al
jne 0x6089
callq 0x5af3
leaq 0x4183(%rip), %rsi      # 0xa1f6
jmp 0x607c
leaq 0x4166(%rip), %rsi      # 0xa1e2
leaq 0x1154d(%rip), %rdi     # 0x175d0
popq %rbx
popq %r14
popq %rbp
jmp 0x608e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x1168b(%rip), %r12     # 0x17740
testq %r12, %r12
je 0x60ef
movq %rsi, %rbx
movq %rdi, %r14
movq 0x11671(%rip), %r13     # 0x17738
xorl %ebp, %ebp
movq (%r13,%rbp,8), %r15
cmpq %rbx, 0x10(%r15)
jne 0x60e7
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4060
testl %eax, %eax
je 0x60f2
incq %rbp
cmpq %rbp, %r12
jne 0x60c9
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: emit_opcode
static void emit_opcode(uint16_t opcode) {
    uint8_t first_byte = (uint8_t) (opcode >> 8);
    if (first_byte == EXTENDED_OPCODE_TABLE1 || first_byte == EXTENDED_OPCODE_TABLE2) {
        EMIT(uint16_t, opcode);
    } else {
        EMIT(uint8_t, (uint8_t) opcode);
    }
}

// Assembly:
pushq %rax
movl %edi, %eax
andl $0xfe00, %eax           # imm = 0xFE00
cmpl $0xf800, %eax           # imm = 0xF800
jne 0x61c8
leaq 0x6(%rsp), %rdx
movw %di, (%rdx)
movq 0x113e6(%rip), %rdi     # 0x175a0
movq 0x11427(%rip), %rcx     # 0x175e8
movl $0x2, %esi
jmp 0x61e3
leaq 0x5(%rsp), %rdx
movb %dil, (%rdx)
movq 0x113c9(%rip), %rdi     # 0x175a0
movq 0x1140a(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: emit_stack_push_value
static void emit_stack_push_value(int32_t val) {
    int ret = alloc_register();

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

    uint8_t reg = (uint8_t) ret;

    emit_leti(reg, val);
    emit_stack_push(reg);

    free_register(reg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorl %r14d, %r14d
leaq 0x113a9(%rip), %r15     # 0x175a8
cmpb $0x0, 0x7a(%r14,%r15)
jne 0x622f
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x61ff
leaq 0x113b6(%rip), %rdi     # 0x175d0
leaq 0x40db(%rip), %rsi      # 0xa2fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x608e
movb $0x0, 0x7a(%r14,%r15)
incl 0x1135d(%rip)           # 0x17598
leaq 0xa(%rsp), %rdx
movb $0x9, (%rdx)
movq 0x11356(%rip), %rdi     # 0x175a0
movq 0x11397(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0xb(%rsp), %rdx
movb %r14b, (%rdx)
movq 0x11336(%rip), %rdi     # 0x175a0
movq 0x11377(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0xc(%rsp), %rdx
movl %ebx, (%rdx)
movq 0x11317(%rip), %rdi     # 0x175a0
movq 0x11358(%rip), %rcx     # 0x175e8
movl $0x4, %esi
callq 0x4564
movzbl %r14b, %edi
callq 0x6104
cmpb $0x0, 0x7a(%r14,%r15)
je 0x62be
leaq 0x1131e(%rip), %rdi     # 0x175d0
leaq 0x405f(%rip), %rsi      # 0xa318
callq 0x608e
movb $0x1, 0x7a(%r14,%r15)
decl 0x112ce(%rip)           # 0x17598
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: emit_conditional_jump_rr
static void emit_conditional_jump_rr(uint16_t opcode, uint8_t reg1, uint8_t reg2, size_t label) {
    emit_opcode(opcode);
    emit_register(reg1);
    emit_register(reg2);
    emit_word((int16_t) label);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
callq 0x619c
leaq 0xc(%rsp), %rdx
movb %r14b, (%rdx)
movq 0x112a8(%rip), %rdi     # 0x175a0
movq 0x112e9(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0xd(%rsp), %rdx
movb %bpl, (%rdx)
movq 0x11288(%rip), %rdi     # 0x175a0
movq 0x112c9(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0xe(%rsp), %rdx
movw %bx, (%rdx)
movq 0x11268(%rip), %rdi     # 0x175a0
movq 0x112a9(%rip), %rcx     # 0x175e8
movl $0x2, %esi
callq 0x4564
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: emit_conditional_jump_ri
static void emit_conditional_jump_ri(uint16_t opcode, uint8_t reg, int32_t val, size_t label) {
    emit_opcode(opcode);
    emit_register(reg);
    emit_dword(val);
    emit_word((int16_t) label);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
callq 0x619c
leaq 0x1(%rsp), %rdx
movb %bpl, (%rdx)
movq 0x111e4(%rip), %rdi     # 0x175a0
movq 0x11225(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x111c1(%rip), %rdi     # 0x175a0
movq 0x11202(%rip), %rcx     # 0x175e8
movl $0x4, %esi
callq 0x4564
leaq 0x2(%rsp), %rdx
movw %bx, (%rdx)
movq 0x111a1(%rip), %rdi     # 0x175a0
movq 0x111e2(%rip), %rcx     # 0x175e8
movl $0x2, %esi
callq 0x4564
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: let_declaration
static void let_declaration(void) {
    int ret = parse_variable("Expected variable name");

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

    uint8_t reg = (uint8_t) ret;

    bool initialized = false;

    if (match(TOKEN_EQUAL)) {
        expression();
        initialized = true;
    } else {
        emit_stack_push_value(0);
    }

    consume(TOKEN_SEMICOLON, "Expected ';' after variable declaration");

    Local* local = &current->locals[current->local_count - 1];
    define_variable(reg, local);

    local->initialized = initialized;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x40f0(%rip), %rdi      # 0xa512
callq 0x6cdc
testl %eax, %eax
js 0x6449
movl %eax, %ebx
movl 0x11175(%rip), %ebp     # 0x175a8
cmpl $0xe, %ebp
jne 0x6460
callq 0x5af3
movl $0x1, %edi
callq 0x5ff5
jmp 0x6467
leaq 0x11180(%rip), %rdi     # 0x175d0
leaq 0x3ea5(%rip), %rsi      # 0xa2fc
popq %rbx
popq %r14
popq %rbp
jmp 0x608e
xorl %edi, %edi
callq 0x61ea
cmpl $0x7, 0x1113a(%rip)     # 0x175a8
jne 0x6477
callq 0x5af3
jmp 0x648a
leaq 0x1112a(%rip), %rdi     # 0x175a8
leaq 0x40a4(%rip), %rsi      # 0xa529
callq 0x608e
movq 0x110f7(%rip), %rax     # 0x17588
movq 0x3000(%rax), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rcx,%rax), %r14
addq $-0x30, %r14
movl 0x3008(%rax), %eax
testl %eax, %eax
jle 0x64c7
movb $0x1, 0x2d(%r14)
movb %bl, 0x2e(%r14)
movl %eax, 0x28(%r14)
movzbl %bl, %edi
callq 0x6150
cmpl $0xe, %ebp
sete 0x2c(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: emit_void_return
static void emit_void_return(void) {
    emit_stack_push_value(0);

    if (parser.current_function_label != entry_point_label) {
        emit_stack_swap();
    }

    emit_opcode(OP_RET);
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x61ea
movq 0x108b2(%rip), %rax     # 0x17750
cmpq 0x106eb(%rip), %rax     # 0x17590
je 0x6eac
callq 0x6f69
leaq 0x7(%rsp), %rdx
movb $0x1, (%rdx)
movq 0x106e5(%rip), %rdi     # 0x175a0
movq 0x10726(%rip), %rcx     # 0x175e8
movl $0x1, %esi
callq 0x4564
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: end_scope
static void end_scope(void) {
    current->scope_depth--;

    while (current->local_count > 0 && current->locals[current->local_count - 1].depth > current->scope_depth) {
        free_register(current->locals[current->local_count - 1].reg);
        current->local_count--;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x106ab(%rip), %rax     # 0x17588
decl 0x3008(%rax)
movq 0x3000(%rax), %rcx
testq %rcx, %rcx
je 0x6f5d
leaq 0x106b2(%rip), %r15     # 0x175a8
leaq 0x106d3(%rip), %rbx     # 0x175d0
leaq 0x3414(%rip), %r14      # 0xa318
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movl -0x8(%rcx,%rax), %edx
cmpl 0x3008(%rax), %edx
jle 0x6f5d
addq %rax, %rcx
addq $-0x30, %rcx
movzbl 0x2e(%rcx), %r12d
cmpb $0x1, 0x7a(%r12,%r15)
jne 0x6f3e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x608e
movq 0x1064a(%rip), %rax     # 0x17588
decl 0x10654(%rip)           # 0x17598
movb $0x1, 0x7a(%r12,%r15)
movq 0x3000(%rax), %rcx
decq %rcx
movq %rcx, 0x3000(%rax)
jne 0x6f04
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/jtuu[P]quesler/src/compiler.c
// Function: emit_stack_swap
static void emit_stack_swap(void) {
    int ret = alloc_register();

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

    uint8_t reg1 = (uint8_t) ret;

    ret = alloc_register();

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

    uint8_t reg2 = (uint8_t) ret;

    emit_stack_pop(reg1);
    emit_stack_pop(reg2);
    emit_stack_push(reg1);
    emit_stack_push(reg2);

    free_register(reg1);
    free_register(reg2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r15d, %r15d
leaq 0x1062d(%rip), %r14     # 0x175a8
cmpb $0x0, 0x7a(%r15,%r14)
jne 0x6f91
incq %r15
cmpq $0x100, %r15            # imm = 0x100
jne 0x6f7b
jmp 0x6fec
movb $0x0, 0x7a(%r15,%r14)
movl 0x105fb(%rip), %eax     # 0x17598
leal 0x1(%rax), %ecx
movl %ecx, 0x105f2(%rip)     # 0x17598
xorl %r12d, %r12d
cmpb $0x0, 0x7a(%r12,%r14)
jne 0x7007
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x6fa9
cmpb $0x1, 0x7a(%r15,%r14)
jne 0x6fe0
leaq 0x10604(%rip), %rdi     # 0x175d0
leaq 0x3345(%rip), %rsi      # 0xa318
callq 0x608e
movl 0x105ba(%rip), %eax     # 0x17598
decl %eax
movb $0x1, 0x7a(%r15,%r14)
movl %eax, 0x105ac(%rip)     # 0x17598
leaq 0x105dd(%rip), %rdi     # 0x175d0
leaq 0x3302(%rip), %rsi      # 0xa2fc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x608e
movb $0x0, 0x7a(%r12,%r14)
addl $0x2, %eax
movl %eax, 0x10582(%rip)     # 0x17598
movl $0xff, %ebx
movl %r15d, %ebp
andl %ebx, %ebp
movl %ebp, %edi
callq 0x6150
andl %r12d, %ebx
movl %ebx, %edi
callq 0x6150
movl %ebp, %edi
callq 0x6104
movl %ebx, %edi
callq 0x6104
cmpb $0x0, 0x7a(%r15,%r14)
je 0x705a
leaq 0x10582(%rip), %rdi     # 0x175d0
leaq 0x32c3(%rip), %rsi      # 0xa318
callq 0x608e
movb $0x1, 0x7a(%r15,%r14)
movl 0x10532(%rip), %eax     # 0x17598
decl %eax
movl %eax, 0x1052a(%rip)     # 0x17598
cmpb $0x1, 0x7a(%r12,%r14)
jne 0x708f
leaq 0x10553(%rip), %rdi     # 0x175d0
leaq 0x3294(%rip), %rsi      # 0xa318
callq 0x608e
movl 0x10509(%rip), %eax     # 0x17598
movb $0x1, 0x7a(%r12,%r14)
decl %eax
movl %eax, 0x104fb(%rip)     # 0x17598
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq