LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_sa_len
socklen_t
af_sa_len(const struct sockaddr *sa)
{
	socklen_t res;

	switch (sa->sa_family) {
	case AF_INET:
		res = sizeof(struct sockaddr_in);
		break;
	case AF_INET6:
		res = sizeof(struct sockaddr_in6);
		break;
	default:
		DEBUG_PRINTF("Internal program error");
		errx(1,"Internal program error");
		break;
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x2c47
jmp 0x2c3d
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x2c50
jmp 0x2c59
movl $0x10, -0xc(%rbp)
jmp 0x2c8b
movl $0x1c, -0xc(%rbp)
jmp 0x2c8b
leaq 0xb3a4(%rip), %rdi      # 0xe004
movl $0x1ca, %esi            # imm = 0x1CA
movl $0x2, %edx
leaq 0xb3b6(%rip), %rcx      # 0xe027
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0xb3a3(%rip), %rsi      # 0xe027
movb $0x0, %al
callq 0x20d0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_create_any_addr
void
af_create_any_addr(struct sockaddr *sa, int sa_family, uint16_t port)
{
	struct sockaddr_in sa_in;
	struct sockaddr_in6 sa_in6;

	switch (sa_family) {
	case PF_INET:
		memset(&sa_in, 0, sizeof(sa_in));
		sa_in.sin_family = sa_family;
		sa_in.sin_port = htons(port);
		sa_in.sin_addr.s_addr = INADDR_ANY;
		memcpy(sa, &sa_in, sizeof(sa_in));
		break;
	case PF_INET6:
		memset(&sa_in6, 0, sizeof(sa_in6));
		sa_in6.sin6_family = sa_family;
		sa_in6.sin6_port = htons(port);
		sa_in6.sin6_addr = in6addr_any;
		memcpy(sa, &sa_in6, sizeof(sa_in6));
		break;
	default:
		DEBUG_PRINTF("Unknown ai family %d", sa_family);
		errx(1, "Unknown ai family %d", sa_family);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x2, %eax
je 0x2cd0
jmp 0x2cc3
movl -0x40(%rbp), %eax
subl $0xa, %eax
je 0x2d13
jmp 0x2d70
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2150
movl -0xc(%rbp), %eax
movw %ax, -0x20(%rbp)
movzwl -0xe(%rbp), %edi
callq 0x20e0
movw %ax, -0x1e(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2da9
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2150
movl -0xc(%rbp), %eax
movw %ax, -0x3c(%rbp)
movzwl -0xe(%rbp), %edi
callq 0x20e0
movw %ax, -0x3a(%rbp)
movq 0x1028a(%rip), %rax     # 0x12fc8
movq (%rax), %rcx
movq %rcx, -0x34(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq -0x3c(%rbp), %rcx
movq %rcx, (%rax)
movq -0x34(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x2c(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x18(%rax)
jmp 0x2da9
movl -0xc(%rbp), %r8d
leaq 0xb289(%rip), %rdi      # 0xe004
movl $0x12c, %esi            # imm = 0x12C
movl $0x2, %edx
leaq 0xb2b2(%rip), %rcx      # 0xe03e
movb $0x0, %al
callq 0x5dc0
movl -0xc(%rbp), %edx
movl $0x1, %edi
leaq 0xb29c(%rip), %rsi      # 0xe03e
movb $0x0, %al
callq 0x20d0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_host_to_ai
struct addrinfo *
af_host_to_ai(const char *host_name, const char *port, int ip_ver)
{
	struct addrinfo ai_hints, *ai_res0, *ai_i;
	int error;
	char ai_s[LOGGING_SA_TO_STR_LEN];

	memset(&ai_hints, 0, sizeof(ai_hints));
	switch (ip_ver) {
	case 0:
		ai_hints.ai_family = PF_UNSPEC;
		break;
	case 4:
		ai_hints.ai_family = PF_INET;
		break;
	case 6:
		ai_hints.ai_family = PF_INET6;
		break;
	default:
		errx(1, "Unknown PF Family");
		/* NOTREACHED */
	}

	ai_hints.ai_socktype = SOCK_DGRAM;
	ai_hints.ai_protocol = IPPROTO_UDP;
	ai_hints.ai_flags = AI_PASSIVE;

	DEBUG_PRINTF("getaddrinfo for \"%s\" port %s ip_ver %d", host_name,
	    port, ip_ver);
	error = getaddrinfo(host_name, port, &ai_hints, &ai_res0);
	if (error != 0) {
		errx(1, "Can't get addr info for %s: %s", host_name, gai_strerror(error));
	}

	if (logging_get_verbose() >= LOGGING_LEVEL_DEBUG2) {
		for (ai_i = ai_res0; ai_i != NULL; ai_i = ai_i->ai_next) {
			logging_ai_to_str(ai_i, ai_s, sizeof(ai_s));
			DEBUG2_PRINTF("%s", ai_s);
		}
	}

	return (ai_res0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xb4(%rbp)
testl %eax, %eax
je 0x2dfe
jmp 0x2de4
movl -0xb4(%rbp), %eax
subl $0x4, %eax
je 0x2e07
jmp 0x2df1
movl -0xb4(%rbp), %eax
subl $0x6, %eax
je 0x2e10
jmp 0x2e19
movl $0x0, -0x4c(%rbp)
jmp 0x2e2c
movl $0x2, -0x4c(%rbp)
jmp 0x2e2c
movl $0xa, -0x4c(%rbp)
jmp 0x2e2c
movl $0x1, %edi
leaq 0xb244(%rip), %rsi      # 0xe069
movb $0x0, %al
callq 0x20d0
movl $0x2, -0x48(%rbp)
movl $0x11, -0x44(%rbp)
movl $0x1, -0x50(%rbp)
movq -0x8(%rbp), %r8
movq -0x10(%rbp), %r9
movl -0x14(%rbp), %eax
leaq 0xb1b1(%rip), %rdi      # 0xe004
movl $0x151, %esi            # imm = 0x151
movl $0x2, %edx
leaq 0xb217(%rip), %rcx      # 0xe07b
movl %eax, (%rsp)
movb $0x0, %al
callq 0x5dc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x2300
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x2ebc
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0x64(%rbp), %edi
callq 0x2120
movq -0xc0(%rbp), %rdx
movq %rax, %rcx
movl $0x1, %edi
leaq 0xb1ed(%rip), %rsi      # 0xe0a2
movb $0x0, %al
callq 0x20d0
callq 0x5ca0
cmpl $0x3, %eax
jl 0x2f20
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x2f1e
movq -0x60(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x3e, %edx
callq 0x5bc0
leaq -0xb0(%rbp), %r8
leaq 0xb10c(%rip), %rdi      # 0xe004
movl $0x15a, %esi            # imm = 0x15A
movl $0x3, %edx
leaq 0xb819(%rip), %rcx      # 0xe722
movb $0x0, %al
callq 0x5dc0
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x2ece
jmp 0x2f20
movq -0x58(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_sa_supported_ipv
int
af_sa_supported_ipv(const struct sockaddr *sa)
{
	int ipv;

	ipv = 0;

	switch (sa->sa_family) {
	case AF_INET:
		ipv = 4;
		break;
	case AF_INET6:
		ipv = 6;
		break;
	}

	return (ipv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x318a
jmp 0x3180
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x3193
jmp 0x319a
movl $0x4, -0xc(%rbp)
jmp 0x319a
movl $0x6, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_sa_port
uint16_t
af_sa_port(const struct sockaddr *addr)
{
	uint16_t port;

	switch (addr->sa_family) {
	case AF_INET:
		port = (((struct sockaddr_in *)addr)->sin_port);
		break;
	case AF_INET6:
		port = (((struct sockaddr_in6 *)addr)->sin6_port);
		break;
	default:
		DEBUG_PRINTF("Internal program error");
		err(1, "Internal program error");
		break;
	}

	return (port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x31c7
jmp 0x31bd
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x31d5
jmp 0x31e3
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xa(%rbp)
jmp 0x3215
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xa(%rbp)
jmp 0x3215
leaq 0xae1a(%rip), %rdi      # 0xe004
movl $0x1e2, %esi            # imm = 0x1E2
movl $0x2, %edx
leaq 0xae2c(%rip), %rcx      # 0xe027
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0xae19(%rip), %rsi      # 0xe027
movb $0x0, %al
callq 0x2240
movw -0xa(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_sa_set_port
void
af_sa_set_port(struct sockaddr *addr, uint16_t port)
{

	switch (addr->sa_family) {
	case AF_INET:
		((struct sockaddr_in *)addr)->sin_port = port;
		break;
	case AF_INET6:
		((struct sockaddr_in6 *)addr)->sin6_port = port;
		break;
	default:
		DEBUG_PRINTF("Internal program error");
		err(1, "Internal program error");
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x324e
jmp 0x3244
movl -0x10(%rbp), %eax
subl $0xa, %eax
je 0x325c
jmp 0x326a
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
jmp 0x329c
movw -0xa(%rbp), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
jmp 0x329c
leaq 0xad93(%rip), %rdi      # 0xe004
movl $0x1f9, %esi            # imm = 0x1F9
movl $0x2, %edx
leaq 0xada5(%rip), %rcx      # 0xe027
movb $0x0, %al
callq 0x5dc0
movl $0x1, %edi
leaq 0xad92(%rip), %rsi      # 0xe027
movb $0x0, %al
callq 0x2240
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_sa_to_any_addr
void
af_sa_to_any_addr(struct sockaddr *dest, const struct sockaddr *src)
{
	uint16_t port;

	switch (src->sa_family) {
	case PF_INET:
		port = ntohs(((struct sockaddr_in *)src)->sin_port);
		break;
	case PF_INET6:
		port = ntohs(((struct sockaddr_in6 *)src)->sin6_port);
		break;
	default:
		DEBUG_PRINTF("Unknown ai family %d", src->sa_family);
		errx(1, "Unknown ai family %d", src->sa_family);
	}

	af_create_any_addr(dest, src->sa_family, port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x2, %eax
je 0x32db
jmp 0x32d1
movl -0x18(%rbp), %eax
subl $0xa, %eax
je 0x32ee
jmp 0x3301
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x2280
movw %ax, -0x12(%rbp)
jmp 0x3342
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x2280
movw %ax, -0x12(%rbp)
jmp 0x3342
movq -0x10(%rbp), %rax
movzwl (%rax), %r8d
leaq 0xacf4(%rip), %rdi      # 0xe004
movl $0x226, %esi            # imm = 0x226
movl $0x2, %edx
leaq 0xad1d(%rip), %rcx      # 0xe03e
movb $0x0, %al
callq 0x5dc0
movq -0x10(%rbp), %rax
movzwl (%rax), %edx
movl $0x1, %edi
leaq 0xad03(%rip), %rsi      # 0xe03e
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl (%rax), %esi
movzwl -0x12(%rbp), %edx
callq 0x2ca0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/addrfunc.c
// Function: af_sa_to_str
char *
af_sa_to_str(const struct sockaddr *sa, char dst[INET6_ADDRSTRLEN])
{

	dst[0] = 0;

	switch (sa->sa_family) {
	case PF_INET:
		inet_ntop(sa->sa_family, &((struct sockaddr_in *)(sa))->sin_addr, dst,
		    INET6_ADDRSTRLEN);
		break;
	case PF_INET6:
		inet_ntop(sa->sa_family, &((struct sockaddr_in6 *)(sa))->sin6_addr, dst,
		    INET6_ADDRSTRLEN);
		break;
	default:
		return (NULL);
	}

	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0x3392
jmp 0x3388
movl -0x1c(%rbp), %eax
subl $0xa, %eax
je 0x33b1
jmp 0x33d0
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x18(%rbp), %rdx
movl $0x2e, %ecx
callq 0x2030
jmp 0x33da
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdx
movl $0x2e, %ecx
callq 0x2030
jmp 0x33da
movq $0x0, -0x8(%rbp)
jmp 0x33e2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/aiifunc.c
// Function: aii_list_free
void
aii_list_free(struct aii_list *aii_list)
{
	struct ai_item *ai_item;
	struct ai_item *ai_item_next;

	ai_item = TAILQ_FIRST(aii_list);

	while (ai_item != NULL) {
		ai_item_next = TAILQ_NEXT(ai_item, entries);

		free(ai_item->host_name);
		free(ai_item);

		ai_item = ai_item_next;
	}

	TAILQ_INIT(aii_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 0x3460
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3427
jmp 0x3462
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
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/aiifunc.c
// Function: aii_list_ai_to_sa
void
aii_list_ai_to_sa(struct aii_list *aii_list, int ip_ver)
{
	struct sockaddr_storage tmp_sas;
	struct addrinfo *ai_i;
	struct ai_item *ai_item_i;
	char *hn;

	TAILQ_FOREACH(ai_item_i, aii_list, entries) {
		hn = (char *)malloc(strlen(ai_item_i->host_name) + 1);
		if (hn == NULL) {
			errx(1, "Can't alloc memory");
		}

		memcpy(hn, ai_item_i->host_name, strlen(ai_item_i->host_name) + 1);
		ai_item_i->host_name = hn;

		for (ai_i = ai_item_i->ai; ai_i != NULL; ai_i = ai_i->ai_next) {
			if (af_ai_supported_ipv(ai_i) == ip_ver) {
				memset(&tmp_sas, 0, sizeof(tmp_sas));

				memcpy(&tmp_sas, ai_i->ai_addr, ai_i->ai_addrlen);

				freeaddrinfo(ai_item_i->ai);

				memcpy(&ai_item_i->sas, &tmp_sas, sizeof(tmp_sas));
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0xa0(%rbp)
je 0x361a
movq -0xa0(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x20c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x2250
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x34f1
movl $0x1, %edi
leaq 0xacea(%rip), %rsi      # 0xe1d4
movb $0x0, %al
callq 0x20d0
movq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xa0(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xa0(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x20c0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x2200
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0xa0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0x35fe
movq -0x98(%rbp), %rdi
callq 0x29d0
cmpl -0xc(%rbp), %eax
jne 0x35e5
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2150
movq -0x98(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x98(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
leaq -0x90(%rbp), %rdi
callq 0x2200
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
callq 0x2340
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x80, %edx
callq 0x2200
jmp 0x35fe
jmp 0x35e7
movq -0x98(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0x3567
jmp 0x3600
movq -0xa0(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0xa0(%rbp)
jmp 0x34a0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/aiifunc.c
// Function: aii_is_ai_in_list
int
aii_is_ai_in_list(const struct addrinfo *a1, const struct aii_list *aii_list)
{
	struct ai_item *aip;

	TAILQ_FOREACH(aip, aii_list, entries) {
		if (af_ai_deep_eq(a1, aip->ai))
			return (1);
	}

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3d93
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x25f0
cmpl $0x0, %eax
je 0x3d80
movl $0x1, -0x4(%rbp)
jmp 0x3d9a
jmp 0x3d82
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3d5b
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/cliprint.c
// Function: cliprint_final_remote_version
void
cliprint_final_remote_version(const struct rh_list *remote_hosts, int host_name_len)
{
	struct rh_item *rh_item;
	struct rh_item_ci *ci;
	size_t i;
	unsigned char ch;

	printf("\n");

	TAILQ_FOREACH(rh_item, remote_hosts, entries) {
			ci = &rh_item->client_info;

			printf("%-*s : ", host_name_len, rh_item->addr->host_name);

			if (ci->server_info_len == 0) {
				printf("response message not received\n");
			} else {
				for (i = 0; i < ci->server_info_len; i++) {
					ch = ci->server_info[i];

				if (ch >= ' ' && ch < 0x7f && ch != '\\') {
					fputc(ch, stdout);
				} else {
					if (ch == '\\') {
						printf("\\\\");
					} else {
						printf("\\x%02X", ch);
					}
				}
			}

			printf("\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x9a20(%rip), %rdi      # 0xed16
movb $0x0, %al
callq 0x20f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x541c
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x80(%rax), %rdx
leaq 0x96e9(%rip), %rdi      # 0xea20
movb $0x0, %al
callq 0x20f0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x535c
leaq 0x97bf(%rip), %rdi      # 0xeb0f
movb $0x0, %al
callq 0x20f0
jmp 0x5406
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jae 0x53f8
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x20, %eax
jl 0x53b8
movzbl -0x29(%rbp), %eax
cmpl $0x7f, %eax
jge 0x53b8
movzbl -0x29(%rbp), %eax
cmpl $0x5c, %eax
je 0x53b8
movzbl -0x29(%rbp), %edi
movq 0xdc12(%rip), %rax      # 0x12fc0
movq (%rax), %rsi
callq 0x2170
jmp 0x53e5
movzbl -0x29(%rbp), %eax
cmpl $0x5c, %eax
jne 0x53d1
leaq 0x9766(%rip), %rdi      # 0xeb2e
movb $0x0, %al
callq 0x20f0
jmp 0x53e3
movzbl -0x29(%rbp), %esi
leaq 0x9755(%rip), %rdi      # 0xeb31
movb $0x0, %al
callq 0x20f0
jmp 0x53e5
jmp 0x53e7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5364
leaq 0x9917(%rip), %rdi      # 0xed16
movb $0x0, %al
callq 0x20f0
jmp 0x5408
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5308
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/cliprint.c
// Function: cliprint_packet_stats
void
cliprint_packet_stats(const char *host_name, int host_name_len, uint32_t seq, int is_dup,
    size_t msg_len, int dist_set, uint8_t dist, int rtt_set, double rtt, double avg_rtt, int loss,
    enum sf_cast_type cast_type, int cont_stat)
{
	const char *cast_str;

	cast_str = sf_cast_type_to_str(cast_type);

	printf("%-*s : ", host_name_len, host_name);
	printf("%5scast, ", cast_str);
	printf("seq=%"PRIu32, seq);

	if (is_dup) {
		printf(" (dup)");
	}

	printf(", ");
	printf("size=%zu bytes", msg_len);

	if (dist_set) {
		printf(", dist=%"PRIu8, dist);
	}

	if (rtt_set) {
		printf(", time=%.3fms", rtt);
	}

	if (cont_stat) {
		printf(" (");

		if (rtt_set) {
			printf("%.3f avg, ", avg_rtt);
		}

		printf("%d%% loss)", loss);
	}

	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movl 0x28(%rbp), %edi
callq 0xaf50
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
leaq 0x9250(%rip), %rdi      # 0xea20
movb $0x0, %al
callq 0x20f0
movq -0x40(%rbp), %rsi
leaq 0x93a1(%rip), %rdi      # 0xeb83
movb $0x0, %al
callq 0x20f0
movl -0x10(%rbp), %esi
leaq 0x93fc(%rip), %rdi      # 0xebef
movb $0x0, %al
callq 0x20f0
cmpl $0x0, -0x14(%rbp)
je 0x580e
leaq 0x93ef(%rip), %rdi      # 0xebf6
movb $0x0, %al
callq 0x20f0
leaq 0x941a(%rip), %rdi      # 0xec2f
movb $0x0, %al
callq 0x20f0
movq -0x20(%rbp), %rsi
leaq 0x93d6(%rip), %rdi      # 0xebfd
movb $0x0, %al
callq 0x20f0
cmpl $0x0, -0x24(%rbp)
je 0x5846
movzbl 0x10(%rbp), %esi
leaq 0x93cd(%rip), %rdi      # 0xec0c
movb $0x0, %al
callq 0x20f0
cmpl $0x0, 0x18(%rbp)
je 0x585f
movsd -0x30(%rbp), %xmm0
leaq 0x93be(%rip), %rdi      # 0xec16
movb $0x1, %al
callq 0x20f0
cmpl $0x0, 0x30(%rbp)
je 0x589d
leaq 0x93b8(%rip), %rdi      # 0xec24
movb $0x0, %al
callq 0x20f0
cmpl $0x0, 0x18(%rbp)
je 0x588c
movsd -0x38(%rbp), %xmm0
leaq 0x93a2(%rip), %rdi      # 0xec27
movb $0x1, %al
callq 0x20f0
movl 0x20(%rbp), %esi
leaq 0x939c(%rip), %rdi      # 0xec32
movb $0x0, %al
callq 0x20f0
leaq 0x9472(%rip), %rdi      # 0xed16
movb $0x0, %al
callq 0x20f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/clisig.c
// Function: clisig_register_handlers
void
clisig_register_handlers(void)
{
	struct sigaction act;

	act.sa_handler = sigint_handler;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;

	sigaction(SIGINT, &act, NULL);

	act.sa_handler = siginfo_handler;
#ifdef SIGINFO
	sigaction(SIGINFO, &act, NULL);
#endif
	sigaction(SIGUSR1, &act, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x6e(%rip), %rax        # 0x59c0
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x21d0
movl $0x0, -0x10(%rbp)
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2080
leaq 0x54(%rip), %rax        # 0x59e0
movq %rax, -0x98(%rbp)
movl $0xa, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2080
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/clistate.c
// Function: clistate_request_exit
void
clistate_request_exit(void)
{

	exit_requested++;
	DEBUG2_PRINTF("Exit requested %d times", exit_requested);

	if (exit_requested > MAX_EXIT_REQUESTS) {
		signal(SIGINT, SIG_DFL);
		kill(getpid(), SIGINT);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xd77a(%rip), %eax      # 0x131c4
addl $0x1, %eax
movl %eax, 0xd771(%rip)      # 0x131c4
movl 0xd76a(%rip), %r8d      # 0x131c4
leaq 0x92c6(%rip), %rdi      # 0xed27
movl $0x5d, %esi
movl $0x3, %edx
leaq 0x92c0(%rip), %rcx      # 0xed32
movb $0x0, %al
callq 0x5dc0
cmpl $0x2, 0xd744(%rip)      # 0x131c4
jle 0x5aa1
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x21b0
callq 0x20b0
movl %eax, %edi
movl $0x2, %esi
callq 0x2210
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/gcra.c
// Function: gcra_rl
int
gcra_rl(struct gcra_item *item, struct timeval tv)
{
	uint64_t tv_u64;

	tv_u64 = util_tv_to_ms(tv);

	if (item->tat >= item->tau && tv_u64 < item->tat - item->tau) {
		return (0);
	} else {
		item->tat = ((tv_u64 > item->tat) ? tv_u64 : item->tat) + item->interval;

		return (1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd060
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
jb 0x5b6b
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movl 0xc(%rdx), %edx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x5b6b
movl $0x0, -0x4(%rbp)
jmp 0x5ba9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x5b82
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x5b8d
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/logging.c
// Function: logging_sa_to_str
int
logging_sa_to_str(const struct sockaddr *sa, char *dst, int max_l)
{
	int ipv;
	char buf[INET6_ADDRSTRLEN];

	if (af_sa_to_str(sa, buf) == NULL) {
		return (0);
	}

	switch (sa->sa_family) {
	case PF_INET:
		ipv = 4;
		break;
	case PF_INET6:
		ipv = 6;
		break;
	default:
		return (0);
	}

	return (snprintf(dst, max_l, "ipv%d, addr: %s", ipv, buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3360
cmpq $0x0, %rax
jne 0x5c3f
movl $0x0, -0x4(%rbp)
jmp 0x5c95
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x54(%rbp)
subl $0x2, %eax
je 0x5c5a
jmp 0x5c50
movl -0x54(%rbp), %eax
subl $0xa, %eax
je 0x5c63
jmp 0x5c6c
movl $0x4, -0x20(%rbp)
jmp 0x5c75
movl $0x6, -0x20(%rbp)
jmp 0x5c75
movl $0x0, -0x4(%rbp)
jmp 0x5c95
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movl -0x20(%rbp), %ecx
leaq -0x50(%rbp), %r8
leaq 0x90c6(%rip), %rdx      # 0xed51
movb $0x0, %al
callq 0x2110
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/logging.c
// Function: logging_hexdump
int
logging_hexdump(const char *file_name, int line, int log_level, const char *prefix_str,
    const void *data, size_t data_len)
{
	size_t i;
	int res;
	uint8_t u8;

	res = 0;

	if (logging_get_verbose() >= log_level) {
		if (logging_get_verbose() >= LOGGING_LEVEL_DEBUG) {
			res += fprintf(stderr, "%s:%d ", file_name, line);
		}

		if (prefix_str != NULL) {
			res += fprintf(stderr, "%s", prefix_str);
		}

		for (i = 0; i < data_len; i++)	{
			u8 = ((const unsigned char *)data)[i];

			res += fprintf(stderr, "%02"PRIX8, u8);
		}
		res += fprintf(stderr, "\n");
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
callq 0x5ca0
cmpl -0x10(%rbp), %eax
jl 0x5da9
callq 0x5ca0
cmpl $0x2, %eax
jl 0x5d12
movq 0xd304(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x9045(%rip), %rsi      # 0xed4a
movb $0x0, %al
callq 0x21c0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5d3b
movq 0xd2d8(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x89f4(%rip), %rsi      # 0xe722
movb $0x0, %al
callq 0x21c0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x5d8b
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x35(%rbp)
movq 0xd296(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movzbl -0x35(%rbp), %edx
leaq 0x8dc3(%rip), %rsi      # 0xeb33
movb $0x0, %al
callq 0x21c0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5d43
movq 0xd266(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x8f7a(%rip), %rsi      # 0xed16
movb $0x0, %al
callq 0x21c0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/logging.c
// Function: logging_printf
int
logging_printf(const char *file_name, int line, int log_level, const char *format, ...)
{
	va_list ap;
	int res;

	res = 0;

	if (logging_verbose >= log_level) {
		va_start(ap, format);
		if (logging_verbose >= LOGGING_LEVEL_DEBUG) {
			res += fprintf(stderr, "%s:%d ", file_name, line);
		}
		res += vfprintf(stderr, format, ap);
		res += fprintf(stderr, "\n");
		va_end(ap);
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5dfb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movl 0xd3a8(%rip), %eax      # 0x131cc
cmpl -0x10(%rbp), %eax
jl 0x5ebe
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
cmpl $0x2, 0xd374(%rip)      # 0x131cc
jl 0x5e7f
movq 0xd197(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x8ed8(%rip), %rsi      # 0xed4a
movb $0x0, %al
callq 0x21c0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq 0xd172(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x22d0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq 0xd155(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x8e69(%rip), %rsi      # 0xed16
movb $0x0, %al
callq 0x21c0
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msg.c
// Function: msg_answer_create
size_t
msg_answer_create(const char *orig_msg, size_t orig_msg_len, char *new_msg, size_t new_msg_len,
    uint8_t ttl, int server_tstamp)
{
	struct tlv_iterator tlv_iter;
	enum tlv_opt_type opt_type;
	size_t pos;

	pos = 0;

	new_msg[pos++] = (unsigned char)MSG_TYPE_ANSWER;

	memset(&tlv_iter, 0, sizeof(tlv_iter));
	tlv_iter_init(orig_msg, orig_msg_len, &tlv_iter);

	while (tlv_iter_next(&tlv_iter) != -1) {
		opt_type = tlv_iter_get_type(&tlv_iter);
		if (opt_type != TLV_OPT_TYPE_SERVER_INFO &&
		    opt_type != TLV_OPT_TYPE_MCAST_PREFIX &&
		    opt_type != TLV_OPT_TYPE_SES_ID &&
		    opt_type != TLV_OPT_TYPE_TTL &&
		    opt_type != TLV_OPT_TYPE_SERVER_TSTAMP) {
			tlv_iter_item_copy(&tlv_iter, new_msg, new_msg_len, &pos);
		}
	}

	if (tlv_add_ttl(new_msg, new_msg_len, &pos, ttl) == -1)
		goto small_buf_err;

	if (server_tstamp) {
		if (tlv_add_server_tstamp(new_msg, new_msg_len, &pos) == -1)
			goto small_buf_err;
	}

	return (pos);

small_buf_err:
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movl %r9d, -0x30(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb $0x41, (%rax,%rcx)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2150
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xc220
leaq -0x48(%rbp), %rdi
callq 0xc350
cmpl $-0x1, %eax
je 0x5fa1
leaq -0x48(%rbp), %rdi
callq 0xc1e0
movl %eax, -0x4c(%rbp)
cmpl $0x6, -0x4c(%rbp)
je 0x5f9f
cmpl $0xa, -0x4c(%rbp)
je 0x5f9f
cmpl $0xb, -0x4c(%rbp)
je 0x5f9f
cmpl $0x9, -0x4c(%rbp)
je 0x5f9f
cmpl $0xc, -0x4c(%rbp)
je 0x5f9f
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rcx
callq 0xc260
jmp 0x5f52
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movzbl -0x29(%rbp), %ecx
callq 0xc0b0
cmpl $-0x1, %eax
jne 0x5fbd
jmp 0x5fe7
cmpl $0x0, -0x30(%rbp)
je 0x5fdd
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0xc080
cmpl $-0x1, %eax
jne 0x5fdb
jmp 0x5fe7
jmp 0x5fdd
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5fef
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msg.c
// Function: msg_has_prefix
int
msg_has_prefix(const char *msg, size_t msg_len, const struct sockaddr_storage *mcast_addr)
{
	struct tlv_iterator tlv_iter;
	int has_prefix;

	has_prefix = 0;

	tlv_iter_init(msg, msg_len, &tlv_iter);
	while (tlv_iter_next(&tlv_iter) == 0) {
		if (tlv_iter_get_type(&tlv_iter) == TLV_OPT_TYPE_MCAST_PREFIX) {
			if (tlv_iter_pref_eq(&tlv_iter, mcast_addr)) {
				has_prefix = 1;

				break;
			}
		}
	}

	return (has_prefix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc220
leaq -0x30(%rbp), %rdi
callq 0xc350
cmpl $0x0, %eax
jne 0x6ae7
leaq -0x30(%rbp), %rdi
callq 0xc1e0
cmpl $0xa, %eax
jne 0x6ae5
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xc3e0
cmpl $0x0, %eax
je 0x6ae3
movl $0x1, -0x34(%rbp)
jmp 0x6ae7
jmp 0x6ae5
jmp 0x6aac
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msg.c
// Function: msg_init_create
size_t
msg_init_create(char *msg, size_t msg_len, int req_si, const struct sockaddr_storage *mcast_addr,
    const char *client_id, size_t client_id_len)
{
	size_t pos;
	uint16_t u16;

	pos = 0;

	if (client_id == NULL) {
		return (0);
	}

	msg[pos++] = (unsigned char)MSG_TYPE_INIT;

	if (tlv_add_version(msg, msg_len, &pos) == -1)
		goto small_buf_err;

	if (tlv_add(msg, msg_len, &pos, TLV_OPT_TYPE_CLIENT_ID, client_id_len, client_id) == -1)
		goto small_buf_err;


	if (req_si) {
		u16 = TLV_OPT_TYPE_SERVER_INFO;

		if (tlv_add_opt_request(msg, msg_len, &pos, &u16, 1) == -1)
			goto small_buf_err;
	}


	if (tlv_add_mcast_prefix(msg, msg_len, &pos, mcast_addr) == -1)
		goto small_buf_err;

	return (pos);

small_buf_err:
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6b2b
movq $0x0, -0x8(%rbp)
jmp 0x6be1
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movb $0x49, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xc140
cmpl $-0x1, %eax
jne 0x6b5a
jmp 0x6bd9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %r9
leaq -0x40(%rbp), %rdx
movl $0x1, %ecx
movzwl %ax, %r8d
callq 0xbb20
cmpl $-0x1, %eax
jne 0x6b83
jmp 0x6bd9
cmpl $0x0, -0x1c(%rbp)
je 0x6bb3
movw $0x6, -0x42(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x42(%rbp), %rcx
movl $0x1, %r8d
callq 0xbee0
cmpl $-0x1, %eax
jne 0x6bb1
jmp 0x6bd9
jmp 0x6bb3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq -0x40(%rbp), %rdx
callq 0xbea0
cmpl $-0x1, %eax
jne 0x6bcf
jmp 0x6bd9
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6be1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msg.c
// Function: msg_query_create
size_t
msg_query_create(char *msg, size_t msg_len, const struct sockaddr_storage *mcast_addr,
    uint32_t seq_num, int server_tstamp, const char *client_id, size_t client_id_len,
    const char *session_id, size_t session_id_len)
{
	size_t pos;
	uint16_t u16;

	pos = 0;

	msg[pos++] = (unsigned char)MSG_TYPE_QUERY;

	if (tlv_add_version(msg, msg_len, &pos) == -1)
		goto small_buf_err;

	if (client_id) {
		if (tlv_add(msg, msg_len, &pos, TLV_OPT_TYPE_CLIENT_ID, client_id_len,
		    client_id) == -1) {
			goto small_buf_err;
		}
	}

	if (tlv_add_seq_num(msg, msg_len, &pos, seq_num) == -1)
		goto small_buf_err;

	if (tlv_add_client_tstamp(msg, msg_len, &pos) == -1)
		goto small_buf_err;

	if (tlv_add_mcast_grp(msg, msg_len, &pos, mcast_addr) == -1)
		goto small_buf_err;

	if (server_tstamp) {
		u16 = TLV_OPT_TYPE_SERVER_TSTAMP;

		if (tlv_add_opt_request(msg, msg_len, &pos, &u16, 1) == -1)
			goto small_buf_err;
	}

	if (tlv_add(msg, msg_len, &pos, TLV_OPT_TYPE_SES_ID, session_id_len, session_id) == -1)
		goto small_buf_err;

	return (pos);

small_buf_err:
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb $0x51, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xc140
cmpl $-0x1, %eax
jne 0x6c55
jmp 0x6d3f
cmpq $0x0, -0x30(%rbp)
je 0x6c8a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x10(%rbp), %rax
movq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rdx
movl $0x1, %ecx
movzwl %ax, %r8d
callq 0xbb20
cmpl $-0x1, %eax
jne 0x6c88
jmp 0x6d3f
jmp 0x6c8a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %ecx
leaq -0x38(%rbp), %rdx
callq 0xbfb0
cmpl $-0x1, %eax
jne 0x6ca8
jmp 0x6d3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xbc60
cmpl $-0x1, %eax
jne 0x6cc0
jmp 0x6d3f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rdx
callq 0xbcf0
cmpl $-0x1, %eax
jne 0x6cdc
jmp 0x6d3f
cmpl $0x0, -0x28(%rbp)
je 0x6d0c
movw $0xc, -0x3a(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x3a(%rbp), %rcx
movl $0x1, %r8d
callq 0xbee0
cmpl $-0x1, %eax
jne 0x6d0a
jmp 0x6d3f
jmp 0x6d0c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %r9
leaq -0x38(%rbp), %rdx
movl $0xb, %ecx
movzwl %ax, %r8d
callq 0xbb20
cmpl $-0x1, %eax
jne 0x6d35
jmp 0x6d3f
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d47
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/msg.c
// Function: msg_update_server_tstamp
int
msg_update_server_tstamp(char *msg, size_t msg_len)
{
	struct tlv_iterator tlv_iter;
	size_t pos;

	memset(&tlv_iter, 0, sizeof(tlv_iter));
	tlv_iter_init(msg, msg_len, &tlv_iter);

	while (tlv_iter_next(&tlv_iter) != -1) {
		if (tlv_iter_get_type(&tlv_iter) == TLV_OPT_TYPE_SERVER_TSTAMP) {
			pos = tlv_iter.pos;

			if (tlv_add_server_tstamp(msg, msg_len, &pos) == -1)
				goto add_tstamp_err;
		}
	}

	return (0);

add_tstamp_err:
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2150
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0xc220
leaq -0x30(%rbp), %rdi
callq 0xc350
cmpl $-0x1, %eax
je 0x6f71
leaq -0x30(%rbp), %rdi
callq 0xc1e0
cmpl $0xc, %eax
jne 0x6f6f
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xc080
cmpl $-0x1, %eax
jne 0x6f6d
jmp 0x6f7a
jmp 0x6f6f
jmp 0x6f31
movl $0x0, -0x4(%rbp)
jmp 0x6f81
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msgsend.c
// Function: ms_init
int
ms_init(int ucast_socket, const struct sockaddr_storage *remote_addr,
    const struct sockaddr_storage *mcast_addr, const char *client_id, int req_si)
{
	char addr_str[INET6_ADDRSTRLEN];
	char msg[MAX_MSG_SIZE];
	size_t msg_len;
	ssize_t sent;

	af_sa_to_str(AF_CAST_SA(remote_addr), addr_str);
	DEBUG_PRINTF("Sending init msg to %s", addr_str);

	msg_len = msg_init_create(msg, sizeof(msg), req_si, mcast_addr, client_id, CLIENTID_LEN);

	if (msg_len == 0) {
		return (-4);
	}

	sent = rs_sendto(ucast_socket, msg, msg_len, remote_addr);

	return (sent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10070, %rsp          # imm = 0x10070
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3360
leaq -0x60(%rbp), %r8
leaq 0x7cf6(%rip), %rdi      # 0xee7c
movl $0x71, %esi
movl $0x2, %edx
leaq 0x7d33(%rip), %rcx      # 0xeeca
movb $0x0, %al
callq 0x5dc0
leaq -0x10060(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0xffff, %esi           # imm = 0xFFFF
movl $0x18, %r9d
callq 0x6af0
movq %rax, -0x10068(%rbp)
cmpq $0x0, -0x10068(%rbp)
jne 0x71da
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x7205
movl -0x8(%rbp), %edi
leaq -0x10060(%rbp), %rsi
movq -0x10068(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xa430
movq %rax, -0x10070(%rbp)
movq -0x10070(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10070, %rsp          # imm = 0x10070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msgsend.c
// Function: ms_query
int
ms_query(int ucast_socket, const struct sockaddr_storage *remote_addr,
    const struct sockaddr_storage *mcast_addr, uint32_t seq_num, const char *client_id,
    const char *ses_id, size_t ses_id_len)
{
	char addr_str[INET6_ADDRSTRLEN];
	char msg[MAX_MSG_SIZE];
	size_t msg_len;
	ssize_t sent;

	af_sa_to_str(AF_CAST_SA(remote_addr), addr_str);
	DEBUG_PRINTF("Sending query msg to %s", addr_str);

	msg_len = msg_query_create(msg, sizeof(msg), mcast_addr, seq_num, 0, client_id,
	    CLIENTID_LEN, ses_id, SESSIONID_LEN);

	if (msg_len == 0) {
		return (-4);
	}

	sent = rs_sendto(ucast_socket, msg, msg_len, remote_addr);

	return (sent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10090, %rsp          # imm = 0x10090
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3360
leaq -0x60(%rbp), %r8
leaq 0x7c1f(%rip), %rdi      # 0xee7c
movl $0x91, %esi
movl $0x2, %edx
leaq 0x7c73(%rip), %rcx      # 0xeee1
movb $0x0, %al
callq 0x5dc0
leaq -0x10060(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
movl $0xffff, %esi           # imm = 0xFFFF
xorl %r8d, %r8d
movq $0x18, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x10, 0x10(%rsp)
callq 0x6bf0
movq %rax, -0x10068(%rbp)
cmpq $0x0, -0x10068(%rbp)
jne 0x72c8
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x72f3
movl -0x8(%rbp), %edi
leaq -0x10060(%rbp), %rsi
movq -0x10068(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0xa430
movq %rax, -0x10070(%rbp)
movq -0x10070(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10090, %rsp          # imm = 0x10090
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/msgsend.c
// Function: ms_response
int
ms_response(int ucast_socket, const struct sockaddr_storage *mcast_addr,
    const struct msg_decoded *decoded, const struct sockaddr_storage *to, int mcast_grp,
    int mcast_prefix, const char *session_id, size_t session_id_len)
{
	char addr_str[INET6_ADDRSTRLEN];
	char msg[MAX_MSG_SIZE];
	size_t msg_len;
	ssize_t sent;

	af_sa_to_str((struct sockaddr *)to, addr_str);
	DEBUG_PRINTF("Sending response msg to %s", addr_str);

	msg_len = msg_response_create(msg, sizeof(msg), decoded, mcast_grp, mcast_prefix,
	    mcast_addr, session_id, session_id_len);

	if (msg_len == 0) {
		return (-4);
	}

	sent = rs_sendto(ucast_socket, msg, msg_len, to);

	return (sent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10080, %rsp          # imm = 0x10080
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3360
leaq -0x60(%rbp), %r8
leaq 0x7b3a(%rip), %rdi      # 0xee7c
movl $0xb2, %esi
movl $0x2, %edx
leaq 0x7ba6(%rip), %rcx      # 0xeef9
movb $0x0, %al
callq 0x5dc0
leaq -0x10060(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movq -0x10(%rbp), %r9
movq 0x10(%rbp), %r10
movq 0x18(%rbp), %rax
movl $0xffff, %esi           # imm = 0xFFFF
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x6d60
movq %rax, -0x10068(%rbp)
cmpq $0x0, -0x10068(%rbp)
jne 0x73a5
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x73d0
movl -0x8(%rbp), %edi
leaq -0x10060(%rbp), %rsi
movq -0x10068(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xa430
movq %rax, -0x10070(%rbp)
movq -0x10070(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10080, %rsp          # imm = 0x10080
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/omping.c
// Function: main
int
main(int argc, char *argv[])
{
	struct omping_instance instance;
	int allow_auto_exit;
	int final_stats;
	int wait_for_finish_time;

	omping_instance_create(&instance, argc, argv);

	clisig_register_handlers();

	if (instance.op_mode == OMPING_OP_MODE_SERVER) {
		final_stats = allow_auto_exit = 0;
	} else {
		final_stats = allow_auto_exit = 1;
	}

	omping_send_receive_loop(&instance, instance.timeout_time, final_stats, allow_auto_exit);

	if (!instance.single_addr && instance.wait_for_finish_time != 0 &&
	    instance.op_mode != OMPING_OP_MODE_CLIENT) {
		clistate_cancel_exit();

		DEBUG_PRINTF("Moving all clients to stop state and server to finishing state");
		rh_list_put_to_finish_state(&instance.remote_hosts, RH_LFS_BOTH);

		if (instance.wait_for_finish_time == -1) {
			wait_for_finish_time = 0;
		} else {
			wait_for_finish_time = instance.wait_for_finish_time;
		}

		VERBOSE_PRINTF("Waiting for %d ms to inform other nodes about instance exit",
		    instance.wait_for_finish_time);

		omping_send_receive_loop(&instance, wait_for_finish_time, 0, 0);
	}

	omping_instance_free(&instance);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x1c0(%rbp), %rdi
callq 0x7580
callq 0x5940
cmpl $0x2, -0x70(%rbp)
jne 0x747d
movl $0x0, -0x1c4(%rbp)
movl $0x0, -0x1c8(%rbp)
jmp 0x7491
movl $0x1, -0x1c4(%rbp)
movl $0x1, -0x1c8(%rbp)
movl -0x2c(%rbp), %esi
movl -0x1c8(%rbp), %edx
movl -0x1c4(%rbp), %ecx
leaq -0x1c0(%rbp), %rdi
callq 0x78f0
cmpl $0x0, -0x34(%rbp)
jne 0x755a
cmpl $0x0, -0x24(%rbp)
je 0x755a
cmpl $0x1, -0x70(%rbp)
je 0x755a
callq 0x5a00
leaq 0x7aca(%rip), %rdi      # 0xefa0
movl $0x79, %esi
movl $0x2, %edx
leaq 0x7ac2(%rip), %rcx      # 0xefa9
movb $0x0, %al
callq 0x5dc0
leaq -0x1c0(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movl $0x2, %esi
callq 0x9d80
cmpl $-0x1, -0x24(%rbp)
jne 0x7518
movl $0x0, -0x1cc(%rbp)
jmp 0x7521
movl -0x24(%rbp), %eax
movl %eax, -0x1cc(%rbp)
movl -0x24(%rbp), %r8d
leaq 0x7a74(%rip), %rdi      # 0xefa0
movl $0x83, %esi
movl $0x1, %edx
leaq 0x7aab(%rip), %rcx      # 0xefe8
movb $0x0, %al
callq 0x5dc0
movl -0x1cc(%rbp), %esi
leaq -0x1c0(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x78f0
leaq -0x1c0(%rbp), %rdi
callq 0x7af0
xorl %eax, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/omping.c
// Function: omping_instance_free
static void
omping_instance_free(struct omping_instance *instance)
{
	aii_list_free(&instance->remote_addrs);
	rh_list_free(&instance->remote_hosts);

	free(instance->local_addr.host_name);
	free(instance->mcast_addr.host_name);
	free(instance->local_ifname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x3410
movq -0x8(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x9bb0
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)