LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/worker.c
// Function: worker_run_test
int worker_run_test(struct client_worker_data *data)
{
	bool get_reply = data->reply;
	bool eof = false;
	int ret;

	data->status = 0;
	while (!eof && !data->test_finished) {
		ret = send_msg(data);
		if (ret < 0) {
			data->status = -1;
			break;
		}
		if (data->test_finished)
			break;
		if (get_reply) {
			ret = recv_msg(data, &eof);
			if (ret < 0) {
				data->status = -1;
				break;
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
xorl %eax, %eax
testb $0x1, -0xa(%rbp)
movb %al, -0x11(%rbp)
jne 0x4322
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x432b
jmp 0x4383
movq -0x8(%rbp), %rdi
callq 0x4390
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x434a
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
jmp 0x4383
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x4356
jmp 0x4383
testb $0x1, -0x9(%rbp)
je 0x4381
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
callq 0x44b0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x437f
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
jmp 0x4383
jmp 0x4381
jmp 0x4307
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/worker.c
// Function: recv_msg
static int recv_msg(struct client_worker_data *data, bool *eof)
{
	unsigned long len = data->msg_size;
	unsigned char *p = data->buff;
	ssize_t chunk;

	*eof = false;
	while (len > 0 && !data->test_finished) {
		chunk = recv(data->sd, p, len, 0);
		if (chunk < 0) {
			if (errno == EINTR)
				continue;
			data->status = -errno;
			return data->status;
		}
		if (chunk == 0) {
			*eof = true;
			return 0;
		}

		p += chunk;
		len -= chunk;
		data->stats.rx.calls++;
		data->stats.rx.bytes += chunk;
	}

	if (!len)
		data->stats.rx.msgs++;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
jbe 0x44fb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4507
jmp 0x45a7
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x4550
callq 0x2070
cmpl $0x4, (%rax)
jne 0x4534
jmp 0x44df
callq 0x2070
xorl %ecx, %ecx
subl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x45c5
cmpq $0x0, -0x30(%rbp)
jne 0x4567
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x45c5
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
jmp 0x44df
cmpq $0x0, -0x20(%rbp)
jne 0x45be
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/worker.c
// Function: worker_main
void *worker_main(void * _data)
{
	struct client_worker_data *data = _data;
	int ret;

	data->status = -1;
	worker_setup(data);
	pthread_cleanup_push(cleanup_close, data);
	wsync_inc_counter(&client_worker_sync);

	wsync_wait_for_state(&client_worker_sync, WS_CONNECT);
	ret = worker_connect(data);
	if (ret < 0)
		goto out;
	wsync_inc_counter(&client_worker_sync);

	wsync_wait_for_state(&client_worker_sync, WS_RUN);
	ret = worker_run_test(data);
	if (ret < 0 || data->test_finished)
		goto out;

out:
	pthread_cleanup_pop(1);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x60(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x3fa0
leaq 0xee(%rip), %rax        # 0x46f0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x2370
movl %eax, -0x94(%rbp)
movslq -0x94(%rbp), %rax
cmpq $0x0, %rax
je 0x464b
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rdi
callq *%rax
leaq -0x80(%rbp), %rdi
callq 0x2240
leaq -0x80(%rbp), %rdi
callq 0x2320
leaq 0x7345(%rip), %rdi      # 0xb9a0
callq 0x4720
leaq 0x7339(%rip), %rdi      # 0xb9a0
movl $0x1, %esi
callq 0x4760
movq -0x10(%rbp), %rdi
callq 0x4140
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x4685
jmp 0x46c2
leaq 0x7314(%rip), %rdi      # 0xb9a0
callq 0x4720
leaq 0x7308(%rip), %rdi      # 0xb9a0
movl $0x2, %esi
callq 0x4760
movq -0x10(%rbp), %rdi
callq 0x42e0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x46be
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x46c0
jmp 0x46c2
jmp 0x46c2
jmp 0x46c4
jmp 0x46c6
jmp 0x46c8
leaq -0x80(%rbp), %rdi
callq 0x2140
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rdi
callq *%rax
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/../wsync.h
// Function: wsync_inc_counter
static inline void wsync_inc_counter(struct worker_sync *ws)
{
	pthread_mutex_lock(&ws->mtx);
	ws->counter++;
	pthread_cond_broadcast(&ws->cv);
	pthread_mutex_unlock(&ws->mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2390
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x2080
movq -0x8(%rbp), %rdi
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/../wsync.h
// Function: wsync_wait_for_state
static inline void wsync_wait_for_state(struct worker_sync *ws,
					unsigned int state)
{
	pthread_mutex_lock(&ws->mtx);
	while (ws->state != state)
		pthread_cond_wait(&ws->cv, &ws->mtx);
	pthread_mutex_unlock(&ws->mtx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2390
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x4797
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
callq 0x20d0
jmp 0x4778
movq -0x8(%rbp), %rdi
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/worker.c
// Function: start_client_worker
int start_client_worker(struct client_worker_data *data)
{
	pthread_attr_t attr;
	int ret;

	ret = pthread_attr_init(&attr);
	if (ret)
		return -ret;
	ret = pthread_attr_setstacksize(&attr, WORKER_STACK_SIZE);
	if (ret)
		return -ret;
	ret = pthread_create(&data->tid, &attr, worker_main, data);

	pthread_attr_destroy(&attr);
	return -ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x21b0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x47d8
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4829
leaq -0x48(%rbp), %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x23c0
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x47f9
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4829
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rcx
leaq -0x48(%rbp), %rsi
leaq -0x240(%rip), %rdx      # 0x45d0
callq 0x2280
movl %eax, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x22f0
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/../estimate.h
// Function: confid_level_input
static inline int confid_level_input(unsigned int level)
{
	switch(level) {
	case 95:
		return CONFID_LEVEL_95;
	case 99:
		return CONFID_LEVEL_99;
	default:
		return -EINVAL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x5f, %eax
je 0x503e
jmp 0x5034
movl -0xc(%rbp), %eax
subl $0x63, %eax
je 0x5047
jmp 0x5050
movl $0x0, -0x4(%rbp)
jmp 0x5057
movl $0x1, -0x4(%rbp)
jmp 0x5057
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/client/cmdline.c
// Function: name_lookup
static int name_lookup(const char *name, const char *const names[],
		       unsigned int names_count)
{
	unsigned int i;

	for (i = 0; i < names_count; i++)
		if (!strcasecmp(name, names[i]))
			return i;

	return -ENOENT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x50b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x2060
cmpl $0x0, %eax
jne 0x50a3
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x50b7
jmp 0x50a5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x507a
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/stats.c
// Function: print_opts_setup
void print_opts_setup(struct print_options *opts, unsigned int test_mode)
{
	switch(test_mode) {
	case MODE_TCP_STREAM:
		opts->unit = PRINT_UNIT_BYTE;
		opts->width = 13;
		break;
	case MODE_TCP_RR:
		opts->unit = PRINT_UNIT_TRANS;
		opts->width = 9;
		break;
	default:
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x5131
jmp 0x5127
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x5148
jmp 0x515f
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0xd, 0x4(%rax)
jmp 0x5161
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x4(%rax)
jmp 0x5161
jmp 0x5161
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/stats.c
// Function: print_count
void print_count(uint64_t val, const struct print_options *opts)
{
	unsigned int base = opts->binary_prefix ? 1024 : 1000;
	const char *unit_str = unit_names[opts->unit];
	const char prefixes[] = " KMGT";
	const char *prefix = &prefixes[0];
	double dval;

	if (opts->exact) {
		printf("%*" PRIu64 " %s", opts->width, val, unit_str);
		return;
	}
	if (val < 20 * base) {
		printf("%5" PRIu64 "    %s", val, unit_str);
		return;
	}

	dval = val / base;
	prefix++;
	while ((dval >= 20 * base) && *prefix) {
		dval /= base;
		prefix++;
	}
	printf("%7.1lf %c%s", dval, *prefix, unit_str);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x9(%rax), %dl
movl $0x3e8, %eax            # imm = 0x3E8
movl $0x400, %ecx            # imm = 0x400
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x6137(%rip), %rax      # 0xb2e0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl 0x2e41(%rip), %eax      # 0x7ff8
movl %eax, -0x26(%rbp)
movw 0x2e3b(%rip), %ax       # 0x7ffc
movw %ax, -0x22(%rbp)
leaq -0x26(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x51f9
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x8(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2e11(%rip), %rdi      # 0x7ffe
movb $0x0, %al
callq 0x2130
jmp 0x52e2
movq -0x8(%rbp), %rax
imull $0x14, -0x14(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x5223
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x2def(%rip), %rdi      # 0x8006
movb $0x0, %al
callq 0x2130
jmp 0x52e2
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %xmm0
movaps 0x2d95(%rip), %xmm1     # 0x7fd0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2d99(%rip), %xmm1     # 0x7fe0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, %eax
leal (%rax,%rax,4), %eax
cvtsi2sd %rax, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x39(%rbp)
jb 0x5297
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x52a0
jmp 0x52c4
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd -0x38(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5267
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
movq -0x20(%rbp), %rdx
leaq 0x2d36(%rip), %rdi      # 0x8011
movb $0x1, %al
callq 0x2130
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/stats.c
// Function: print_rate
void print_rate(double val, const struct print_options *opts)
{
	unsigned int base = opts->binary_prefix ? 1024 : 1000;
	const char *unit_str = unit_names[opts->unit];
	const char prefixes[] = " KMGT";
	const char *prefix = &prefixes[0];

	if (opts->exact) {
		printf("%*.1lf %s/s", opts->width, val, unit_str);
		return;
	}

	while (val >= 20000 && *prefix) {
		val /= base;
		prefix++;
	}
	printf("%7.1lf %c%s/s", val, *prefix, unit_str);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb 0x9(%rax), %dl
movl $0x3e8, %eax            # imm = 0x3E8
movl $0x400, %ecx            # imm = 0x400
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x5fb6(%rip), %rax      # 0xb2e0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl 0x2cc0(%rip), %eax      # 0x7ff8
movl %eax, -0x26(%rbp)
movw 0x2cba(%rip), %ax       # 0x7ffc
movw %ax, -0x22(%rbp)
leaq -0x26(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x5378
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movsd -0x8(%rbp), %xmm0
movq -0x20(%rbp), %rdx
leaq 0x2cae(%rip), %rdi      # 0x801d
movb $0x1, %al
callq 0x2130
jmp 0x53ed
jmp 0x537a
movsd -0x8(%rbp), %xmm0
xorl %eax, %eax
movsd 0x2c67(%rip), %xmm1     # 0x7ff0
ucomisd %xmm1, %xmm0
movb %al, -0x31(%rbp)
jb 0x53a2
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x53ab
jmp 0x53cf
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd -0x8(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x537a
movsd -0x8(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
movq -0x20(%rbp), %rdx
leaq 0x2c43(%rip), %rdi      # 0x8029
movb $0x1, %al
callq 0x2130
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/stats.c
// Function: xfer_stats_result
double xfer_stats_result(const struct xfer_stats *client,
			 const struct xfer_stats *server,
			 unsigned int test_mode, double elapsed)
{
	switch(test_mode) {
	case MODE_TCP_STREAM:
		return server->rx.bytes / elapsed;
	case MODE_TCP_RR:
		return client->rx.msgs / elapsed;
	default:
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x542a
jmp 0x5420
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x5461
jmp 0x5497
movq -0x18(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0x2b96(%rip), %xmm1     # 0x7fd0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2b9a(%rip), %xmm1     # 0x7fe0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x549f
movq -0x10(%rbp), %rax
movq (%rax), %xmm0
movaps 0x2b60(%rip), %xmm1     # 0x7fd0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2b64(%rip), %xmm1     # 0x7fe0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x549f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/stats.c
// Function: xfer_stats_print_raw
void xfer_stats_print_raw(const struct xfer_stats *stats, unsigned int id)
{
	if (id == XFER_STATS_TOTAL)
		fputs("total    ", stdout);
	else
		printf("%-8u ", id);

	xfer_stats_1_print(&stats->rx);
	fputs("    ", stdout);
	xfer_stats_1_print(&stats->tx);
	putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x552d
movq 0x5ab4(%rip), %rax      # 0xafd0
movq (%rax), %rsi
leaq 0x2b48(%rip), %rdi      # 0x806e
callq 0x2160
jmp 0x553e
movl -0xc(%rbp), %esi
leaq 0x2b41(%rip), %rdi      # 0x8078
movb $0x0, %al
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0x5580
movq 0x5a82(%rip), %rax      # 0xafd0
movq (%rax), %rsi
leaq 0x2b50(%rip), %rdi      # 0x80a8
callq 0x2160
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x5580
movl $0xa, %edi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/stats.c
// Function: xfer_stats_thread_footer
void xfer_stats_thread_footer(double sum, double sum_sqr, unsigned int n,
			      const struct print_options *opts)
{
	double avg, mdev;

	avg = sum / n;
	mdev = mdev_n(sum, sum_sqr, n);
	fputs("thread average ", stdout);
	print_rate(avg, opts);
	fputs(", mdev ", stdout);
	print_rate(mdev, opts);
	printf(" (%.1lf%%)\n", 100 * mdev / avg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movl -0x14(%rbp), %edi
callq 0x50c0
movsd %xmm0, -0x30(%rbp)
movq 0x59c3(%rip), %rax      # 0xafd0
movq (%rax), %rsi
leaq 0x2a67(%rip), %rdi      # 0x807e
callq 0x2160
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0x52f0
movq 0x599f(%rip), %rax      # 0xafd0
movq (%rax), %rsi
leaq 0x2a53(%rip), %rdi      # 0x808e
callq 0x2160
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0x52f0
movsd 0x19d2(%rip), %xmm0     # 0x7028
mulsd -0x30(%rbp), %xmm0
divsd -0x28(%rbp), %xmm0
leaq 0x2a2f(%rip), %rdi      # 0x8096
movb $0x1, %al
callq 0x2130
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/estimate.c
// Function: tval
static double tval(unsigned int nu, enum confid_level level)
{
	if (nu < sizeof(crit_values) / sizeof(crit_values[0]))
		return crit_values[nu][level];

	return tval_coeffs[level].c0 + tval_coeffs[level].c1 / nu +
	       tval_coeffs[level].c2 / (nu * nu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x65, %rax
jae 0x5cc5
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x5641(%rip), %rax      # 0xb2f0
shlq $0x4, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5d0d
movl -0x10(%rbp), %eax
leaq (%rax,%rax,2), %rdx
leaq 0x5c6d(%rip), %rcx      # 0xb940
movsd (%rcx,%rdx,8), %xmm0
movsd 0x8(%rcx,%rdx,8), %xmm1
movl -0xc(%rbp), %eax
movl %eax, %esi
movl %esi, %eax
cvtsi2sd %rsi, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd 0x10(%rcx,%rdx,8), %xmm1
imull %eax, %eax
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_init
void iface_init(void)
{
  initscr();
  atexit(iface_exit_handler);
  noecho();
  keypad(stdscr, TRUE);
  timeout(0); /* Non-blocking mode */

  if (iface_invalid_size()) {
    strncpy(iface_end_msg, 
      "Invalid size of terminal. (Must be atleast 80x24.)", IFACE_END_MSG_MAX);
    exit(0);
  }

  strncpy(iface_end_msg, "Abnormal termination.", IFACE_END_MSG_MAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1080
leaq 0x80(%rip), %rdi        # 0x14c0
callq 0x2910
callq 0x1060
movq 0x3b8f(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x10a0
movq 0x3b7b(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x10d0
callq 0x15d0
cmpl $0x0, %eax
je 0x1498
leaq 0x3c70(%rip), %rdi      # 0x50f0
leaq 0x1c3b(%rip), %rsi      # 0x30c2
movl $0x50, %edx
callq 0x1040
xorl %edi, %edi
callq 0x1130
leaq 0x3c51(%rip), %rdi      # 0x50f0
leaq 0x1c4f(%rip), %rsi      # 0x30f5
movl $0x50, %edx
callq 0x1040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_exit_handler
static void iface_exit_handler(void)
{
  char *rating;

  if (game_state.score >= 3000)
    rating = "Perfect";
  else if (game_state.score > 2500)
    rating = "Very Good";
  else if (game_state.score > 2000)
    rating = "Good";
  else if (game_state.score > 1000)
    rating = "Mediocre";
  else if (game_state.score > 0)
    rating = "Poor";
  else
    rating = "Horrible";

  endwin();
  printf("\n%s\n", iface_end_msg);
  printf("%d invaders survived, and %d shots were wasted.\n",
    game_invaders_alive(), game_state.wasted_shots);
  printf("Score: %ld (%s)\n", game_state.score, rating);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3c71(%rip), %rax      # 0x5140
cmpq $0xbb8, (%rax)          # imm = 0xBB8
jl 0x14e8
leaq 0x1c79(%rip), %rax      # 0x3158
movq %rax, -0x8(%rbp)
jmp 0x156c
leaq 0x3c51(%rip), %rax      # 0x5140
cmpq $0x9c4, (%rax)          # imm = 0x9C4
jle 0x1505
leaq 0x1c61(%rip), %rax      # 0x3160
movq %rax, -0x8(%rbp)
jmp 0x156a
leaq 0x3c34(%rip), %rax      # 0x5140
cmpq $0x7d0, (%rax)          # imm = 0x7D0
jle 0x1522
leaq 0x1c49(%rip), %rax      # 0x3165
movq %rax, -0x8(%rbp)
jmp 0x1568
leaq 0x3c17(%rip), %rax      # 0x5140
cmpq $0x3e8, (%rax)          # imm = 0x3E8
jle 0x153f
leaq 0x1c31(%rip), %rax      # 0x316a
movq %rax, -0x8(%rbp)
jmp 0x1566
leaq 0x3bfa(%rip), %rax      # 0x5140
cmpq $0x0, (%rax)
jle 0x1559
leaq 0x1c20(%rip), %rax      # 0x3173
movq %rax, -0x8(%rbp)
jmp 0x1564
leaq 0x1c18(%rip), %rax      # 0x3178
movq %rax, -0x8(%rbp)
jmp 0x1566
jmp 0x1568
jmp 0x156a
jmp 0x156c
callq 0x1140
leaq 0x1c09(%rip), %rdi      # 0x3181
leaq 0x3b71(%rip), %rsi      # 0x50f0
movb $0x0, %al
callq 0x1070
callq 0x20c0
movl %eax, %esi
leaq 0x3bac(%rip), %rax      # 0x5140
movswl 0x8(%rax), %edx
leaq 0x1be7(%rip), %rdi      # 0x3186
movb $0x0, %al
callq 0x1070
leaq 0x3b93(%rip), %rax      # 0x5140
movq (%rax), %rsi
movq -0x8(%rbp), %rdx
leaq 0x1bfc(%rip), %rdi      # 0x31b7
movb $0x0, %al
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_invalid_size
int iface_invalid_size(void)
{
  int maxy, maxx;

  getmaxyx(stdscr, maxy, maxx);

  if (maxy < GAME_MAP_HEIGHT)
    return 1;
  else if (maxx < GAME_MAP_WIDTH)
    return 1;
  else
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq 0x3a03(%rip), %rcx      # 0x4fe0
cmpq (%rcx), %rax
je 0x15f8
movq 0x39f7(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1602
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x10(%rbp)
jmp 0x1602
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
movq 0x39cf(%rip), %rcx      # 0x4fe0
cmpq (%rcx), %rax
je 0x162c
movq 0x39c3(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1636
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x1636
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x18, -0x8(%rbp)
jge 0x164b
movl $0x1, -0x4(%rbp)
jmp 0x1661
cmpl $0x50, -0xc(%rbp)
jge 0x165a
movl $0x1, -0x4(%rbp)
jmp 0x1661
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/iface.c
// Function: iface_get_action
iface_action_t iface_get_action(void)
{
  int c;
  iface_action_t action;

  action = ACTION_NONE; /* Default. */

  /* Read character buffer until empty. */
  while ((c = getch()) != ERR) {
    switch (c) {
    case KEY_RESIZE:
      return ACTION_RESIZE;
    case ' ':
    case KEY_UP:
      action = ACTION_SHOOT;
      break;
    case KEY_LEFT:
      action = ACTION_MOVE_LEFT;
      break;
    case KEY_RIGHT:
      action = ACTION_MOVE_RIGHT;
      break;
    case 'q':
    case 'Q':
    case '\e':
      return ACTION_EXIT;
    default:
      break;
    }
  }

  return action;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
movq 0x392a(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x1050
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x1759
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1b, %eax
je 0x1749
jmp 0x16d7
movl -0x10(%rbp), %eax
subl $0x20, %eax
je 0x172e
jmp 0x16e1
movl -0x10(%rbp), %eax
subl $0x51, %eax
je 0x1749
jmp 0x16eb
movl -0x10(%rbp), %eax
subl $0x71, %eax
je 0x1749
jmp 0x16f5
movl -0x10(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x172e
jmp 0x1701
movl -0x10(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x1737
jmp 0x170d
movl -0x10(%rbp), %eax
subl $0x105, %eax            # imm = 0x105
je 0x1740
jmp 0x1719
movl -0x10(%rbp), %eax
subl $0x19a, %eax            # imm = 0x19A
jne 0x1752
jmp 0x1725
movl $0x2, -0x4(%rbp)
jmp 0x175f
movl $0x5, -0xc(%rbp)
jmp 0x1754
movl $0x3, -0xc(%rbp)
jmp 0x1754
movl $0x4, -0xc(%rbp)
jmp 0x1754
movl $0x1, -0x4(%rbp)
jmp 0x175f
jmp 0x1754
jmp 0x16af
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/game.c
// Function: game_init
void game_init(void)
{
  int i, j;

  srand(time(NULL));

  game_state.score = 0;
  game_state.wasted_shots = 0;
  game_state.player_pos = GAME_MAP_WIDTH / 2;
  game_state.invaders_pos_x = game_state.invaders_pos_y = 0;
  game_state.invaders_moving_right = 1;
  game_state.shot_pos_x = game_state.shot_pos_y = -1;
  game_state.bomb_pos_x = game_state.bomb_pos_y = -1;

  for (i = 0; i < GAME_INVADERS; i++) {
    game_state.invader_alive[i] = true;
  }

  for (i = 0; i < GAME_SHIELDS; i++) {
    for (j = 0; j < GAME_SHIELD_PARTS; j++) {
      game_state.shield_intact[i][j] = true;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x10e0
movl %eax, %edi
callq 0x10b0
movq $0x0, 0x315d(%rip) # 0x5140
movw $0x0, 0x315c(%rip)      # 0x5148
movw $0x28, 0x3155(%rip)     # 0x514a
movw $0x0, 0x314e(%rip)      # 0x514c
movw $0x0, 0x3147(%rip)      # 0x514e
movw $0x1, 0x3140(%rip)      # 0x5150
movw $0xffff, 0x3139(%rip)   # imm = 0xFFFF
movw $0xffff, 0x3132(%rip)   # imm = 0xFFFF
movw $0xffff, 0x312b(%rip)   # imm = 0xFFFF
movw $0xffff, 0x3124(%rip)   # imm = 0xFFFF
movl $0x0, -0x4(%rbp)
cmpl $0x1e, -0x4(%rbp)
jge 0x205c
movslq -0x4(%rbp), %rcx
leaq 0x30f4(%rip), %rax      # 0x5140
movb $0x1, 0x1a(%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x203b
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x20ac
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x209f
movslq -0x4(%rbp), %rcx
leaq 0x30bf(%rip), %rax      # 0x5140
addq $0x38, %rax
imulq $0xa, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2070
jmp 0x20a1
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2063
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/game.c
// Function: game_invaders_alive
int game_invaders_alive(void)
{
  int i, n = 0;
  for (i = 0; i < GAME_INVADERS; i++) {
    if (game_state.invader_alive[i])
      n++;
  }
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x1e, -0x4(%rbp)
jge 0x2100
movslq -0x4(%rbp), %rcx
leaq 0x305d(%rip), %rax      # 0x5140
testb $0x1, 0x1a(%rax,%rcx)
je 0x20f3
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x20f5
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x20d2
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/invaders/game.c
// Function: game_fire_shot
void game_fire_shot(void)
{
  if (game_state.shot_pos_y >= 0)
    return; /* A shot is already being fired. */
    
  game_state.shot_pos_y = GAME_MAP_HEIGHT - 1;
  game_state.shot_pos_x = game_state.player_pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movswl 0x3037(%rip), %eax      # 0x5152
cmpl $0x0, %eax
jl 0x2122
jmp 0x2139
movw $0x17, 0x3027(%rip)     # 0x5152
movw 0x3018(%rip), %ax       # 0x514a
movw %ax, 0x301b(%rip)       # 0x5154
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/usleep-until.c
// Function: main
int main(int argc, char **argv) {
    if (argc < 2) {
        usage_error(argv[0]);
    }
    const int seconds = atoi(argv[1]);
    if (seconds <= 0) {
        usage_error(argv[0]);
    }

    struct timeval tv;
    gettimeofday(&tv, NULL);

    time_t sleep_seconds = seconds - tv.tv_sec % seconds - 1;
    suseconds_t sleep_useconds = ONE_MILLION - tv.tv_usec;
    if (sleep_useconds == ONE_MILLION) {
        sleep_useconds = 0;
        sleep_seconds ++;
    }

    usleep(ONE_MILLION * (useconds_t)sleep_seconds + sleep_useconds);

    if (argc > 2) {
        execvp(argv[2], argv+2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x11b8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1280
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x11da
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1280
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1030
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movq -0x40(%rbp), %rax
subq %rdx, %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movl $0xf4240, %eax          # imm = 0xF4240
subq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0xf4240, -0x38(%rbp)   # imm = 0xF4240
jne 0x1236
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
imull $0xf4240, %eax, %eax    # imm = 0xF4240
movl %eax, %eax
addq -0x38(%rbp), %rax
movl %eax, %edi
callq 0x1080
cmpl $0x2, -0x8(%rbp)
jle 0x1268
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1050
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
	static char buf[BUFSIZ];
	static int buflen = 0;
	int written;
	int ret;

	/* append read bytes to unprocessed bytes */
	if ((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0)
		die("couldn't read from shell: %s\n", strerror(errno));
	buflen += ret;

	written = twrite(buf, buflen, 0);
	buflen -= written;
	/* keep any uncomplete utf8 char for the next call */
	if (buflen > 0)
		memmove(buf, buf + written, buflen);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x120aa(%rip), %edi     # 0x18da8
movslq 0x140ab(%rip), %rax     # 0x1adb0
leaq 0x120a4(%rip), %rsi     # 0x18db0
addq %rax, %rsi
movslq 0x1409a(%rip), %rax     # 0x1adb0
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x51c0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jge 0x6d48
callq 0x5560
movl (%rax), %edi
callq 0x5420
movq %rax, %rsi
leaq 0xab56(%rip), %rdi      # 0x11897
movb $0x0, %al
callq 0x5a60
movl -0x8(%rbp), %eax
addl 0x1405f(%rip), %eax     # 0x1adb0
movl %eax, 0x14059(%rip)     # 0x1adb0
movl 0x14053(%rip), %esi     # 0x1adb0
leaq 0x1204c(%rip), %rdi     # 0x18db0
xorl %edx, %edx
callq 0x6dc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movl 0x14039(%rip), %eax     # 0x1adb0
subl %ecx, %eax
movl %eax, 0x14031(%rip)     # 0x1adb0
cmpl $0x0, 0x1402a(%rip)     # 0x1adb0
jle 0x6da9
movslq -0x4(%rbp), %rax
leaq 0x1201d(%rip), %rsi     # 0x18db0
addq %rax, %rsi
movslq 0x14013(%rip), %rdx     # 0x1adb0
leaq 0x1200c(%rip), %rdi     # 0x18db0
callq 0x54d0
movslq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/st.c
// Function: base64dec
char *
base64dec(const char *src)
{
	size_t in_len = strlen(src);
	char *result, *dst;

	if (in_len % 4)
		in_len += 4 - (in_len % 4);
	result = dst = xmalloc(in_len / 4 * 3 + 1);
	while (*src) {
		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
		int d = base64_digits[(unsigned char) base64dec_getc(&src)];

		*dst++ = (a << 2) | ((b & 0x30) >> 4);
		if (c == -1)
			break;
		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
		if (d == -1)
			break;
		*dst++ = ((c & 0x03) << 6) | d;
	}
	*dst = '\0';
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5340
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xa65f
movq -0x10(%rbp), %rcx
andq $0x3, %rcx
movl $0x4, %eax
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
imulq $0x3, %rax, %rdi
addq $0x1, %rdi
callq 0x5a10
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa778
leaq -0x8(%rbp), %rdi
callq 0xa8f0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x7062(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa8f0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x7046(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa8f0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x702a(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xa8f0
movzbl %al, %eax
movl %eax, %ecx
leaq 0x700e(%rip), %rax      # 0x11700
movsbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
shll $0x2, %eax
movl -0x28(%rbp), %ecx
andl $0x30, %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $-0x1, -0x2c(%rbp)
jne 0xa725
jmp 0xa778
movl -0x28(%rbp), %eax
andl $0xf, %eax
shll $0x4, %eax
movl -0x2c(%rbp), %ecx
andl $0x3c, %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $-0x1, -0x30(%rbp)
jne 0xa754
jmp 0xa778
movl -0x2c(%rbp), %eax
andl $0x3, %eax
shll $0x6, %eax
orl -0x30(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xa67c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/st.c
// Function: selscroll
void
selscroll(int orig, int n)
{
	if (sel.ob.x == -1)
		return;

	if (BETWEEN(sel.ob.y, orig, term.bot) || BETWEEN(sel.oe.y, orig, term.bot)) {
		if ((sel.ob.y += n) > term.bot || (sel.oe.y += n) < term.top) {
			selclear();
			return;
		}
		if (sel.type == SEL_RECTANGULAR) {
			if (sel.ob.y < term.top)
				sel.ob.y = term.top;
			if (sel.oe.y > term.bot)
				sel.oe.y = term.bot;
		} else {
			if (sel.ob.y < term.top) {
				sel.ob.y = term.top;
				sel.ob.x = 0;
			}
			if (sel.oe.y > term.bot) {
				sel.oe.y = term.bot;
				sel.oe.x = term.col;
			}
		}
		selnormalize();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $-0x1, 0xd517(%rip)     # 0x18d2c
jne 0xb81c
jmp 0xb91e
movl -0x4(%rbp), %eax
cmpl 0xd50b(%rip), %eax      # 0x18d30
jg 0xb835
movl 0xd503(%rip), %eax      # 0x18d30
cmpl 0xd555(%rip), %eax      # 0x18d88
jle 0xb856
movl -0x4(%rbp), %eax
cmpl 0xd4fa(%rip), %eax      # 0x18d38
jg 0xb91e
movl 0xd4ee(%rip), %eax      # 0x18d38
cmpl 0xd538(%rip), %eax      # 0x18d88
jg 0xb91e
movl -0x8(%rbp), %eax
addl 0xd4d1(%rip), %eax      # 0x18d30
movl %eax, 0xd4cb(%rip)      # 0x18d30
cmpl 0xd51d(%rip), %eax      # 0x18d88
jg 0xb884
movl -0x8(%rbp), %eax
addl 0xd4c2(%rip), %eax      # 0x18d38
movl %eax, 0xd4bc(%rip)      # 0x18d38
cmpl 0xd502(%rip), %eax      # 0x18d84
jge 0xb88e
callq 0x5df0
jmp 0xb91e
cmpl $0x2, 0xd47f(%rip)      # 0x18d14
jne 0xb8cd
movl 0xd493(%rip), %eax      # 0x18d30
cmpl 0xd4e1(%rip), %eax      # 0x18d84
jge 0xb8b1
movl 0xd4d9(%rip), %eax      # 0x18d84
movl %eax, 0xd47f(%rip)      # 0x18d30
movl 0xd481(%rip), %eax      # 0x18d38
cmpl 0xd4cb(%rip), %eax      # 0x18d88
jle 0xb8cb
movl 0xd4c3(%rip), %eax      # 0x18d88
movl %eax, 0xd46d(%rip)      # 0x18d38
jmp 0xb919
movl 0xd45d(%rip), %eax      # 0x18d30
cmpl 0xd4ab(%rip), %eax      # 0x18d84
jge 0xb8f1
movl 0xd4a3(%rip), %eax      # 0x18d84
movl %eax, 0xd449(%rip)      # 0x18d30
movl $0x0, 0xd43b(%rip)      # 0x18d2c
movl 0xd441(%rip), %eax      # 0x18d38
cmpl 0xd48b(%rip), %eax      # 0x18d88
jle 0xb917
movl 0xd483(%rip), %eax      # 0x18d88
movl %eax, 0xd42d(%rip)      # 0x18d38
movl 0xd433(%rip), %eax      # 0x18d44
movl %eax, 0xd41d(%rip)      # 0x18d34
jmp 0xb919
callq 0x5e30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/x.c
// Function: xximspot
void
xximspot(int x, int y)
{
	XPoint spot = { borderpx + x * win.cw, borderpx + (y + 1) * win.ch };
	XVaNestedList attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);

	XSetICValues(xw.xic, XNPreeditAttributes, attr, NULL);
	XFree(attr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x9b24(%rip), %eax      # 0x16f28
movl -0x4(%rbp), %ecx
imull 0xe0d6(%rip), %ecx      # 0x1b4e4
addl %ecx, %eax
movw %ax, -0xc(%rbp)
movl 0x9b0e(%rip), %eax      # 0x16f28
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
imull 0xe0b9(%rip), %ecx      # 0x1b4e0
addl %ecx, %eax
movw %ax, -0xa(%rbp)
xorl %edi, %edi
leaq 0x49fe(%rip), %rsi      # 0x11e34
leaq -0xc(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x56b0
movq %rax, -0x18(%rbp)
movq 0xdfe0(%rip), %rdi      # 0x1b430
movq -0x18(%rbp), %rdx
leaq 0x49e6(%rip), %rsi      # 0x11e41
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x5240
movq -0x18(%rbp), %rdi
callq 0x5090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/x.c
// Function: xsetcursor
int
xsetcursor(int cursor)
{
	DEFAULT(cursor, 1);
	if (!BETWEEN(cursor, 0, 6))
		return 1;
	win.cursor = cursor;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xd555
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xd55f
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd55f
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl -0x8(%rbp), %eax
jg 0xd572
cmpl $0x6, -0x8(%rbp)
jle 0xd57b
movl $0x1, -0x4(%rbp)
jmp 0xd58b
movl -0x8(%rbp), %eax
movl %eax, 0xdf68(%rip)      # 0x1b4ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/x.c
// Function: ximopen
void
ximopen(Display *dpy)
{
	XIMCallback destroy = { .client_data = NULL, .callback = ximdestroy };

	if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) {
		XSetLocaleModifiers("@im=local");
		if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL) {
			XSetLocaleModifiers("@im=");
			if ((xw.xim = XOpenIM(xw.dpy, NULL, NULL, NULL)) == NULL)
				die("XOpenIM failed. Could not open input device.\n");
		}
	}
	if (XSetIMValues(xw.xim, XNDestroyCallback, &destroy, NULL) != NULL)
		die("XSetIMValues failed. Could not set input method value.\n");
	xw.xic = XCreateIC(xw.xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
				XNClientWindow, xw.win, XNFocusWindow, xw.win, NULL);
	if (xw.xic == NULL)
		die("XCreateIC failed. Could not obtain input method.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6c1d(%rip), %rax      # 0x15d90
movq %rax, -0x18(%rbp)
movq 0x6c1a(%rip), %rax      # 0x15d98
movq %rax, -0x10(%rbp)
movq 0xc257(%rip), %rdi      # 0x1b3e0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5680
movq %rax, 0xc289(%rip)      # 0x1b428
cmpq $0x0, %rax
jne 0xf215
leaq 0x2fa6(%rip), %rdi      # 0x12152
callq 0x5750
movq 0xc228(%rip), %rdi      # 0x1b3e0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5680
movq %rax, 0xc25a(%rip)      # 0x1b428
cmpq $0x0, %rax
jne 0xf213
leaq 0x2f81(%rip), %rdi      # 0x1215c
callq 0x5750
movq 0xc1f9(%rip), %rdi      # 0x1b3e0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x5680
movq %rax, 0xc22b(%rip)      # 0x1b428
cmpq $0x0, %rax
jne 0xf211
leaq 0x2f57(%rip), %rdi      # 0x12161
movb $0x0, %al
callq 0x5a60
jmp 0xf213
jmp 0xf215
movq 0xc20c(%rip), %rdi      # 0x1b428
leaq 0x2f6c(%rip), %rsi      # 0x1218f
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x5590
cmpq $0x0, %rax
je 0xf246
leaq 0x2f60(%rip), %rdi      # 0x1219f
movb $0x0, %al
callq 0x5a60
movq 0xc1db(%rip), %rdi      # 0x1b428
movq 0xc19c(%rip), %r8       # 0x1b3f0
movq 0xc195(%rip), %rax      # 0x1b3f0
leaq 0x2f75(%rip), %rsi      # 0x121d7
movl $0x408, %edx            # imm = 0x408
leaq 0x2f74(%rip), %rcx      # 0x121e2
leaq 0x2f7a(%rip), %r9       # 0x121ef
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x5030
movq %rax, 0xc19d(%rip)      # 0x1b430
cmpq $0x0, 0xc195(%rip)      # 0x1b430
jne 0xf2ab
leaq 0x2f57(%rip), %rdi      # 0x121fb
movb $0x0, %al
callq 0x5a60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/x.c
// Function: brelease
void
brelease(XEvent *e)
{
	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
		mousereport(e);
		return;
	}

	if (e->xbutton.button == Button2)
		selpaste(NULL);
	else if (e->xbutton.button == Button1)
		mousesel(e, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xb756(%rip), %eax      # 0x1b4e8
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0xfdb9
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x8f07(%rip), %eax      # 0x18cb0
cmpl $0x0, %eax
jne 0xfdb9
movq -0x8(%rbp), %rdi
callq 0x10a10
jmp 0xfde8
movq -0x8(%rbp), %rax
cmpl $0x2, 0x54(%rax)
jne 0xfdce
xorl %eax, %eax
movl %eax, %edi
callq 0x10880
jmp 0xfde8
movq -0x8(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0xfde6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x10d60
jmp 0xfde8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/x.c
// Function: bmotion
void
bmotion(XEvent *e)
{
	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) {
		mousereport(e);
		return;
	}

	mousesel(e, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xb6e6(%rip), %eax      # 0x1b4e8
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0xfe29
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x8e97(%rip), %eax      # 0x18cb0
cmpl $0x0, %eax
jne 0xfe29
movq -0x8(%rbp), %rdi
callq 0x10a10
jmp 0xfe34
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10d60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/garbeam[P]st/x.c
// Function: focus
void
focus(XEvent *ev)
{
	XFocusChangeEvent *e = &ev->xfocus;

	if (e->mode == NotifyGrab)
		return;

	if (ev->type == FocusIn) {
		XSetICFocus(xw.xic);
		win.mode |= MODE_FOCUSED;
		xseturgency(0);
		if (IS_SET(MODE_FOCUS))
			ttywrite("\033[I", 3, 0);
	} else {
		XUnsetICFocus(xw.xic);
		win.mode &= ~MODE_FOCUSED;
		if (IS_SET(MODE_FOCUS))
			ttywrite("\033[O", 3, 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0xfe63
jmp 0xfef3
movq -0x8(%rbp), %rax
cmpl $0x9, (%rax)
jne 0xfeb3
movq 0xb5bd(%rip), %rdi      # 0x1b430
callq 0x5610
movl 0xb66a(%rip), %eax      # 0x1b4e8
orl $0x2, %eax
movl %eax, 0xb661(%rip)      # 0x1b4e8
xorl %edi, %edi
callq 0xd5e0
movl 0xb654(%rip), %eax      # 0x1b4e8
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xfeb1
leaq 0x2747(%rip), %rdi      # 0x125ec
movl $0x3, %esi
xorl %edx, %edx
callq 0x6ef0
jmp 0xfef3
movq 0xb576(%rip), %rdi      # 0x1b430
callq 0x5390
movl 0xb623(%rip), %eax      # 0x1b4e8
andl $-0x3, %eax
movl %eax, 0xb61a(%rip)      # 0x1b4e8
movl 0xb614(%rip), %eax      # 0x1b4e8
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xfef1
leaq 0x270b(%rip), %rdi      # 0x125f0
movl $0x3, %esi
xorl %edx, %edx
callq 0x6ef0
jmp 0xfef3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_soapC.c
// Function: soap_putheader
SOAP_FMAC4 soap_putheader(struct soap *soap)
{
	if (soap->header)
	{	soap->part = SOAP_IN_HEADER;
		if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
			return soap->error;
		soap->part = SOAP_END_HEADER;
	}
	return SOAP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x5f30(%rax)
je 0x35ea
movq -0x10(%rbp), %rax
movw $0x3, 0x18590(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x5f30(%rax), %rcx
leaq 0x755c3(%rip), %rsi     # 0x78b80
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %r8d
callq 0x3600
cmpl $0x0, %eax
je 0x35dd
movq -0x10(%rbp), %rax
movl 0x19214(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x35f1
movq -0x10(%rbp), %rax
movw $0x4, 0x18590(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_soapC.c
// Function: soap_getheader
SOAP_FMAC4 soap_getheader(struct soap *soap)
{
	soap->part = SOAP_IN_HEADER;
	soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
	soap->part = SOAP_END_HEADER;
	return soap->header == NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw $0x3, 0x18590(%rax)
movq -0x8(%rbp), %rdi
leaq 0x754dc(%rip), %rsi     # 0x78b80
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x36f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x5f30(%rax)
movq -0x8(%rbp), %rax
movw $0x4, 0x18590(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x5f30(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)