LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_destroy
void vector_destroy(Vector vec) {
	// Αν υπάρχει συνάρτηση destroy_value, την καλούμε για όλα τα στοιχεία
	if (vec->destroy_value != NULL)
		for (int i = 0; i < vec->size; i++)
			vec->destroy_value(vec->array[i].value);

	// Πρέπει να κάνουμε free τόσο τον πίνακα όσο και το struct!
	free(vec->array);
	free(vec);			// τελευταίο το vec!
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x59b0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x59ae
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x597e
jmp 0x59b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2270
movq -0x8(%rbp), %rdi
callq 0x2270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_first
VectorNode vector_first(Vector vec) {
	if (vec->size == 0)
		return VECTOR_BOF;
	else	
		return &vec->array[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x59ec
movq $0x0, -0x8(%rbp)
jmp 0x59f7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_last
VectorNode vector_last(Vector vec) {
	if (vec->size == 0)
		return VECTOR_EOF;
	else
		return &vec->array[vec->size-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x5a1c
movq $0x0, -0x8(%rbp)
jmp 0x5a3b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_next
VectorNode vector_next(Vector vec, VectorNode node) {
	if (node == &vec->array[vec->size-1])
		return VECTOR_EOF;
	else
		return node + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x5a8a
movq $0x0, -0x8(%rbp)
jmp 0x5a96
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_previous
VectorNode vector_previous(Vector vec, VectorNode node) {
	if (node == &vec->array[0])
		return VECTOR_EOF;
	else
		return node - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq %rcx, %rax
jne 0x5ac6
movq $0x0, -0x8(%rbp)
jmp 0x5ad2
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_find_node
VectorNode vector_find_node(Vector vec, Pointer value, CompareFunc compare) {
	// Διάσχιση του vector
	for (int i = 0; i < vec->size; i++)
		if (compare(vec->array[i].value, value) == 0)
			return &vec->array[i];		// βρέθηκε

	return VECTOR_EOF;				// δεν υπάρχει
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5b6a
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x5b5d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5b72
jmp 0x5b5f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b1b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/xping.c
// Function: target_mark
void
target_mark(struct target *t, int seq, int ch)
{
	if (ch == '.' && t->res[seq % NUM] != ' ')
		t->res[seq % NUM] = ':';
	else
		t->res[seq % NUM] = ch;
	if (a_flag && ch == '.') {
		if (a_flag == 1)
			bell();
		else if (a_flag >=2 && t->npkts >= 4 &&
		    t->res[(seq-3) % NUM] != '.' &&
		    t->res[(seq-2) % NUM] != '.' &&
		    t->res[(seq-1) % NUM] == '.' &&
		    t->res[(seq-0) % NUM] == '.')
			bell();
	}

	if (seq == t->npkts - 1)
		ui_update(t);
	else
		ui_update(NULL); /* this is a late reply, need full update to redraw this */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x2e, -0x10(%rbp)
jne 0x25ad
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x25ad
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movb $0x3a, 0x44(%rax,%rcx)
jmp 0x25d6
movl -0x10(%rbp), %eax
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movl %edx, %ecx
movb -0x21(%rbp), %dl
movslq %ecx, %rcx
movb %dl, 0x44(%rax,%rcx)
cmpl $0x0, 0x6c83(%rip)      # 0x9260
je 0x26c0
cmpl $0x2e, -0x10(%rbp)
jne 0x26c0
cmpl $0x1, 0x6c6c(%rip)      # 0x9260
jne 0x2600
callq 0x26f0
jmp 0x26be
cmpl $0x2, 0x6c59(%rip)      # 0x9260
jl 0x26bc
movq -0x8(%rbp), %rax
cmpl $0x4, 0x40(%rax)
jl 0x26bc
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
subl $0x3, %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x38(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x26bc
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
subl $0x2, %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x40(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0x26bc
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x48(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x26bc
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
subl $0x0, %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x50(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x26bc
callq 0x26f0
jmp 0x26be
jmp 0x26c0
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x26e0
movq 0x6b58(%rip), %rax      # 0x9230
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x26ea
xorl %eax, %eax
movl %eax, %edi
callq *0x6b46(%rip)           # 0x9230
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/xping.c
// Function: usage
void
usage(const char *whine)
{
	if (whine != NULL) {
		fprintf(stderr, "%s\n", whine);
	}
	fprintf(stderr,
	    "usage: xping [-46ABCTVah] [-c count] [-i interval] [-w width] "
	    "host [host [...]]\n"
	    "\n");
	exit(EX_USAGE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x277f
movq 0x686e(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3a4d(%rip), %rsi      # 0x61c5
movb $0x0, %al
callq 0x2320
movq 0x6852(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x3990(%rip), %rsi      # 0x6120
movb $0x0, %al
callq 0x2320
movl $0x40, %edi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/xping.c
// Function: target_add
static int
target_add(const char *line)
{
	struct target *t;

	t = (struct target *)calloc(1, sizeof(*t));
	if (t == NULL)
		return -1;
	memset(t->res, ' ', sizeof(t->res));
	strncat(t->host, line, sizeof(t->host) - 1);
	DL_APPEND(list, t);
	t->prb = probe_new(line, t);
	if (t->prb == NULL) {
		free(t);
		return -1;
	}
	numtargets++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x1a0, %esi            # imm = 0x1A0
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2e22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2f
movq -0x18(%rbp), %rdi
addq $0x44, %rdi
movl $0x20, %esi
movl $0x12d, %edx            # imm = 0x12D
callq 0x20f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3f, %edx
callq 0x2140
cmpq $0x0, 0x6435(%rip)      # 0x9288
je 0x2eaa
movq 0x642c(%rip), %rax      # 0x9288
movq 0x190(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x190(%rax)
movq -0x18(%rbp), %rcx
movq 0x640f(%rip), %rax      # 0x9288
movq 0x190(%rax), %rax
movq %rcx, 0x198(%rax)
movq -0x18(%rbp), %rcx
movq 0x63f6(%rip), %rax      # 0x9288
movq %rcx, 0x190(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x198(%rax)
jmp 0x2edc
movq -0x18(%rbp), %rax
movq %rax, 0x63d3(%rip)      # 0x9288
movq 0x63cc(%rip), %rcx      # 0x9288
movq 0x63c5(%rip), %rax      # 0x9288
movq %rcx, 0x190(%rax)
movq 0x63b7(%rip), %rax      # 0x9288
movq $0x0, 0x198(%rax)
jmp 0x2ede
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x178(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x178(%rax)
jne 0x2f19
movq -0x18(%rbp), %rdi
callq 0x2260
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f2f
movl 0x6361(%rip), %eax      # 0x9280
addl $0x1, %eax
movl %eax, 0x6358(%rip)      # 0x9280
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/xping.c
// Function: cleanup
static void
cleanup(void)
{
	struct target *t, *t_tmp;

	DL_FOREACH_SAFE(list, t, t_tmp) {
		event_free(t->ev_write);
		probe_free(t->prb);
		free(t);
	}
	probe_cleanup();
	evdns_base_free(dns, 0);
	event_base_free(ev_base);
#ifdef libevent_global_shutdown
	libevent_global_shutdown();
#endif /* !libevent_global_shutdown */
	close(fd4);
	close(fd6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x6339(%rip), %rax      # 0x9288
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x2f73
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x10(%rbp)
movb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2f7c
jmp 0x2faf
movq -0x8(%rbp), %rax
movq 0x180(%rax), %rdi
callq 0x2390
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rdi
callq 0x3930
movq -0x8(%rbp), %rdi
callq 0x2260
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f53
movb $0x0, %al
callq 0x3340
movq 0x62fb(%rip), %rdi      # 0x92b8
xorl %esi, %esi
callq 0x2350
movq 0x62c5(%rip), %rdi      # 0x9290
callq 0x22f0
movl 0x62c2(%rip), %edi      # 0x9298
callq 0x23f0
movl 0x62bf(%rip), %edi      # 0x92a0
callq 0x23f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/xping.c
// Function: target_probe_sched
static void
target_probe_sched(int fd, short what, void *thunk)
{
	struct target *t = thunk;

	event_free(t->ev_write);
	t->ev_write = event_new(ev_base, -1, EV_PERSIST, target_probe, t);
	event_add(t->ev_write, &tv_interval);
	target_probe(fd, what, thunk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x180(%rax), %rdi
callq 0x2390
movq 0x626b(%rip), %rdi      # 0x9290
movq -0x18(%rbp), %r8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x10, %edx
leaq 0x46(%rip), %rcx        # 0x3080
callq 0x21a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x180(%rax)
movq -0x18(%rbp), %rax
movq 0x180(%rax), %rdi
leaq 0x6249(%rip), %rsi      # 0x92a8
callq 0x20c0
movl -0x4(%rbp), %edi
movw -0x6(%rbp), %ax
movq -0x10(%rbp), %rdx
movswl %ax, %esi
callq 0x3080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: probe_setup
void
probe_setup()
{
	tv_timeout.tv_sec = 3 * i_interval / 1000;
	tv_timeout.tv_usec = 3 * i_interval % 1000 * 1000;
	if (regcomp(&re_target, "^(https?:(//)?)?"
            "([0-9A-Za-z.-]+)(\\[([0-9A-Fa-f.:]+)\\])?(:[0-9]+)?(/[^ ]*)?$",
	    REG_EXTENDED | REG_NEWLINE) != 0) {
		fprintf(stderr,
		    "regcomp: error compiling regular expression\n");
		exit(1);
	}
#ifdef WITH_SSL
	SSL_library_init();
#endif /* WITH_SSL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5f65(%rip), %rax      # 0x9220
imull $0x3, (%rax), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, 0x5ff1(%rip)      # 0x92c0
leaq 0x5f4a(%rip), %rax      # 0x9220
imull $0x3, (%rax), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
cltq
movq %rax, 0x5fd8(%rip)      # 0x92c8
leaq 0x5fd9(%rip), %rdi      # 0x92d0
leaq 0x2eeb(%rip), %rsi      # 0x61e9
movl $0x5, %edx
callq 0x2230
cmpl $0x0, %eax
je 0x332f
movq 0x5cc4(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x2f17(%rip), %rsi      # 0x6235
movb $0x0, %al
callq 0x2320
movl $0x1, %edi
callq 0x2270
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: resolved
static void
resolved(int af, void *address, void *thunk)
{
	struct probe *prb = thunk;
	if (af == AF_INET6) {
		sin6(prb)->sin6_family = AF_INET6;
		memmove(&sin6(prb)->sin6_addr, (struct in6_addr *)address,
		    sizeof(sin6(prb)->sin6_addr));
		prb->resolved = 1;
	} else if (af == AF_INET) {
		sin(prb)->sin_family = AF_INET;
		memmove(&sin(prb)->sin_addr, (struct in_addr *)address,
		    sizeof(sin(prb)->sin_addr));
		prb->resolved = 1;
	} else if (af == 0) {
		prb->resolved = 0;
	}
	target_resolved(prb->owner, af, address);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0xa, -0x4(%rbp)
jne 0x38be
movq -0x20(%rbp), %rax
movw $0xa, 0x44(%rax)
movq -0x20(%rbp), %rax
addq $0x44, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x40(%rax)
jmp 0x3904
cmpl $0x2, -0x4(%rbp)
jne 0x38ef
movq -0x20(%rbp), %rax
movw $0x2, 0x44(%rax)
movq -0x20(%rbp), %rax
addq $0x44, %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x40(%rax)
jmp 0x3902
cmpl $0x0, -0x4(%rbp)
jne 0x3900
movq -0x20(%rbp), %rax
movl $0x0, 0x40(%rax)
jmp 0x3902
jmp 0x3904
movq -0x20(%rbp), %rax
movq 0xb0(%rax), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2720
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: probe_free
void probe_free(struct probe *prb)
{
	struct session *s, *s_tmp;

	LL_FOREACH_SAFE(prb->sessions, s, s_tmp) {
		session_free(s);
	}
	if (prb->dnstask)
		dnstask_free(prb->dnstask);
	free(prb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x3968
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3971
jmp 0x3984
movq -0x10(%rbp), %rdi
callq 0x39c0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x394b
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x39a2
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x4fd0
movq -0x8(%rbp), %rdi
callq 0x2260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: session_free
static void
session_free(struct session *session)
{

	if (session->statusline)
		free(session->statusline);
	LL_DELETE(session->prb->sessions, session);
	if (session->ev_timeout)
		event_free(session->ev_timeout);
	if (session->bev) {
		bufferevent_disable(session->bev, EV_READ|EV_WRITE);
		bufferevent_free(session->bev);
	}
	free(session);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x39e4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2260
jmp 0x39e6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x3a1c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0xa0(%rax)
jmp 0x3a84
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, -0x11(%rbp)
je 0x3a50
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3a59
jmp 0x3a67
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3a2e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3a82
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x3a84
jmp 0x3a86
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3a9e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2390
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3ac8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x6, %esi
callq 0x2340
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2070
movq -0x8(%rbp), %rdi
callq 0x2260
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: session_readcb_status
static void
session_readcb_status(struct bufferevent *bev, void *thunk)
{
	struct session *session = thunk;
	struct evbuffer *evbuf = bufferevent_get_input(bev);
	size_t len;
	char *line;
	char *protocol;
	char *number;

	line = evbuffer_readln(evbuf, &len, EVBUFFER_EOL_CRLF);
	if (line == NULL) {
		if (evbuffer_get_length(evbuf) > 2048) {
			session_free(session);
			return;
		} else
			return; /* wait for more data */
	}
	session->statusline = line;
	/* Parse response line */
	protocol = strsep(&line, " ");
	if (line == NULL) {
		session_free(session);
		return;
	}
	number = strsep(&line, " ");
	if (line == NULL) {
		session_free(session);
		return;
	}
	(void)protocol;
	(void)number;
	if (atoi(number) < 400 && atoi(number) >= 200 ) {
		session->completed = 1;
	} else {
		target_mark(session->prb->owner, session->seq, '%');
	}
	/* Drain the response on future callbacks */
	bufferevent_setcb(session->bev, session_readcb_drain, NULL,
	    session_eventcb, session);
	session_readcb_drain(bev, session);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x21f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3dd6
movq -0x20(%rbp), %rdi
callq 0x21e0
cmpq $0x800, %rax            # imm = 0x800
jbe 0x3dd1
movq -0x18(%rbp), %rdi
callq 0x39c0
jmp 0x3ead
jmp 0x3ead
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq -0x30(%rbp), %rdi
leaq 0x24ce(%rip), %rsi      # 0x62bb
callq 0x2100
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3e0b
movq -0x18(%rbp), %rdi
callq 0x39c0
jmp 0x3ead
leaq -0x30(%rbp), %rdi
leaq 0x24a5(%rip), %rsi      # 0x62bb
callq 0x2100
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3e31
movq -0x18(%rbp), %rdi
callq 0x39c0
jmp 0x3ead
movq -0x40(%rbp), %rdi
callq 0x2360
cmpl $0x190, %eax            # imm = 0x190
jge 0x3e5e
movq -0x40(%rbp), %rdi
callq 0x2360
cmpl $0xc8, %eax
jl 0x3e5e
movq -0x18(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x3e7d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x25, %edx
callq 0x2550
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %r8
leaq 0x1c0(%rip), %rsi       # 0x4050
xorl %eax, %eax
movl %eax, %edx
leaq 0x25(%rip), %rcx        # 0x3ec0
callq 0x21c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4050
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: session_eventcb
static void
session_eventcb(struct bufferevent *bev, short what, void *thunk)
{
	struct session *session = thunk;
	switch (what & ~(BEV_EVENT_READING|BEV_EVENT_WRITING)) {
	case BEV_EVENT_CONNECTED:
		session_send(session);
		return;
	case BEV_EVENT_EOF:
		bufferevent_disable(bev, EV_READ|EV_WRITE);
		if (session->completed)
			target_mark(session->prb->owner, session->seq, '.');
		else
			target_mark(session->prb->owner, session->seq, '%');
		break;
	case BEV_EVENT_ERROR:
		bufferevent_disable(bev, EV_READ|EV_WRITE);
		target_mark(session->prb->owner, session->seq, '#');
		break;
	case BEV_EVENT_TIMEOUT:
		target_mark(session->prb->owner, session->seq, '?');
		break;
	}
	session_free(session);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movswl -0xa(%rbp), %eax
andl $-0x4, %eax
movl %eax, -0x24(%rbp)
subl $0x10, %eax
je 0x3f2a
jmp 0x3ef0
movl -0x24(%rbp), %eax
subl $0x20, %eax
je 0x3f84
jmp 0x3efe
movl -0x24(%rbp), %eax
subl $0x40, %eax
je 0x3fb3
jmp 0x3f0c
movl -0x24(%rbp), %eax
subl $0x80, %eax
jne 0x3fd2
jmp 0x3f1c
movq -0x20(%rbp), %rdi
callq 0x4090
jmp 0x3fdb
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x2340
movq -0x20(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x3f63
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x2e, %edx
callq 0x2550
jmp 0x3f82
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x25, %edx
callq 0x2550
jmp 0x3fd2
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x2340
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x23, %edx
callq 0x2550
jmp 0x3fd2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x3f, %edx
callq 0x2550
movq -0x20(%rbp), %rdi
callq 0x39c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/http.c
// Function: session_timeout
static void
session_timeout(int fd, short what, void *thunk)
{
	struct session *session = thunk;

	if (session->completed)
		target_mark(session->prb->owner, session->seq, '?');
	session_free(session);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x4037
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0xb0(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x3f, %edx
callq 0x2550
movq -0x18(%rbp), %rdi
callq 0x39c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: getmaxx
int
getmaxx(void)
{
	struct winsize wsz;
	char *p;

	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &wsz) != -1 &&
	    wsz.ws_col > 0)
		return (wsz.ws_col);
	else if ((p = getenv("COLUMNS")) != NULL && *p != '\0')
		return atoi(p);
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x2310
cmpl $-0x1, %eax
je 0x4114
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jle 0x4114
movzwl -0xa(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x414b
leaq 0x2375(%rip), %rdi      # 0x6490
callq 0x2280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4144
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4144
movq -0x18(%rbp), %rdi
callq 0x2360
movl %eax, -0x4(%rbp)
jmp 0x414b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: getmaxy
int
getmaxy(void)
{
	struct winsize wsz;
	char *p;

	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &wsz) != -1 &&
	    wsz.ws_row > 0)
		return (wsz.ws_row);
	else if ((p = getenv("ROWS")) != NULL && *p != '\0')
		return atoi(p);
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x2310
cmpl $-0x1, %eax
je 0x4194
movzwl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x4194
movzwl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x41cb
leaq 0x22fd(%rip), %rdi      # 0x6498
callq 0x2280
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x41c4
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x41c4
movq -0x18(%rbp), %rdi
callq 0x2360
movl %eax, -0x4(%rbp)
jmp 0x41cb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: move
void
move(int row, int col)
{
	fprintf(stdout, "%c[u", 0x1b);
	if (row > 0)
		fprintf(stdout, "%c[%dB", 0x1b, row);
	if (col > 0)
		fprintf(stdout, "%c[%dC", 0x1b, col);
	cursor_y = row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0x4dbb(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
leaq 0x229e(%rip), %rsi      # 0x649d
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
cmpl $0x0, -0x4(%rbp)
jle 0x4231
movq 0x4d98(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
movl -0x4(%rbp), %ecx
leaq 0x227d(%rip), %rsi      # 0x64a2
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
cmpl $0x0, -0x8(%rbp)
jle 0x4257
movq 0x4d72(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
movl -0x8(%rbp), %ecx
leaq 0x225e(%rip), %rsi      # 0x64a9
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
movl -0x4(%rbp), %eax
movl %eax, 0x50b0(%rip)      # 0x9310
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: sigwinch
void
sigwinch(int sig)
{
	if (cursor_y > 0)
		fprintf(stdout, "%c[%dA\r", 0x1b, cursor_y);
	fprintf(stdout, "\r%c[s", 0x1b);
	cursor_y = 0;
	fprintf(stdout, "%c[2K\r", 0x1b);
	clrtobot();
	termio_update(NULL); /* XXX: this is probably a bad idea */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x508e(%rip)      # 0x9310
jle 0x42a7
movq 0x4d25(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
movl 0x507c(%rip), %ecx      # 0x9310
leaq 0x2215(%rip), %rsi      # 0x64b0
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
movq 0x4d02(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
leaq 0x2200(%rip), %rsi      # 0x64b8
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
movl $0x0, 0x5042(%rip)      # 0x9310
movq 0x4cdb(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
leaq 0x21df(%rip), %rsi      # 0x64be
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
callq 0x4300
xorl %eax, %eax
movl %eax, %edi
callq 0x4330
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: termio_update
void
termio_update(struct target *selective)
{
	struct target *t;
	int col;

	int imax, ifirst, ilast;

	t = list;
	if (t == NULL)
		return;

	col = getmaxx(stdscr);
	imax = MIN(t->npkts, col - labelwidth);
	imax = MIN(imax, NUM);
	ifirst = (t->npkts > imax ? t->npkts - imax : 0);
	ilast = t->npkts;

	if (selective != NULL && ifirst == ifirst_state) {
		updatesingle(ifirst, selective);
	} else {
#ifndef NCURSES
		/* Re-establish the reference point for move() */
		if (cursor_y > 0)
			fprintf(stdout, "%c[%dA\r", 0x1b, cursor_y);
		fprintf(stdout, "\r%c[s", 0x1b);
		cursor_y = 0;
#endif /* !NCURSES */
		updatefull(ifirst, ilast);
		ifirst_state = ifirst;
		clrtoeol();
		clrtobot();
	}
	refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4f45(%rip), %rax      # 0x9288
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4356
jmp 0x4479
callq 0x40e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl -0x14(%rbp), %ecx
subl 0x4fee(%rip), %ecx      # 0x935c
cmpl %ecx, %eax
jge 0x437e
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x438a
movl -0x14(%rbp), %eax
subl 0x4fd5(%rip), %eax      # 0x935c
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x12c, -0x18(%rbp)     # imm = 0x12C
jge 0x43a1
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x43ab
movl $0x12c, %eax            # imm = 0x12C
movl %eax, -0x28(%rbp)
jmp 0x43ab
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
cmpl -0x18(%rbp), %eax
jle 0x43cc
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x43d3
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x43d3
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4403
movl -0x1c(%rbp), %eax
cmpl 0x4e61(%rip), %eax      # 0x9254
jne 0x4403
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x46e0
jmp 0x4474
cmpl $0x0, 0x4f06(%rip)      # 0x9310
jle 0x442f
movq 0x4b9d(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
movl 0x4ef4(%rip), %ecx      # 0x9310
leaq 0x208d(%rip), %rsi      # 0x64b0
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
movq 0x4b7a(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
leaq 0x2078(%rip), %rsi      # 0x64b8
movl $0x1b, %edx
movb $0x0, %al
callq 0x2320
movl $0x0, 0x4eba(%rip)      # 0x9310
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x4760
movl -0x1c(%rbp), %eax
movl %eax, 0x4dea(%rip)      # 0x9254
callq 0x4920
callq 0x4300
callq 0x4950
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: updatefull
static void
updatefull(int ifirst, int ilast)
{
	struct target *t;
	int row;
	int i;

	row = 0;
	DL_FOREACH(list, t) {
		t->row = row; /* cache for selective updates */
		if (C_flag && t->af == AF_INET6)
			mvprintw(row, 0, "%c[2;32m%*.*s%c[0m",
			    0x1b, w_width, w_width, t->host, 0x1b);
		else if (C_flag && t->af == AF_INET)
			mvprintw(row, 0, "%c[2;31m%*.*s%c[0m",
			    0x1b, w_width, w_width, t->host, 0x1b);
		else
			mvprintw(row, 0, "%*.*s", w_width, w_width, t->host);
		if (w_width)
			drawchar(' ');
		for (i=ifirst; i<ilast; i++) {
			if (i < t->npkts)
				drawchar(t->res[i % NUM]);
			else
				drawchar(' ');
		}
		move(++row, 0);
	}
	holding_row = row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x4b0c(%rip), %rax      # 0x9288
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4909
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x188(%rax)
leaq 0x4ace(%rip), %rax      # 0x9270
cmpl $0x0, (%rax)
je 0x47f5
movq -0x10(%rbp), %rax
cmpl $0xa, 0x18c(%rax)
jne 0x47f5
movl -0x14(%rbp), %edi
leaq 0x4a66(%rip), %rax      # 0x9224
movl (%rax), %r8d
leaq 0x4a5c(%rip), %rax      # 0x9224
movl (%rax), %r9d
movq -0x10(%rbp), %rax
xorl %esi, %esi
leaq 0x1d46(%rip), %rdx      # 0x651e
movl $0x1b, %ecx
movq %rax, (%rsp)
movl $0x1b, 0x8(%rsp)
movb $0x0, %al
callq 0x4bc0
jmp 0x4878
leaq 0x4a74(%rip), %rax      # 0x9270
cmpl $0x0, (%rax)
je 0x484c
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18c(%rax)
jne 0x484c
movl -0x14(%rbp), %edi
leaq 0x4a0c(%rip), %rax      # 0x9224
movl (%rax), %r8d
leaq 0x4a02(%rip), %rax      # 0x9224
movl (%rax), %r9d
movq -0x10(%rbp), %rax
xorl %esi, %esi
leaq 0x1cff(%rip), %rdx      # 0x6531
movl $0x1b, %ecx
movq %rax, (%rsp)
movl $0x1b, 0x8(%rsp)
movb $0x0, %al
callq 0x4bc0
jmp 0x4876
movl -0x14(%rbp), %edi
leaq 0x49ce(%rip), %rax      # 0x9224
movl (%rax), %ecx
leaq 0x49c5(%rip), %rax      # 0x9224
movl (%rax), %r8d
movq -0x10(%rbp), %r9
xorl %esi, %esi
leaq 0x1cd5(%rip), %rdx      # 0x6544
movb $0x0, %al
callq 0x4bc0
jmp 0x4878
leaq 0x49a5(%rip), %rax      # 0x9224
cmpl $0x0, (%rax)
je 0x488e
movl $0x20, %edi
callq 0x49d0
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x48e5
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x48ce
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %edi
callq 0x49d0
jmp 0x48d8
movl $0x20, %edi
callq 0x49d0
jmp 0x48da
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4894
movl -0x14(%rbp), %edi
addl $0x1, %edi
movl %edi, -0x14(%rbp)
xorl %esi, %esi
callq 0x41e0
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4783
movl -0x14(%rbp), %eax
movl %eax, 0x4a4e(%rip)      # 0x9360
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: drawchar
static void
drawchar(int ch)
{


	if (!B_flag) {
		addch(ch);
	} else {
		printw("%s%c\x1b[0m", getcolor(ch), ch);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x488a(%rip), %rax      # 0x926c
cmpl $0x0, (%rax)
jne 0x49f1
movl -0x4(%rbp), %edi
callq 0x4a20
jmp 0x4a0d
movl -0x4(%rbp), %edi
callq 0x4b20
movq %rax, %rsi
movl -0x4(%rbp), %edx
leaq 0x1ad2(%rip), %rdi      # 0x64d8
movb $0x0, %al
callq 0x4a50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: getcolor
static char *
getcolor(int ch)
{

	switch(ch) {
	case '.':
		return "\x1b[2;34m"; /* blue */
	case ':':
		return "\x1b[6;33m"; /* yellow */
	case '?':
	case '#':
		return "\x1b[1;31m"; /* red */
	case '%':
		return "\x1b[2;35m"; /* magenta */
	case '@':
		return "\x1b[5;32m"; /* green */
	case '!':
		return "\x1b[3;31m"; /* red */
	case '"':
		return "\x1b[5;33m"; /* yellow */
	}
	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1f, %eax
ja 0x4ba7
movq -0x18(%rbp), %rax
leaq 0x18cd(%rip), %rcx      # 0x6410
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1993(%rip), %rax      # 0x64e6
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x198e(%rip), %rax      # 0x64ee
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x1989(%rip), %rax      # 0x64f6
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x1984(%rip), %rax      # 0x64fe
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x197f(%rip), %rax      # 0x6506
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x197a(%rip), %rax      # 0x650e
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x1975(%rip), %rax      # 0x6516
movq %rax, -0x8(%rbp)
jmp 0x4bb2
leaq 0x163a(%rip), %rax      # 0x61e8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/termio.c
// Function: mvprintw
static void
mvprintw(int row, int col, const char *fmt, ...)
{
	va_list ap;

	move(row, col);
	fprintf(stdout, "%c[K", 0x1b);
	va_start(ap, fmt);
	vfprintf(stdout, fmt, ap);
	va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x4bf8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x41e0
movq 0x4387(%rip), %rax      # 0x8fb0
movq %rax, -0xe8(%rbp)
movq (%rax), %rdi
leaq 0x18a7(%rip), %rsi      # 0x64e1
xorl %eax, %eax
movl $0x1b, %edx
callq 0x2320
movq -0xe8(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x18, -0x30(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x22e0
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/report.c
// Function: report_cleanup
void report_cleanup()
{
	struct target *t;
	int i, imax, ifirst, ilast;

	t = list;
	if (t == NULL)
		return;

	imax = MIN(t->npkts, NUM);
	ifirst = (t->npkts > imax ? t->npkts - imax : 0);
	ilast = t->npkts;

	DL_FOREACH(list, t) {
		fprintf(stdout, "%*.*s", w_width, w_width, t->host);
		if (w_width)
			fputc(' ', stdout);
		for (i=ifirst; i<ilast; i++) {
			if (i < t->npkts) fputc(t->res[i % NUM], stdout);
			else fputc(' ', stdout);
		}
		fputc('\n', stdout);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x45c9(%rip), %rax      # 0x9288
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4cd2
jmp 0x4e27
movq -0x8(%rbp), %rax
cmpl $0x12c, 0x40(%rax)      # imm = 0x12C
jge 0x4ceb
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4cf5
movl $0x12c, %eax            # imm = 0x12C
movl %eax, -0x1c(%rbp)
jmp 0x4cf5
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
cmpl -0x10(%rbp), %eax
jle 0x4d16
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x4d1d
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x4d1d
movl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x4554(%rip), %rax      # 0x9288
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4e27
movq 0x4263(%rip), %rax      # 0x8fb0
movq (%rax), %rdi
leaq 0x44cd(%rip), %rax      # 0x9224
movl (%rax), %edx
leaq 0x44c4(%rip), %rax      # 0x9224
movl (%rax), %ecx
movq -0x8(%rbp), %r8
leaq 0x17d7(%rip), %rsi      # 0x6544
movb $0x0, %al
callq 0x2320
leaq 0x44a9(%rip), %rax      # 0x9224
cmpl $0x0, (%rax)
je 0x4d94
movq 0x4229(%rip), %rax      # 0x8fb0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x22b0
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4dff
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x4dde
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0x12c, %ecx            # imm = 0x12C
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
movsbl 0x44(%rax,%rcx), %edi
movq 0x41dc(%rip), %rax      # 0x8fb0
movq (%rax), %rsi
callq 0x22b0
jmp 0x4df2
movq 0x41cb(%rip), %rax      # 0x8fb0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x22b0
jmp 0x4df4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d9a
movq 0x41aa(%rip), %rax      # 0x8fb0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x22b0
movq -0x8(%rbp), %rax
movq 0x198(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d3b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/dnstask.c
// Function: dnstask_new
struct dnstask *
dnstask_new(const char *hostname, dnstask_cb_type cb, void *thunk)
{
	struct dnstask *task;
	struct timeval tv;

	task = calloc(1, sizeof(*task));
	if (task == NULL)
		return NULL;
	assert(strlen(hostname) + 1 <= sizeof(task->host));
	strncat(task->host, hostname, sizeof(task->host) - 1);
	task->cb = cb;
	task->thunk = thunk;
	task->ev_resolve = event_new(ev_base, -1, 0, sendquery, task);
	if (task->ev_resolve == NULL) {
		free(task);
		return NULL;
	}
	evutil_timerclear(&tv);
	event_add(task->ev_resolve, &tv);
	return task;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4e6b
movq $0x0, -0x8(%rbp)
jmp 0x4f3f
movq -0x10(%rbp), %rdi
callq 0x20d0
addq $0x1, %rax
cmpq $0x40, %rax
ja 0x4e80
jmp 0x4e9f
leaq 0x16ca(%rip), %rdi      # 0x6551
leaq 0x16ee(%rip), %rsi      # 0x657c
movl $0x85, %edx
leaq 0x16ec(%rip), %rcx      # 0x6586
callq 0x2120
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movl $0x3f, %edx
callq 0x2140
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x43bd(%rip), %rax      # 0x9290
movq (%rax), %rdi
movq -0x28(%rbp), %r8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
leaq 0x68(%rip), %rcx        # 0x4f50
callq 0x21a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x4f16
movq -0x28(%rbp), %rdi
callq 0x2260
movq $0x0, -0x8(%rbp)
jmp 0x4f3f
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20c0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/dnstask.c
// Function: sendquery
static void
sendquery(int fd, short what, void *thunk)
{
	struct dnstask *task = thunk;
	if (!v4_flag) {
		evdns_base_resolve_ipv6(dns, task->host, 0,
		    response_ipv6, task);
	} else {
		evdns_base_resolve_ipv4(dns, task->host, 0,
		    response_ipv4, task);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x4303(%rip), %rax      # 0x9278
cmpl $0x0, (%rax)
jne 0x4fa0
leaq 0x4337(%rip), %rax      # 0x92b8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %r8
xorl %edx, %edx
leaq 0x67(%rip), %rcx        # 0x5000
callq 0x21b0
jmp 0x4fc4
leaq 0x4311(%rip), %rax      # 0x92b8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %r8
xorl %edx, %edx
leaq 0x131(%rip), %rcx       # 0x50f0
callq 0x22a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/dnstask.c
// Function: response_ipv6
static void
response_ipv6(int result, char type, int count, int ttl, void *addresses,
    void *thunk)
{
	struct dnstask *task = thunk;

	if (result == DNS_ERR_NONE && count > 0) {
		task->cb(AF_INET6, addresses, task->thunk);
		/* Schedule new request, enforce a lower bound on ttl. */
		if (T_flag)
			reschedule(task->ev_resolve, MAX(ttl, 1));
	} else {
		if (!v6_flag) {
			evdns_base_resolve_ipv4(dns, task->host, 0,
			    response_ipv4, thunk);
		} else {
			/* neg-TTL might be search domain's */
			reschedule(task->ev_resolve, 60);
			task->cb(0, NULL, task->thunk);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x508b
cmpl $0x0, -0xc(%rbp)
jle 0x508b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl $0xa, %edi
callq *%rax
leaq 0x4220(%rip), %rax      # 0x9274
cmpl $0x0, (%rax)
je 0x5089
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x10(%rbp)
jle 0x5073
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x507d
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x507d
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x51b0
jmp 0x50e8
leaq 0x41ea(%rip), %rax      # 0x927c
cmpl $0x0, (%rax)
jne 0x50bd
leaq 0x421a(%rip), %rax      # 0x92b8
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
movq -0x20(%rbp), %r8
xorl %edx, %edx
leaq 0x3a(%rip), %rcx        # 0x50f0
callq 0x22a0
jmp 0x50e6
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
movl $0x3c, %esi
callq 0x51b0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdx
xorl %edi, %edi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
jmp 0x50e8
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/dnstask.c
// Function: response_ipv4
static void
response_ipv4(int result, char type, int count, int ttl, void *addresses,
    void *thunk)
{
	struct dnstask *task = thunk;

	if (result == DNS_ERR_NONE && count > 0) {
		task->cb(AF_INET, addresses, task->thunk);
		/* Schedule new request, enforce a lower bound on ttl. */
		if (T_flag)
			reschedule(task->ev_resolve, MAX(ttl, 1));
	} else {
		task->cb(0, NULL, task->thunk);
		/* neg-TTL might be search domain's */
		reschedule(task->ev_resolve, 60);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x517b
cmpl $0x0, -0xc(%rbp)
jle 0x517b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl $0x2, %edi
callq *%rax
leaq 0x4130(%rip), %rax      # 0x9274
cmpl $0x0, (%rax)
je 0x5179
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, -0x10(%rbp)
jle 0x5163
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x516d
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x516d
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x51b0
jmp 0x51a4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdx
xorl %edi, %edi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
movl $0x3c, %esi
callq 0x51b0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhronosGroup[P]dfdutils/interpretdfd.c
// Function: bit_ceil
static uint32_t bit_ceil(uint32_t x) {
    x -= 1;
    for (uint32_t i = 0; i < sizeof(x) * 8; ++i)
        if (1u << i > x)
            return 1u << i;
    return 0;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpq $0x20, %rax
jae 0x1fe2
movl -0xc(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl -0x8(%rsp), %eax
jbe 0x1fd3
movl -0xc(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x4(%rsp)
jmp 0x1fea
jmp 0x1fd5
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1fa7
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop