LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/omping.c
// Function: omping_send_client_query
static int
omping_send_client_query(struct omping_instance *instance, struct rh_item *ri, int increase)
{
	struct rh_item_ci *ci;
	int send_res;

	ci = &ri->client_info;

	if (increase) {
		if (ci->no_sent + 1 == ((uint64_t)~0)) {
			omping_client_move_to_stop(instance, ri, RH_CSR_SEND_MAXIMUM);
			DEBUG_PRINTF("Maximum number of sent messages for %s exhausted. "
			    "Moving to stop state.", ri->addr->host_name);

			return (0);
		}

		if (instance->send_count_queries > 0 &&
		    ci->no_sent + 1 > instance->send_count_queries) {
			omping_client_move_to_stop(instance, ri, RH_CSR_TO_SEND_EXHAUSTED);
			DEBUG_PRINTF("Number of messages to be sent by %s exhausted. "
			    "Moving to stop state.", ri->addr->host_name);

			return (0);
		}

		ci->seq_num++;
		ci->no_sent++;

		if (ci->seq_num == 0) {
			ci->seq_num_overflow = 1;
			ci->seq_num++;
		}
	}

	send_res = ms_query(instance->ucast_socket, &ri->addr->sas, &instance->mcast_addr.sas,
	    ci->seq_num, ci->client_id, ci->ses_id, ci->ses_id_len);

	return (send_res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8267
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
addq $0x1, %rax
cmpq $-0x1, %rax
jne 0x8199
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x82c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %r8
leaq 0x6e2b(%rip), %rdi      # 0xefa0
movl $0x39c, %esi            # imm = 0x39C
movl $0x2, %edx
leaq 0x6f70(%rip), %rcx      # 0xf0f6
movb $0x0, %al
callq 0x5dc0
movl $0x0, -0x4(%rbp)
jmp 0x82b7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x160(%rax)
jbe 0x820e
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x160(%rcx), %rax
jbe 0x820e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x82c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %r8
leaq 0x6db6(%rip), %rdi      # 0xefa0
movl $0x3a5, %esi            # imm = 0x3A5
movl $0x2, %edx
leaq 0x6f43(%rip), %rcx      # 0xf13e
movb $0x0, %al
callq 0x5dc0
movl $0x0, -0x4(%rbp)
jmp 0x82b7
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe8(%rax)
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd8(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xe8(%rax)
jne 0x8265
movq -0x28(%rbp), %rax
movl $0x1, 0xf0(%rax)
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xe8(%rax)
jmp 0x8267
movq -0x10(%rbp), %rax
movl 0x198(%rax), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x98, %rdx
movq -0x28(%rbp), %rax
movl 0xe8(%rax), %ecx
movq -0x28(%rbp), %r8
addq $0x4, %r8
movq -0x28(%rbp), %rax
movq 0x48(%rax), %r9
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, (%rsp)
callq 0x7220
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/omping.c
// Function: omping_client_move_to_stop
static void
omping_client_move_to_stop(struct omping_instance *instance, struct rh_item *ri,
    enum rh_client_stop_reason stop_reason)
{
	ri->client_info.state = RH_CS_STOP;
	instance->rh_no_active--;

	if (instance->quiet < 2) {
		cliprint_client_state(ri->addr->host_name, instance->hn_max_len,
		    instance->transport_method, NULL, &ri->addr->sas,
		    RH_CS_STOP, stop_reason);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x1a4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1a4(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x180(%rax)
jge 0x833a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x174(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x154(%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %r8
movl -0x14(%rbp), %eax
xorl %ecx, %ecx
movl $0x2, %r9d
movl %eax, (%rsp)
callq 0x50f0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/omping.c
// Function: omping_poll_timeout
static int
omping_poll_timeout(struct omping_instance *instance, struct timeval *old_tstamp, int timeout_time)
{
	int poll_res;

	do {
		poll_res = rs_poll_timeout(instance->ucast_socket, instance->mcast_socket,
		    timeout_time, old_tstamp);

		switch (poll_res) {
		case -1:
			err(2, "Cannot poll on sockets");
			/* NOTREACHED */
			break;
		case -2:
			if (clistate_is_stats_display_requested()) {
				clistate_cancel_stats_display();

				if (instance->op_mode == OMPING_OP_MODE_SHOW_VERSION) {
					cliprint_final_remote_version(&instance->remote_hosts,
					    instance->hn_max_len);
				} else {
					cliprint_final_stats(&instance->remote_hosts,
					    instance->hn_max_len, instance->transport_method);
				}

				cliprint_nl();

				if (!clistate_is_exit_requested()) {
					break;
				}
			}

			return (-2);
			/* NOTREACHED */
			break;
		}
	} while (poll_res < 0);

	return (poll_res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x17c(%rax), %esi
movl 0x198(%rax), %edi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x9df0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $-0x2, %eax
je 0x83a0
jmp 0x837f
movl -0x24(%rbp), %eax
subl $-0x1, %eax
jne 0x8418
jmp 0x838d
movl $0x2, %edi
leaq 0x6e37(%rip), %rsi      # 0xf1d0
movb $0x0, %al
callq 0x2240
callq 0x5a30
cmpl $0x0, %eax
je 0x840f
callq 0x5a10
movq -0x10(%rbp), %rax
cmpl $0x3, 0x150(%rax)
jne 0x83d8
movq -0x10(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq -0x10(%rbp), %rax
movl 0x174(%rax), %esi
callq 0x52e0
jmp 0x83fc
movq -0x10(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq -0x10(%rbp), %rax
movl 0x174(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x154(%rax), %edx
callq 0x5430
callq 0x5760
callq 0x5a20
cmpl $0x0, %eax
jne 0x840d
jmp 0x8418
jmp 0x840f
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x842a
jmp 0x841a
cmpl $0x0, -0x20(%rbp)
jl 0x8353
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/omping.c
// Function: omping_check_msg_common
static int
omping_check_msg_common(const struct msg_decoded *msg_decoded)
{
	if (msg_decoded->msg_type != MSG_TYPE_INIT && msg_decoded->msg_type != MSG_TYPE_RESPONSE &&
	    msg_decoded->msg_type != MSG_TYPE_QUERY && msg_decoded->msg_type != MSG_TYPE_ANSWER) {
		DEBUG_PRINTF("Unknown type %c (0x%X) of message", msg_decoded->msg_type,
		    msg_decoded->msg_type);

		return (-1);
	}

	if (msg_decoded->version != 2) {
		DEBUG_PRINTF("Message version %d is not supported", msg_decoded->version);

		return (-1);
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x49, 0x20(%rax)
je 0x888c
movq -0x10(%rbp), %rax
cmpl $0x53, 0x20(%rax)
je 0x888c
movq -0x10(%rbp), %rax
cmpl $0x51, 0x20(%rax)
je 0x888c
movq -0x10(%rbp), %rax
cmpl $0x41, 0x20(%rax)
je 0x888c
movq -0x10(%rbp), %rax
movl 0x20(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x20(%rax), %r9d
leaq 0x6735(%rip), %rdi      # 0xefa0
movl $0x96, %esi
movl $0x2, %edx
leaq 0x6a51(%rip), %rcx      # 0xf2cd
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x88d7
movq -0x10(%rbp), %rax
movzbl 0x91(%rax), %eax
cmpl $0x2, %eax
je 0x88d0
movq -0x10(%rbp), %rax
movzbl 0x91(%rax), %r8d
leaq 0x66f1(%rip), %rdi      # 0xefa0
movl $0x9c, %esi
movl $0x2, %edx
leaq 0x6a2f(%rip), %rcx      # 0xf2ef
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x88d7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_ci_is_dup_packet
int
rh_ci_is_dup_packet(const struct rh_item_ci *ci, uint32_t seq, int cast_index)
{
	int res;

	if (ci->dup_buffer[cast_index][seq % ci->dup_buf_items] == seq) {
		res = 1;
	} else {
		ci->dup_buffer[cast_index][seq % ci->dup_buf_items] = seq;

		res = 0;
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x50(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0xec(%rcx)
movq -0x20(%rbp), %rax
movl %edx, %ecx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jne 0x98b5
movl $0x1, -0x14(%rbp)
jmp 0x98f0
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x50(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0xec(%rcx)
movq -0x30(%rbp), %rax
movl %edx, %ecx
movl -0x24(%rbp), %edx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_add_item
struct rh_item *
rh_list_add_item(struct rh_list *rh_list, struct ai_item *addr, int dup_buf_items,
    int rate_limit_time)
{
	struct rh_item *rh_item;
	struct rh_item_ci *ci;
	int i;

	rh_item = (struct rh_item *)malloc(sizeof(struct rh_item));
	if (rh_item == NULL) {
		return (NULL);
	}

	memset(rh_item, 0, sizeof(struct rh_item));

	rh_item->addr = addr;
	ci = &rh_item->client_info;

	if (dup_buf_items > 0) {
		ci->dup_buf_items = dup_buf_items;

		for (i = 0; i < 2; i++) {
			ci->dup_buffer[i] = (uint32_t *)malloc(dup_buf_items * sizeof(uint32_t));

			if (ci->dup_buffer[i] == NULL) {
				goto malloc_error;
			}

			memset(ci->dup_buffer[i], 0, dup_buf_items * sizeof(uint32_t));
		}
	}

	if (rate_limit_time > 0) {
		gcra_init(&rh_item->server_info.gcra, rate_limit_time, GCRA_BURST);
	}

	TAILQ_INSERT_TAIL(rh_list, rh_item, entries);

	return (rh_item);

malloc_error:
	for (i = 0; i < 2; i++) {
		free(rh_item->client_info.dup_buffer[i]);
	}
	free(rh_item);

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x148, %edi            # imm = 0x148
callq 0x2250
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9938
movq $0x0, -0x8(%rbp)
jmp 0x9a87
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x148, %edx            # imm = 0x148
callq 0x2150
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x99da
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0xec(%rax)
movl $0x0, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jge 0x99d8
movslq -0x1c(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2250
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, 0x50(%rax,%rcx,8)
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpq $0x0, 0x50(%rax,%rcx,8)
jne 0x99b1
jmp 0x9a4c
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x50(%rax,%rcx,8), %rdi
movslq -0x1c(%rbp), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2150
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9979
jmp 0x99da
cmpl $0x0, -0x20(%rbp)
jle 0x99fc
movq -0x28(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
addq $0x18, %rdi
movl -0x20(%rbp), %esi
movl $0x5, %edx
callq 0x5ad0
jmp 0x99fe
movq -0x28(%rbp), %rax
movq $0x0, 0x138(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x140(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x138, %rcx            # imm = 0x138
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9a87
movl $0x0, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jge 0x9a76
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq 0x58(%rax,%rcx,8), %rdi
callq 0x2040
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x9a53
movq -0x28(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_create
void
rh_list_create(struct rh_list *rh_list, struct aii_list *remote_addrs, int dup_buf_items,
    int rate_limit_time)
{
	struct ai_item *addr;
	struct rh_item *rh_item;

	TAILQ_INIT(rh_list);

	if (remote_addrs != NULL) {
		TAILQ_FOREACH(addr, remote_addrs, entries) {
			rh_item = rh_list_add_item(rh_list, addr, dup_buf_items, rate_limit_time);
			if (rh_item == NULL) {
				errx(1, "Can't alloc memory");
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x9b2c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9b2a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x9900
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9b17
movl $0x1, %edi
leaq 0x46c4(%rip), %rsi      # 0xe1d4
movb $0x0, %al
callq 0x20d0
jmp 0x9b19
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9adf
jmp 0x9b2c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_find
struct rh_item *
rh_list_find(struct rh_list *rh_list, const struct sockaddr *sa)
{
	struct rh_item *rh_item;

	TAILQ_FOREACH(rh_item, rh_list, entries) {
		if (af_sockaddr_eq((const struct sockaddr *)&rh_item->addr->sas, sa))
			return (rh_item);
	}

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9b94
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x24e0
cmpl $0x0, %eax
je 0x9b81
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9b9c
jmp 0x9b83
movq -0x20(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9b5b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_free
void
rh_list_free(struct rh_list *rh_list)
{
	struct rh_item *rh_item;
	struct rh_item *rh_item_next;
	int i;

	rh_item = TAILQ_FIRST(rh_list);

	while (rh_item != NULL) {
		rh_item_next = TAILQ_NEXT(rh_item, entries);

		free(rh_item->client_info.server_info);
		free(rh_item->client_info.ses_id);

		for (i = 0; i < 2; i++) {
			free(rh_item->client_info.dup_buffer[i]);
		}

		free(rh_item);

		rh_item = rh_item_next;
	}

	TAILQ_INIT(rh_list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9c34
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2040
movl $0x0, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jge 0x9c21
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x58(%rax,%rcx,8), %rdi
callq 0x2040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9bfe
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x9bc7
jmp 0x9c36
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_hn_max_len
int
rh_list_hn_max_len(struct rh_list *rh_list)
{
	struct rh_item *rh_item;
	size_t max_len;

	max_len = 0;
	TAILQ_FOREACH(rh_item, rh_list, entries) {
		if (strlen(rh_item->addr->host_name) > max_len) {
			max_len = strlen(rh_item->addr->host_name);
		}
	}

	return (max_len > INT_MAX ? INT_MAX : (int)max_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9d19
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %rdi
callq 0x20c0
cmpq -0x18(%rbp), %rax
jbe 0x9d06
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %rdi
callq 0x20c0
movq %rax, -0x18(%rbp)
jmp 0x9d08
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9ccf
cmpq $0x7fffffff, -0x18(%rbp) # imm = 0x7FFFFFFF
jbe 0x9d2d
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0x9d34
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_length
unsigned int
rh_list_length(const struct rh_list *rh_list)
{
	struct rh_item *rh_item;
	unsigned int res;

	res = 0;

	TAILQ_FOREACH(rh_item, rh_list, entries) {
		res++;
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9d7b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9d5a
movl -0x14(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rhfunc.c
// Function: rh_list_put_to_finish_state
void
rh_list_put_to_finish_state(struct rh_list *rh_list, enum rh_list_finish_state fs)
{
	struct rh_item *rh_item;

	TAILQ_FOREACH(rh_item, rh_list, entries) {
		if (fs == RH_LFS_SERVER || fs == RH_LFS_BOTH) {
			rh_item->server_info.state = RH_SS_FINISHING;
		}
		if (fs == RH_LFS_CLIENT || fs == RH_LFS_BOTH) {
			rh_item->client_info.state = RH_CS_STOP;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9de1
cmpl $0x1, -0xc(%rbp)
je 0x9da9
cmpl $0x2, -0xc(%rbp)
jne 0x9db7
movq -0x18(%rbp), %rax
movl $0x2, 0x100(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x9dc3
cmpl $0x2, -0xc(%rbp)
jne 0x9dce
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rax)
jmp 0x9dd0
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9d96
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/rsfunc.c
// Function: rs_sendto
ssize_t
rs_sendto(int sock, const char *msg, size_t msg_size, const struct sockaddr_storage *to)
{
	ssize_t sent;

	sent = sendto(sock, msg, msg_size, 0, (struct sockaddr *)to, af_sas_len(to));

	if (sent == -1) {
		if (errno == EINTR) {
			DEBUG2_PRINTF("sendto error - EINTR");
			return (-2);
		}

		if (errno == EHOSTUNREACH || errno == EHOSTDOWN || errno == ENETDOWN ||
		    errno == ENOBUFS) {
			DEBUG2_PRINTF("sendto error - EHOSTUNREACH || EHOSTDOWN || ENETDOWN ||"
			    "ENOBUFS");
			return (-3);
		}

		DEBUG2_PRINTF("sendto error - errno = %d", errno);
		return (-1);
	}

	if ((size_t)sent != msg_size) {
		DEBUG2_PRINTF("sendto error - sent != msg_size");

		return (-1);
	}

	return (sent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x33f0
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %r8
movl %eax, %r9d
xorl %ecx, %ecx
callq 0x2160
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0xa54e
callq 0x2050
cmpl $0x4, (%rax)
jne 0xa4cc
leaq 0x51c5(%rip), %rdi      # 0xf66c
movl $0xf0, %esi
movl $0x3, %edx
leaq 0x52c6(%rip), %rcx      # 0xf77e
movb $0x0, %al
callq 0x5dc0
movq $-0x2, -0x8(%rbp)
jmp 0xa589
callq 0x2050
cmpl $0x71, (%rax)
je 0xa4f4
callq 0x2050
cmpl $0x70, (%rax)
je 0xa4f4
callq 0x2050
cmpl $0x64, (%rax)
je 0xa4f4
callq 0x2050
cmpl $0x69, (%rax)
jne 0xa51d
leaq 0x5171(%rip), %rdi      # 0xf66c
movl $0xf7, %esi
movl $0x3, %edx
leaq 0x5287(%rip), %rcx      # 0xf793
movb $0x0, %al
callq 0x5dc0
movq $-0x3, -0x8(%rbp)
jmp 0xa589
callq 0x2050
movl (%rax), %r8d
leaq 0x5140(%rip), %rdi      # 0xf66c
movl $0xfb, %esi
movl $0x3, %edx
leaq 0x5295(%rip), %rcx      # 0xf7d2
movb $0x0, %al
callq 0x5dc0
movq $-0x1, -0x8(%rbp)
jmp 0xa589
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xa581
leaq 0x510d(%rip), %rdi      # 0xf66c
movl $0x100, %esi            # imm = 0x100
movl $0x3, %edx
leaq 0x527c(%rip), %rcx      # 0xf7ec
movb $0x0, %al
callq 0x5dc0
movq $-0x1, -0x8(%rbp)
jmp 0xa589
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_buf_size
int
sfset_buf_size(int sock, int snd_buf, int buf_size, int *new_buf_size, int force_buf_size)
{
	const char *opt_name_s;
	socklen_t optlen;
	int opt_name;
	int res;
	int tmp_buf_size;

	if (snd_buf) {
		opt_name = SO_SNDBUF;
		opt_name_s = "SO_SNDBUF";
	} else {
		opt_name = SO_RCVBUF;
		opt_name_s = "SO_RCVBUF";
	}

	if (buf_size > 0) {
		res = setsockopt(sock, SOL_SOCKET, opt_name, &buf_size, sizeof(buf_size));

		if (res == -1) {
			DEBUG_PRINTF("setsockopt %s failed", opt_name_s);

			return (-1);
		}
	}

	if (new_buf_size == NULL && !force_buf_size) {
		return (0);
	}

	optlen = sizeof(tmp_buf_size);
	res = getsockopt(sock, SOL_SOCKET, opt_name, &tmp_buf_size, &optlen);

	if (res == -1) {
		DEBUG_PRINTF("getsockopt %s failed", opt_name_s);

		return (-1);
	}

	if (force_buf_size && tmp_buf_size < buf_size) {
		VERBOSE_PRINTF("Buffer size request was %u bytes, but only %u"
		    " bytes was allocated", buf_size, tmp_buf_size);
		errno = ENOBUFS;
		return (-1);
	}

	if (new_buf_size != NULL) {
		*new_buf_size = tmp_buf_size;
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa5d3
movl $0x7, -0x30(%rbp)
leaq 0x523f(%rip), %rax      # 0xf80c
movq %rax, -0x28(%rbp)
jmp 0xa5e5
movl $0x8, -0x30(%rbp)
leaq 0x5235(%rip), %rax      # 0xf816
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0xa63f
movl -0x8(%rbp), %edi
movl -0x30(%rbp), %edx
movl $0x1, %esi
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0xa63d
movq -0x28(%rbp), %r8
leaq 0x5207(%rip), %rdi      # 0xf820
movl $0x43, %esi
movl $0x2, %edx
leaq 0x51fe(%rip), %rcx      # 0xf828
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa70c
jmp 0xa63f
cmpq $0x0, -0x18(%rbp)
jne 0xa658
cmpl $0x0, -0x1c(%rbp)
jne 0xa658
movl $0x0, -0x4(%rbp)
jmp 0xa70c
movl $0x4, -0x2c(%rbp)
movl -0x8(%rbp), %edi
movl -0x30(%rbp), %edx
movl $0x1, %esi
leaq -0x38(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x2190
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0xa6ac
movq -0x28(%rbp), %r8
leaq 0x5195(%rip), %rdi      # 0xf820
movl $0x51, %esi
movl $0x2, %edx
leaq 0x51a1(%rip), %rcx      # 0xf83d
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa70c
cmpl $0x0, -0x1c(%rbp)
je 0xa6f5
movl -0x38(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xa6f5
movl -0x10(%rbp), %r8d
movl -0x38(%rbp), %r9d
leaq 0x5157(%rip), %rdi      # 0xf820
movl $0x58, %esi
movl $0x1, %edx
leaq 0x5178(%rip), %rcx      # 0xf852
movb $0x0, %al
callq 0x5dc0
callq 0x2050
movl $0x69, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa70c
cmpq $0x0, -0x18(%rbp)
je 0xa705
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_broadcast
int
sfset_broadcast(int sock, int enable)
{
	int opt;

	opt = (enable ? 1 : 0);

	if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(opt)) == -1) {
		DEBUG_PRINTF("setsockopt SO_BROADCAST failed");

		return (-1);
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x6, %edx
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xa78a
leaq 0x50b7(%rip), %rdi      # 0xf820
movl $0x70, %esi
movl $0x2, %edx
leaq 0x511a(%rip), %rcx      # 0xf894
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa791
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_ipv6only
int
sfset_ipv6only(const struct sockaddr *sa, int sock)
{
	int opt;

	opt = 1;

	if (sa->sa_family != AF_INET6) {
		return (-1);
	}

#ifdef IPV6_V6ONLY
	if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt)) == -1) {
		DEBUG_PRINTF("setsockopt IPV6_V6ONLY failed");

		return (-1);
	}
#endif

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
je 0xa7cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa81b
movl -0x14(%rbp), %edi
movl $0x29, %esi
movl $0x1a, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xa814
leaq 0x502d(%rip), %rdi      # 0xf820
movl $0x89, %esi
movl $0x2, %edx
leaq 0x50af(%rip), %rcx      # 0xf8b3
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa81b
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/jfriesse[P]omping/sfset.c
// Function: sfset_mcast_if
int
sfset_mcast_if(const struct sockaddr *local_addr, int sock, const char *local_ifname)
{
	int iface_index;

	switch (local_addr->sa_family) {
	case AF_INET:
		if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
		    &((struct sockaddr_in *)local_addr)->sin_addr, sizeof(struct in_addr)) == -1) {
			DEBUG_PRINTF("setsockopt IP_MULTICAST_IF failed");

			return (-1);
		}
		break;
	case AF_INET6:
		iface_index = if_nametoindex(local_ifname);
		if (iface_index == 0) {
			DEBUG_PRINTF("if_nametoindex cannot convert iface name %s to index",
			    local_ifname);

			return (-1);
		}

		if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, &iface_index,
		    sizeof(iface_index)) == -1) {
			DEBUG_PRINTF("setsockopt IPV6_MULTICAST_IF failed");

			return (-1);
		}
		break;

	default:
		DEBUG_PRINTF("Unknown sockaddr family");
		errx(1, "Unknown sockaddr family");
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x2, %eax
je 0xa861
jmp 0xa854
movl -0x28(%rbp), %eax
subl $0xa, %eax
je 0xa8b3
jmp 0xa93f
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
xorl %esi, %esi
movl $0x20, %edx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xa8ae
leaq 0x4f96(%rip), %rdi      # 0xf820
movl $0xa1, %esi
movl $0x2, %edx
leaq 0x5036(%rip), %rcx      # 0xf8d1
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa978
jmp 0xa971
movq -0x20(%rbp), %rdi
callq 0x21e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xa8f4
movq -0x20(%rbp), %r8
leaq 0x4f50(%rip), %rdi      # 0xf820
movl $0xaa, %esi
movl $0x2, %edx
leaq 0x5012(%rip), %rcx      # 0xf8f3
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa978
movl -0x14(%rbp), %edi
movl $0x29, %esi
movl $0x11, %edx
leaq -0x24(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xa93d
leaq 0x4f04(%rip), %rdi      # 0xf820
movl $0xb1, %esi
movl $0x2, %edx
leaq 0x4ffb(%rip), %rcx      # 0xf928
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa978
jmp 0xa971
leaq 0x4eda(%rip), %rdi      # 0xf820
movl $0xb8, %esi
movl $0x2, %edx
leaq 0x376a(%rip), %rcx      # 0xe0c1
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0x3757(%rip), %rsi      # 0xe0c1
movb $0x0, %al
callq 0x20d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_mcast_loop
int
sfset_mcast_loop(const struct sockaddr *mcast_addr, int sock, int enable)
{
	uint8_t val;
	int ival;

	val = (enable ? 1 : 0);
	ival = val;

	switch (mcast_addr->sa_family) {
	case AF_INET:
		if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, &val, sizeof(val)) == -1) {
			DEBUG_PRINTF("setsockopt IP_MULTICAST_LOOP failed");

			return (-1);
		}
		break;
	case AF_INET6:
		if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &ival,
		    sizeof(ival)) == -1) {
			DEBUG_PRINTF("setsockopt IPV6_MULTICAST_LOOP failed");

			return (-1);
		}
		break;
	default:
		DEBUG_PRINTF("Unknown sockaddr family");
		errx(1, "Unknown sockaddr family");
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
testl %eax, %eax
setne -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0xa9d0
jmp 0xa9c3
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0xaa1b
jmp 0xaa66
movl -0x14(%rbp), %edi
xorl %esi, %esi
movl $0x22, %edx
leaq -0x19(%rbp), %rcx
movl $0x1, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xaa19
leaq 0x4e2b(%rip), %rdi      # 0xf820
movl $0xd1, %esi
movl $0x2, %edx
leaq 0x4f46(%rip), %rcx      # 0xf94c
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaa9f
jmp 0xaa98
movl -0x14(%rbp), %edi
movl $0x29, %esi
movl $0x13, %edx
leaq -0x20(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xaa64
leaq 0x4ddd(%rip), %rdi      # 0xf820
movl $0xd9, %esi
movl $0x2, %edx
leaq 0x4f1c(%rip), %rcx      # 0xf970
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaa9f
jmp 0xaa98
leaq 0x4db3(%rip), %rdi      # 0xf820
movl $0xdf, %esi
movl $0x2, %edx
leaq 0x3643(%rip), %rcx      # 0xe0c1
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0x3630(%rip), %rsi      # 0xe0c1
movb $0x0, %al
callq 0x20d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_recvttl
int
sfset_recvttl(const struct sockaddr *sa, int sock)
{
	int opt;

	opt = 1;

	switch (sa->sa_family) {
	case AF_INET:
#ifdef IP_RECVTTL
		if (setsockopt(sock, IPPROTO_IP, IP_RECVTTL, &opt, sizeof(opt)) == -1) {
			DEBUG_PRINTF("setsockopt IP_RECVTTL failed");

			return (-1);
		}
#else
		return (-2);
#endif
		break;
	case AF_INET6:
#ifdef IPV6_RECVHOPLIMIT
		if (setsockopt(sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &opt, sizeof(opt)) == -1) {
			DEBUG_PRINTF("setsockopt IPV6_RECVHOPLIMIT failed");

			return (-1);
		}
#else
		if (setsockopt(sock, IPPROTO_IPV6, IPV6_HOPLIMIT, &opt, sizeof(opt)) == -1) {
			DEBUG_PRINTF("setsockopt IPV6_HOPLIMIT failed");

			return (-1);
		}
#endif
		break;
	default:
		DEBUG_PRINTF("Unknown sockaddr family");
		errx(1, "Unknown sockaddr family");
	}


	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0xaae4
jmp 0xaad7
movl -0x1c(%rbp), %eax
subl $0xa, %eax
je 0xab2f
jmp 0xab7a
movl -0x14(%rbp), %edi
xorl %esi, %esi
movl $0xc, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xab2d
leaq 0x4d17(%rip), %rdi      # 0xf820
movl $0xf7, %esi
movl $0x2, %edx
leaq 0x4e7c(%rip), %rcx      # 0xf996
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xabb3
jmp 0xabac
movl -0x14(%rbp), %edi
movl $0x29, %esi
movl $0x33, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xab78
leaq 0x4cc9(%rip), %rdi      # 0xf820
movl $0x102, %esi            # imm = 0x102
movl $0x2, %edx
leaq 0x4e4b(%rip), %rcx      # 0xf9b3
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xabb3
jmp 0xabac
leaq 0x4c9f(%rip), %rdi      # 0xf820
movl $0x10f, %esi            # imm = 0x10F
movl $0x2, %edx
leaq 0x352f(%rip), %rcx      # 0xe0c1
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0x351c(%rip), %rsi      # 0xe0c1
movb $0x0, %al
callq 0x20d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_reuse
int
sfset_reuse(int sock)
{
	int opt;

	opt = 1;

	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) {
		DEBUG_PRINTF("setsockopt SO_REUSEADDR failed");

		return (-1);
	}

#ifdef SO_REUSEPORT
	if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) == -1) {
		DEBUG_PRINTF("setsockopt SO_REUSEPORT failed");

		return (-1);
	}
#endif

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xac1b
leaq 0x4c26(%rip), %rdi      # 0xf820
movl $0x123, %esi            # imm = 0x123
movl $0x2, %edx
leaq 0x4dcc(%rip), %rcx      # 0xf9d7
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xac6b
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0xf, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xac64
leaq 0x4bdd(%rip), %rdi      # 0xf820
movl $0x12a, %esi            # imm = 0x12A
movl $0x2, %edx
leaq 0x4da2(%rip), %rcx      # 0xf9f6
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xac6b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sfset.c
// Function: sfset_timestamp
int
sfset_timestamp(int sock)
{
#ifdef SO_TIMESTAMP
	int opt;

	opt = 1;

	if (setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &opt, sizeof(opt)) == -1) {
		DEBUG_PRINTF("setsockopt SO_TIMESTAMP failed");

		return (-1);
	}
#endif

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x1d, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
cmpl $-0x1, %eax
jne 0xacdb
leaq 0x4b66(%rip), %rdi      # 0xf820
movl $0x140, %esi            # imm = 0x140
movl $0x2, %edx
leaq 0x4d4a(%rip), %rcx      # 0xfa15
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xace2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sockfunc.c
// Function: sf_bind_socket
int
sf_bind_socket(const struct sockaddr *bind_addr, int sock)
{
	if (bind(sock, bind_addr, af_sa_len(bind_addr)) == -1) {
		DEBUG_PRINTF("Can't bind socket");

		return (-1);
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2c20
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movl %eax, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0xaf31
leaq 0x4baa(%rip), %rdi      # 0xfaba
movl $0x32, %esi
movl $0x2, %edx
leaq 0x4ba4(%rip), %rcx      # 0xfac5
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaf38
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sockfunc.c
// Function: sf_cast_type_to_str
const char *
sf_cast_type_to_str(enum sf_cast_type cast_type)
{
	const char *res;

	switch (cast_type) {
	case SF_CT_UNI:
		res = "uni";
		break;
	case SF_CT_MULTI:
		res = "multi";
		break;
	case SF_CT_BROAD:
		res = "broad";
		break;
	default:
		DEBUG_PRINTF("Internal error - unknown transport method");
		errx(1, "Internal error - unknown transport method");
		/* NOTREACHED */
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0xaf7b
jmp 0xaf67
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0xaf88
jmp 0xaf71
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0xaf95
jmp 0xafa2
leaq 0x4b55(%rip), %rax      # 0xfad7
movq %rax, -0x10(%rbp)
jmp 0xafd4
leaq 0x4b4c(%rip), %rax      # 0xfadb
movq %rax, -0x10(%rbp)
jmp 0xafd4
leaq 0x4b45(%rip), %rax      # 0xfae1
movq %rax, -0x10(%rbp)
jmp 0xafd4
leaq 0x4b11(%rip), %rdi      # 0xfaba
movl $0x4d, %esi
movl $0x2, %edx
leaq 0x3b7e(%rip), %rcx      # 0xeb38
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0x3b6b(%rip), %rsi      # 0xeb38
movb $0x0, %al
callq 0x20d0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sockfunc.c
// Function: sf_create_udp_socket
int
sf_create_udp_socket(const struct sockaddr *sa)
{
	int sock;

	sock = socket(sa->sa_family, SOCK_DGRAM, 0);
	if (sock == -1) {
		DEBUG_PRINTF("Can't create socket");
		return (-1);
	}

	return (sock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2350
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xb2a0
leaq 0x483b(%rip), %rdi      # 0xfaba
movl $0xcc, %esi
movl $0x2, %edx
leaq 0x4857(%rip), %rcx      # 0xfae7
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb2a6
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/sockfunc.c
// Function: sf_mcast_join_ssm_group_list
int
sf_mcast_join_ssm_group_list(const struct sockaddr *mcast_addr, const struct sockaddr *local_addr,
    const struct aii_list *remote_addrs, const char *local_ifname, int sock)
{
	struct ai_item *ai_item_i;

	TAILQ_FOREACH(ai_item_i, remote_addrs, entries) {
		if (sf_mcast_join_ssm_group(mcast_addr, local_addr,
		    (const struct sockaddr *)&ai_item_i->sas, local_ifname, sock) == -1) {
			return (-1);
		}
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb638
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0xb890
cmpl $-0x1, %eax
jne 0xb625
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb63f
jmp 0xb627
movq -0x38(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xb5f7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_add
int
tlv_add(char *msg, size_t msg_len, size_t *pos, enum tlv_opt_type opt_type, uint16_t opt_len,
    const void *value)
{
	uint16_t nlen;
	uint16_t nopt_type;

	DEBUG2_PRINTF("Add option %"PRIu16" with len %"PRIu16" pos %zu", opt_type, opt_len, *pos);

	if (*pos + sizeof(nopt_type) + sizeof(nlen) + opt_len > msg_len) {
		DEBUG2_PRINTF("Can't store option. msg_len too small.");
		return (-1);
	}

	nopt_type = ntohs((uint16_t)opt_type);
	memcpy(msg + *pos, &nopt_type, sizeof(nopt_type));
	*pos += sizeof(nopt_type);

	nlen = htons(opt_len);

	memcpy(msg + *pos, &nlen, sizeof(nlen));
	*pos += sizeof(nlen);

	memcpy(msg + *pos, value, opt_len);

	*pos += opt_len;

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %r8w, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movw %ax, -0x26(%rbp)
movq %r9, -0x30(%rbp)
movl -0x24(%rbp), %r8d
movzwl -0x26(%rbp), %r9d
movq -0x20(%rbp), %rax
movq (%rax), %rax
leaq 0x411e(%rip), %rdi      # 0xfc78
movl $0x40, %esi
movl $0x3, %edx
leaq 0x4113(%rip), %rcx      # 0xfc7e
movq %rax, (%rsp)
movb $0x0, %al
callq 0x5dc0
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x2, %rax
addq $0x2, %rax
movzwl -0x26(%rbp), %ecx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jbe 0xbbbd
leaq 0x40df(%rip), %rdi      # 0xfc78
movl $0x43, %esi
movl $0x3, %edx
leaq 0x40f6(%rip), %rcx      # 0xfca0
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbc4c
movl -0x24(%rbp), %eax
movzwl %ax, %edi
callq 0x2280
movw %ax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movw -0x34(%rbp), %dx
movw %dx, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movzwl -0x26(%rbp), %edi
callq 0x20e0
movw %ax, -0x32(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movw -0x32(%rbp), %dx
movw %dx, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq (%rax), %rdi
movq -0x30(%rbp), %rsi
movzwl -0x26(%rbp), %eax
movl %eax, %edx
callq 0x2200
movzwl -0x26(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_add_sas
static int
tlv_add_sas(char *msg, size_t msg_len, size_t *pos, enum tlv_opt_type opt,
    const struct sockaddr_storage *sas, int store_prefix_len)
{
	char *value;
	void *addr_pointer;
	size_t addr_len;
	size_t opt_len;
	uint16_t af;
	uint8_t pref_len_val;

	switch (sas->ss_family) {
	case AF_INET:
		af = AF_IANA_IP;
		addr_len = sizeof(struct in_addr);
		addr_pointer = &((struct sockaddr_in *)sas)->sin_addr;
		break;
	case AF_INET6:
		af = AF_IANA_IP6;
		addr_len = sizeof(struct in6_addr);
		addr_pointer = &((struct sockaddr_in6 *)sas)->sin6_addr;
		break;
	default:
		DEBUG_PRINTF("Unknown sas family %d", sas->ss_family);
		errx(1, "Unknown sas family %d", sas->ss_family);
	}

	pref_len_val = addr_len * 8;

	opt_len = sizeof(af) + addr_len;

	if (store_prefix_len)
		opt_len += sizeof(pref_len_val);

	value = (char *)alloca(opt_len);

	af = htons(af);

	memcpy(value, &af, sizeof(af));
	if (store_prefix_len)
		memcpy(value + sizeof(af), &pref_len_val, sizeof(pref_len_val));

	memcpy(value + sizeof(af) + (store_prefix_len ? sizeof(pref_len_val) : 0), addr_pointer,
	    addr_len);

	return (tlv_add(msg, msg_len, pos, opt, opt_len, value));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x58(%rbp)
subl $0x2, %eax
je 0xbd6a
jmp 0xbd60
movl -0x58(%rbp), %eax
subl $0xa, %eax
je 0xbd86
jmp 0xbda2
movw $0x1, -0x52(%rbp)
movq $0x4, -0x48(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
jmp 0xbde3
movw $0x2, -0x52(%rbp)
movq $0x10, -0x48(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0xbde3
movq -0x28(%rbp), %rax
movzwl (%rax), %r8d
leaq 0x3ec7(%rip), %rdi      # 0xfc78
movl $0xb5, %esi
movl $0x2, %edx
leaq 0x2291(%rip), %rcx      # 0xe053
movb $0x0, %al
callq 0x5dc0
movq -0x28(%rbp), %rax
movzwl (%rax), %edx
movl $0x1, %edi
leaq 0x2277(%rip), %rsi      # 0xe053
movb $0x0, %al
callq 0x20d0
movq -0x48(%rbp), %rax
shlq $0x3, %rax
movb %al, -0x53(%rbp)
movq -0x48(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xbe0c
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x38(%rbp)
movzwl -0x52(%rbp), %edi
callq 0x20e0
movw %ax, -0x52(%rbp)
movq -0x38(%rbp), %rax
movw -0x52(%rbp), %cx
movw %cx, (%rax)
cmpl $0x0, -0x2c(%rbp)
je 0xbe4d
movq -0x38(%rbp), %rax
movb -0x53(%rbp), %cl
movb %cl, 0x2(%rax)
movq -0x38(%rbp), %rdi
addq $0x2, %rdi
movl -0x2c(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovneq %rcx, %rax
addq %rax, %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x2200
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %r9
movzwl %ax, %r8d
callq 0xbb20
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_add_opt_request
int
tlv_add_opt_request(char *msg, size_t msg_len, size_t *pos, uint16_t *opts, size_t opts_len)
{
	char *value;
	size_t val_len;
	unsigned int i;
	uint16_t opt;

	if (opts_len == 0)
		return (-1);

	val_len = opts_len * sizeof(uint16_t);

	value = (char *)alloca(val_len);

	for (i = 0; i < opts_len; i++) {
		opt = htons(opts[i]);

		memcpy(value + i * sizeof(opt), &opt, sizeof(opt));
	}

	return (tlv_add(msg, msg_len, pos, TLV_OPT_TYPE_OPT_REQUEST, val_len, value));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xbf0f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbf99
movq -0x30(%rbp), %rax
addq %rax, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpq -0x30(%rbp), %rax
jae 0xbf74
movq -0x28(%rbp), %rax
movl -0x44(%rbp), %ecx
movzwl (%rax,%rcx,2), %edi
callq 0x20e0
movw %ax, -0x46(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
shlq %rcx
movw -0x46(%rbp), %dx
movw %dx, (%rax,%rcx)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xbf3a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %r9
movl $0x5, %ecx
movzwl %ax, %r8d
callq 0xbb20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_add_server_info
int
tlv_add_server_info(char *msg, size_t msg_len, size_t *pos, const char *server_info)
{
	if (strlen(server_info) == 0)
		return (-1);

	return (tlv_add(msg, msg_len, pos, TLV_OPT_TYPE_SERVER_INFO, strlen(server_info),
	    server_info));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20c0
cmpq $0x0, %rax
jne 0xc030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc072
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %r9
movl $0x6, %ecx
movzwl %ax, %r8d
callq 0xbb20
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)