LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_iter_item_copy
int
tlv_iter_item_copy(const struct tlv_iterator *tlv_iter, char *new_msg, size_t new_msg_len,
    size_t *pos)
{
	size_t item_size;

	DEBUG2_PRINTF("Copy option %"PRIu16" with len %"PRIu16" pos %zu",
	    tlv_iter_get_type(tlv_iter), tlv_iter_get_len(tlv_iter), *pos);

	item_size = tlv_iter_get_len(tlv_iter) + 2 * sizeof(uint16_t);

	if (*pos + item_size > new_msg_len) {
		DEBUG2_PRINTF("Can't copy option. new_msg_len too small.");

		return (-1);
	}

	memcpy(new_msg + *pos, tlv_iter->msg + tlv_iter->pos, item_size);

	*pos += item_size;

	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)
movq -0x10(%rbp), %rdi
callq 0xc1e0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1a0
movl -0x34(%rbp), %r8d
movzwl %ax, %r9d
movq -0x28(%rbp), %rax
movq (%rax), %rax
leaq 0x39d5(%rip), %rdi      # 0xfc78
movl $0x160, %esi            # imm = 0x160
movl $0x3, %edx
leaq 0x3a13(%rip), %rcx      # 0xfcc7
movq %rax, (%rsp)
movb $0x0, %al
callq 0x5dc0
movq -0x10(%rbp), %rdi
callq 0xc1a0
movzwl %ax, %eax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xc30c
leaq 0x398d(%rip), %rdi      # 0xfc78
movl $0x165, %esi            # imm = 0x165
movl $0x3, %edx
leaq 0x39ee(%rip), %rcx      # 0xfcea
movb $0x0, %al
callq 0x5dc0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc344
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
addq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x2200
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_iter_next
int
tlv_iter_next(struct tlv_iterator *tlv_iter)
{
	uint16_t nlen;

	if (tlv_iter->pos == 0) {
		tlv_iter->pos = 1;
		return (0);
	}

	nlen = tlv_iter_get_len(tlv_iter);

	if (tlv_iter->pos + sizeof(uint16_t) + sizeof(nlen) + nlen >= tlv_iter->msg_len) {
		return (-1);
	}

	tlv_iter->pos += sizeof(uint16_t) + sizeof(nlen) + nlen;

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc37c
movq -0x10(%rbp), %rax
movq $0x1, 0x10(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xc3d0
movq -0x10(%rbp), %rdi
callq 0xc1a0
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x2, %rax
addq $0x2, %rax
movzwl -0x12(%rbp), %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xc3b3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc3d0
movzwl -0x12(%rbp), %eax
movl %eax, %ecx
addq $0x4, %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
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/tlv.c
// Function: tlv_iter_pref_eq
int
tlv_iter_pref_eq(const struct tlv_iterator *tlv_iter, const struct sockaddr_storage *sas)
{
	uint16_t tlv_len;
	uint16_t u16;
	uint8_t pref_len;
	uint8_t min_len;

	if (tlv_iter_get_type(tlv_iter) != TLV_OPT_TYPE_MCAST_PREFIX) {
		return (0);
	}

	tlv_len = tlv_iter_get_len(tlv_iter);

	if (tlv_len <= 2) {
		return (0);
	}

	memcpy(&u16, tlv_iter_get_data(tlv_iter), sizeof(u16));
	u16 = ntohs(u16);

	if (u16 != AF_IANA_IP  && u16 != AF_IANA_IP6) {
		return (0);
	}

	memcpy(&pref_len, tlv_iter_get_data(tlv_iter) + 2, sizeof(pref_len));

	min_len = pref_len / 8;
	if (pref_len % 8 != 0)
		min_len++;

	if (tlv_len - 3 < min_len) {
		return (0);
	}

	return (tlv_pref_eq(sas, u16, pref_len, tlv_iter_get_data(tlv_iter) + 3));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1e0
cmpl $0xa, %eax
je 0xc40a
movl $0x0, -0x4(%rbp)
jmp 0xc4f5
movq -0x10(%rbp), %rdi
callq 0xc1a0
movw %ax, -0x1a(%rbp)
movzwl -0x1a(%rbp), %eax
cmpl $0x2, %eax
jg 0xc42c
movl $0x0, -0x4(%rbp)
jmp 0xc4f5
movq -0x10(%rbp), %rdi
callq 0xc180
movw (%rax), %ax
movw %ax, -0x1c(%rbp)
movzwl -0x1c(%rbp), %edi
callq 0x2280
movw %ax, -0x1c(%rbp)
movzwl -0x1c(%rbp), %eax
cmpl $0x1, %eax
je 0xc467
movzwl -0x1c(%rbp), %eax
cmpl $0x2, %eax
je 0xc467
movl $0x0, -0x4(%rbp)
jmp 0xc4f5
movq -0x10(%rbp), %rdi
callq 0xc180
movb 0x2(%rax), %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movb %al, -0x1e(%rbp)
movzbl -0x1d(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc49e
movb -0x1e(%rbp), %al
addb $0x1, %al
movb %al, -0x1e(%rbp)
movzwl -0x1a(%rbp), %eax
subl $0x3, %eax
movzbl -0x1e(%rbp), %ecx
cmpl %ecx, %eax
jge 0xc4b6
movl $0x0, -0x4(%rbp)
jmp 0xc4f5
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movw -0x1c(%rbp), %ax
movw %ax, -0x22(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x1f(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc180
movq -0x30(%rbp), %rdi
movw -0x22(%rbp), %dx
movq %rax, %rcx
movb -0x1f(%rbp), %al
addq $0x3, %rcx
movzwl %dx, %esi
movzbl %al, %edx
callq 0xc500
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_mcast_grp_eq
int
tlv_mcast_grp_eq(const struct sockaddr_storage *sas, const char *mcast_grp, size_t mcast_grp_len)
{
	uint16_t u16;

	memcpy(&u16, mcast_grp, sizeof(u16));
	u16 = ntohs(u16);

	if (!((u16 == AF_IANA_IP && mcast_grp_len == 6) ||
	    (u16 == AF_IANA_IP6 && mcast_grp_len == 18))) {
		return (0);
	}

	if (u16 == AF_IANA_IP && sas->ss_family != AF_INET) {
		return (0);
	}

	if (u16 == AF_IANA_IP6 && sas->ss_family != AF_INET6) {
		return (0);
	}

	return (tlv_pref_eq(sas, u16, (mcast_grp_len - 2) * 8, mcast_grp + 2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %edi
callq 0x2280
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
cmpl $0x1, %eax
jne 0xc77c
cmpq $0x6, -0x20(%rbp)
je 0xc795
movzwl -0x22(%rbp), %eax
cmpl $0x2, %eax
jne 0xc78c
cmpq $0x12, -0x20(%rbp)
je 0xc795
movl $0x0, -0x4(%rbp)
jmp 0xc7fb
movzwl -0x22(%rbp), %eax
cmpl $0x1, %eax
jne 0xc7b3
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
je 0xc7b3
movl $0x0, -0x4(%rbp)
jmp 0xc7fb
movzwl -0x22(%rbp), %eax
cmpl $0x2, %eax
jne 0xc7d1
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xa, %eax
je 0xc7d1
movl $0x0, -0x4(%rbp)
jmp 0xc7fb
movq -0x10(%rbp), %rdi
movw -0x22(%rbp), %dx
movq -0x20(%rbp), %rax
subq $0x2, %rax
shlq $0x3, %rax
movq -0x18(%rbp), %rcx
addq $0x2, %rcx
movzwl %dx, %esi
movzbl %al, %edx
callq 0xc500
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/tlv.c
// Function: tlv_opt_type_to_str
const char *
tlv_opt_type_to_str(enum tlv_opt_type opt)
{
	const char *res;

	switch (opt) {
	case TLV_OPT_TYPE_VERSION: res = "Version"; break;
	case TLV_OPT_TYPE_CLIENT_ID: res = "Client ID"; break;
	case TLV_OPT_TYPE_SEQ_NUM: res = "Sequence Number"; break;
	case TLV_OPT_TYPE_CLIENT_TSTAMP: res = "Client Timestamp"; break;
	case TLV_OPT_TYPE_MCAST_GRP: res = "Multicast Group"; break;
	case TLV_OPT_TYPE_OPT_REQUEST: res = "Option Request Option"; break;
	case TLV_OPT_TYPE_SERVER_INFO: res = "Server Information"; break;
	case TLV_OPT_TYPE_TTL: res = "TTL"; break;
	case TLV_OPT_TYPE_MCAST_PREFIX: res = "Multicast Prefix"; break;
	case TLV_OPT_TYPE_SES_ID: res = "Session ID"; break;
	case TLV_OPT_TYPE_SERVER_TSTAMP: res = "Server Timestamp"; break;
	default: res = "Unknown"; break;
	}

	return (res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xc, %rax
ja 0xc8d1
movq -0x18(%rbp), %rax
leaq 0x3411(%rip), %rcx      # 0xfc44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x34d1(%rip), %rax      # 0xfd14
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34c9(%rip), %rax      # 0xfd1c
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34c3(%rip), %rax      # 0xfd26
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34c6(%rip), %rax      # 0xfd36
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34ca(%rip), %rax      # 0xfd47
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34cd(%rip), %rax      # 0xfd57
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34d6(%rip), %rax      # 0xfd6d
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34dc(%rip), %rax      # 0xfd80
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34d3(%rip), %rax      # 0xfd84
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34d7(%rip), %rax      # 0xfd95
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34d5(%rip), %rax      # 0xfda0
movq %rax, -0x10(%rbp)
jmp 0xc8dc
leaq 0x34d9(%rip), %rax      # 0xfdb1
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/tlv.c
// Function: tlv_add_ts
static int
tlv_add_ts(char *msg, size_t msg_len, size_t *pos, enum tlv_opt_type opt, struct timeval *tv)
{
	char value[8];
	uint32_t u32;

	u32 = tv->tv_sec;
	u32 = htonl(u32);
	memcpy(value, &u32, sizeof(u32));

	u32 = tv->tv_usec;
	u32 = htonl(u32);
	memcpy(value + sizeof(u32), &u32, sizeof(u32));

	return (tlv_add(msg, msg_len, pos, opt, sizeof(value), value));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x2140
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x2140
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq -0x30(%rbp), %r9
movl $0x8, %r8d
callq 0xbb20
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_gen_id
static void
util_gen_id(char *id, size_t len, const struct ai_item *ai_item,
    const struct sockaddr_storage *sas)
{
	pid_t pid;
	size_t pos;

	/*
	 * First fill item with some random data
	 */
	for (pos = 0; pos < len; pos++) {
#if defined(__FreeBSD__) || defined(__OPENBSD__)
		id[pos] = (unsigned char)arc4random_uniform(UCHAR_MAX);
#else
		id[pos] = (unsigned char)random();
#endif
	}

	pos = 0;

	if (pos + sizeof(pid) < len) {
		/*
		 * Add PID
		 */
		pid = getpid();
		memcpy(id, &pid, sizeof(pid));

		pos += sizeof(pid);
	}

	/*
	 * Add sas from ai_item
	 */
	if (ai_item != NULL) {
		util_gen_id_add_sas(id, len, &pos, &ai_item->sas);
	}

	if (sas != NULL) {
		util_gen_id_add_sas(id, len, &pos, sas);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xca6a
callq 0x2230
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xca40
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
cmpq -0x10(%rbp), %rax
jae 0xca9d
callq 0x20b0
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcab9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0xd0d0
cmpq $0x0, -0x20(%rbp)
je 0xcad5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0xd0d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_random_init
void
util_random_init(const struct sockaddr_storage *local_addr)
{
	unsigned int seed;
	unsigned int i;

	seed = time(NULL) + getpid();

	for (i = 0; i < af_sas_len(local_addr); i++) {
		seed += ((uint8_t *)local_addr)[i];
	}

	srandom(seed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2220
movq %rax, -0x18(%rbp)
callq 0x20b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33f0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jae 0xcbc8
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcb94
movl -0xc(%rbp), %edi
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_time_absdiff
uint64_t
util_time_absdiff(struct timeval t1, struct timeval t2)
{
	uint64_t u64t1, u64t2, tmp;

	u64t1 = t1.tv_usec / 1000 + t1.tv_sec * 1000;
	u64t2 = t2.tv_usec / 1000 + t2.tv_sec * 1000;

	if (u64t2 > u64t1) {
		tmp = u64t1;
		u64t1 = u64t2;
		u64t2 = tmp;
	}

	return (u64t1 - u64t2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
imulq $0x3e8, -0x10(%rbp), %rcx # imm = 0x3E8
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
imulq $0x3e8, -0x20(%rbp), %rcx # imm = 0x3E8
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0xcc50
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_time_double_absdiff_us
double
util_time_double_absdiff_us(struct timeval t1, struct timeval t2)
{
	double dt1, dt2, tmp;

	dt1 = t1.tv_usec + t1.tv_sec * UTIL_NSINMS;
	dt2 = t2.tv_usec + t2.tv_sec * UTIL_NSINMS;

	if (dt2 > dt1) {
		tmp = dt1;
		dt1 = dt2;
		dt2 = tmp;
	}

	return (dt1 - dt2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
cvtsi2sdq -0x8(%rbp), %xmm1
cvtsi2sdq -0x10(%rbp), %xmm0
movsd 0x1d50(%rip), %xmm2     # 0xea18
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sdq -0x18(%rbp), %xmm1
cvtsi2sdq -0x20(%rbp), %xmm0
movsd 0x1d2f(%rip), %xmm2     # 0xea18
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0xcd20
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_u64sqrt
uint32_t
util_u64sqrt(uint64_t n)
{
	double x, x2;

	if (n == 0) {
		return (0);
	}

	x = n;

	while (util_fabs((x2 = (x + n / x) / 2) - x) >= 0.5) {
		x = x2;
	}

	return ((uint32_t)x2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xcdef
movl $0x0, -0x4(%rbp)
jmp 0xce8e
movaps 0x2ffa(%rip), %xmm1     # 0xfdf0
movq -0x10(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2ff9(%rip), %xmm1     # 0xfe00
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movaps 0x2fc9(%rip), %xmm2     # 0xfdf0
movq -0x10(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x2fc8(%rip), %xmm2     # 0xfe00
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd -0x18(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd 0x2f80(%rip), %xmm1     # 0xfdd8
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
subsd -0x18(%rbp), %xmm0
callq 0xc970
movsd 0x2f5d(%rip), %xmm1     # 0xfdd0
ucomisd %xmm1, %xmm0
jb 0xce85
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xce1b
cvttsd2si -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_packet_loss_percent
int
util_packet_loss_percent(uint64_t packet_sent, uint64_t packet_received)
{
	int loss;

	if (packet_received > packet_sent) {
		DEBUG_PRINTF("packet_received > packet_sent");
		loss = 0;
	} else {
		loss = (int)((1.0 - (double)packet_received / (double)packet_sent) * 100.0);
	}

	return (loss);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0xcff2
leaq 0x2e3f(%rip), %rdi      # 0xfe10
movl $0x170, %esi            # imm = 0x170
movl $0x2, %edx
leaq 0x2e57(%rip), %rcx      # 0xfe39
movb $0x0, %al
callq 0x5dc0
movl $0x0, -0x14(%rbp)
jmp 0xd054
movq -0x10(%rbp), %xmm1
movaps 0x2df2(%rip), %xmm3     # 0xfdf0
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movapd 0x2df6(%rip), %xmm2     # 0xfe00
subpd %xmm2, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movq -0x8(%rbp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x152b(%rip), %xmm0     # 0xe568
subsd %xmm1, %xmm0
movsd 0x2d97(%rip), %xmm1     # 0xfde0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_u64_absdiff
uint64_t
util_u64_absdiff(uint64_t u1, uint64_t u2)
{
	uint64_t tmpu;

	if (u1 > u2) {
		tmpu = u1;
		u1 = u2;
		u2 = tmpu;
	}

	return (u2 - u1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0xd0be
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jfriesse[P]omping/util.c
// Function: util_gen_id_add_sas
static void
util_gen_id_add_sas(char *id, size_t len, size_t *pos, const struct sockaddr_storage *sas)
{
	void *addr_pointer;
	size_t addr_len;

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

	if (*pos + addr_len < len) {
		memcpy(id + *pos, addr_pointer, addr_len);
		*pos += addr_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
je 0xd103
jmp 0xd0f9
movl -0x34(%rbp), %eax
subl $0xa, %eax
je 0xd119
jmp 0xd12f
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq $0x4, -0x30(%rbp)
jmp 0xd170
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq $0x10, -0x30(%rbp)
jmp 0xd170
movq -0x20(%rbp), %rax
movzwl (%rax), %r8d
leaq 0x2cd2(%rip), %rdi      # 0xfe10
movl $0xc9, %esi
movl $0x2, %edx
leaq 0x2c6a(%rip), %rcx      # 0xfdb9
movb $0x0, %al
callq 0x5dc0
movq -0x20(%rbp), %rax
movzwl (%rax), %edx
movl $0x1, %edi
leaq 0x2c50(%rip), %rsi      # 0xfdb9
movb $0x0, %al
callq 0x20d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xd1a7
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
addq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2200
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/poll2.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	struct rlimit rlim;
	int nr_procs = sysconf(_SC_NPROCESSORS_CONF);
	rlim_t new_lim = (NR_FILES + 10) * nr_procs;

	getrlimit(RLIMIT_NOFILE, &rlim);
	if (rlim.rlim_max < new_lim) {
		rlim.rlim_cur = new_lim;
		rlim.rlim_max = new_lim;
	}
	if (rlim.rlim_cur < new_lim) {
		rlim.rlim_cur = new_lim;
	}
	assert(setrlimit(RLIMIT_NOFILE, &rlim) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x53, %edi
callq 0x2210
movl %eax, -0x1c(%rbp)
imull $0x8a, -0x1c(%rbp), %eax
cltq
movq %rax, -0x28(%rbp)
movl $0x7, %edi
leaq -0x18(%rbp), %rsi
callq 0x22a0
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x302e
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x3040
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x7, %edi
leaq -0x18(%rbp), %rsi
callq 0x21c0
cmpl $0x0, %eax
jne 0x3055
jmp 0x3074
leaq 0x121c(%rip), %rdi      # 0x4278
leaq 0x123a(%rip), %rsi      # 0x429d
movl $0x1d, %edx
leaq 0x123c(%rip), %rcx      # 0x42ab
callq 0x2110
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/poll2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int i;
	char tmpfile[PATH_MAX];
	int tmpfiles[NR_FILES];

	for (i = 0; i < NR_FILES; i++) {
		sprintf(tmpfile, "/tmp/willitscale.XXXXXX");
		tmpfiles[i] = mkstemp(tmpfile);
		assert(tmpfiles[i] >= 0);
		unlink(tmpfile);
	}

	while (1) {
		struct pollfd pfd[NR_FILES];

		memset(&pfd, 0, sizeof(pfd));

		for (i = 0; i < NR_FILES; i++) {
			pfd[i].fd = tmpfiles[i];
			pfd[i].events = POLLOUT;
		}

		assert(poll(pfd, NR_FILES, 0) >= 0);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1620, %rsp           # imm = 0x1620
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0x3117
leaq -0x1020(%rbp), %rdi
leaq 0x121f(%rip), %rsi      # 0x42d0
movb $0x0, %al
callq 0x2280
leaq -0x1020(%rbp), %rdi
callq 0x21b0
movl %eax, %ecx
movslq -0x14(%rbp), %rax
movl %ecx, -0x1220(%rbp,%rax,4)
movslq -0x14(%rbp), %rax
cmpl $0x0, -0x1220(%rbp,%rax,4)
jl 0x30e1
jmp 0x3100
leaq 0x1200(%rip), %rdi      # 0x42e8
leaq 0x11ae(%rip), %rsi      # 0x429d
movl $0x29, %edx
leaq 0x11fe(%rip), %rcx      # 0x42f9
callq 0x2110
leaq -0x1020(%rbp), %rdi
callq 0x2080
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x309a
jmp 0x3119
leaq -0x1620(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2120
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0x316b
movslq -0x14(%rbp), %rax
movl -0x1220(%rbp,%rax,4), %ecx
movslq -0x14(%rbp), %rax
movl %ecx, -0x1620(%rbp,%rax,8)
movslq -0x14(%rbp), %rax
movw $0x4, -0x161c(%rbp,%rax,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3133
leaq -0x1620(%rbp), %rdi
movl $0x80, %esi
xorl %edx, %edx
callq 0x21d0
cmpl $0x0, %eax
jl 0x3185
jmp 0x31a4
leaq 0x11a0(%rip), %rdi      # 0x432c
leaq 0x110a(%rip), %rsi      # 0x429d
movl $0x37, %edx
leaq 0x115a(%rip), %rcx      # 0x42f9
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3119
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: pi32_init
int PI_INIT(
        PI_CTX *ctx,
        const void *key,
        size_t key_length_B,
        const void *pmn,
        size_t pmn_length_B)
{
	int i;
	uint8_t setup_buf[PI_IS_BITS / 8];
    if (key_length_B + pmn_length_B + 1 >= PI_IS_BITS / 8) {
        return -1;
    }
    memset(ctx->tag, 0, sizeof(ctx->tag));
    memset(setup_buf, 0, sizeof(setup_buf));
    memcpy(setup_buf, key, key_length_B);
    memcpy(&setup_buf[key_length_B], pmn, pmn_length_B);
    setup_buf[key_length_B + pmn_length_B] = 1;
    for (i = 0; i < 16; ++i) {
        ctx->cis[i / 4][i % 4] = load_word_little(&setup_buf[i * PI_WORD_SIZE / 8]);
    }
    pi((word_t*)ctx->cis);
    ctx->ctr = 0;
    for (i = 0; i * PI_WORD_SIZE < 64; ++i) {
		ctx->ctr |= (uint64_t)ctx->cis[1][i] << (i * PI_WORD_SIZE);
	}
    return 0;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq 0x78(%rsp), %rax
addq 0x68(%rsp), %rax
addq $0x1, %rax
cmpq $0x40, %rax
jb 0x13ba
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x1528
movq 0x88(%rsp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1030
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1030
leaq 0x20(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x1120
leaq 0x20(%rsp), %rdi
addq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x1120
movq 0x78(%rsp), %rax
addq 0x68(%rsp), %rax
movb $0x1, 0x20(%rsp,%rax)
movl $0x0, 0x64(%rsp)
cmpl $0x10, 0x64(%rsp)
jge 0x14af
movl 0x64(%rsp), %eax
shll $0x5, %eax
movl $0x8, %ecx
cltd
idivl %ecx
cltq
leaq 0x20(%rsp), %rdi
addq %rax, %rdi
callq 0x1540
movl %eax, 0x1c(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x64(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movl 0x64(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movq 0x10(%rsp), %rax
movl %edx, %ecx
movl 0x1c(%rsp), %edx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x142a
movq 0x88(%rsp), %rdi
callq 0x1550
movq 0x88(%rsp), %rax
movq $0x0, 0x60(%rax)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
shll $0x5, %eax
cmpl $0x40, %eax
jge 0x151d
movq 0x88(%rsp), %rax
movslq 0x64(%rsp), %rcx
movl 0x10(%rax,%rcx,4), %eax
movl 0x64(%rsp), %ecx
shll $0x5, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq 0x88(%rsp), %rax
orq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x14d4
movl $0x0, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: pi32_process_ad_last_block
void PI_PROCESS_AD_LAST_BLOCK(
        PI_CTX *ctx,
        const void *ad,
        size_t ad_length_B,
        unsigned long ad_num )
{
    state_t a;
    while (ad_length_B >= PI_AD_BLOCK_LENGTH_BYTES) {
        PI_PROCESS_AD_BLOCK(ctx, ad, ad_num);
        ad_num++;
        ad_length_B -= PI_AD_BLOCK_LENGTH_BYTES;
        ad = &((uint8_t*)ad)[PI_AD_BLOCK_LENGTH_BYTES];
    }

    ctr_trans(ctx, a, ad_num);
    inject_last_block(a, ad, ad_length_B);
    pi((word_t*)a);
    add_tag(ctx, a);
    ctx->ctr += ad_num;
    inject_tag(ctx->cis, ctx->tag);
    pi((word_t*)ctx->cis);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
cmpq $0x20, 0x50(%rsp)
jb 0x1830
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x10d0
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
subq $0x20, %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x58(%rsp)
jmp 0x17e8
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
movq 0x48(%rsp), %rdx
callq 0x1620
movq %rsp, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x18a0
movq %rsp, %rdi
callq 0x1550
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x1760
movq 0x48(%rsp), %rcx
movq 0x60(%rsp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x40, %rsi
callq 0x1900
movq 0x60(%rsp), %rdi
callq 0x1550
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: inject_last_block
static void inject_last_block(
        state_t a,
        const void *block,
        size_t length_B )
{
    uint8_t t[PI_RATE_BYTES];
    if (length_B >= PI_RATE_BYTES) {
        /* error */
    	printf("ERROR <%s %s %d>\n", __FILE__, __func__, __LINE__);
        return;
    }
    memset(t, 0, sizeof(t));
    memcpy(t, block, length_B);
    t[length_B] = 1;
    inject_block(a, t);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x20, 0x20(%rsp)
jb 0x18bd
jmp 0x18f4
movq %rsp, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1030
movq %rsp, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1120
movq 0x20(%rsp), %rax
movb $0x1, (%rsp,%rax)
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x16c0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: pi32_encrypt_last_block
void PI_ENCRYPT_LAST_BLOCK(
        PI_CTX *ctx,
        void *dest,
        const void *src,
        size_t length_B,
        unsigned long num )
{
    state_t a;
    while (length_B >= PI_PT_BLOCK_LENGTH_BYTES) {
        PI_ENCRYPT_BLOCK(ctx, dest, src, num);
        num++;
        length_B -= PI_PT_BLOCK_LENGTH_BYTES;
        src = &((uint8_t*)src)[PI_PT_BLOCK_LENGTH_BYTES];
        if (dest) {
            dest = &((uint8_t*)dest)[PI_CT_BLOCK_LENGTH_BYTES];
        }
    }
    ctr_trans(ctx, a, num);
    inject_last_block(a, src, length_B);
    if (dest) {
        uint8_t tmp[PI_PT_BLOCK_LENGTH_BYTES];
        extract_block(tmp, a);
        memcpy(dest, tmp, length_B);
    }
    pi((word_t*)a);
    add_tag(ctx, a);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
cmpq $0x20, 0x68(%rsp)
jb 0x1cc9
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x60(%rsp), %rcx
callq 0x1060
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
subq $0x20, %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x1cc7
movq 0x78(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x78(%rsp)
jmp 0x1c63
movq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x1620
leaq 0x20(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x18a0
cmpq $0x0, 0x78(%rsp)
je 0x1d1b
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1a00
movq 0x78(%rsp), %rdi
movq %rsp, %rsi
movq 0x68(%rsp), %rdx
callq 0x1120
leaq 0x20(%rsp), %rdi
callq 0x1550
movq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1760
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: replace_last_block
static void replace_last_block(
        state_t a,
        const void *block,
        size_t length_B  )
{
    uint8_t t[PI_RATE_BYTES];
    if (length_B >= PI_RATE_BYTES) {
        /* error */
    	printf("ERROR <%s %s %d>\n", __FILE__, __func__, __LINE__);
        return;
    }
    extract_block(t, a);
    memcpy(t, block, length_B);
    replace_block(a, t);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x20, 0x20(%rsp)
jb 0x1f3d
jmp 0x1f69
movq %rsp, %rdi
movq 0x30(%rsp), %rsi
callq 0x1a00
movq %rsp, %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1120
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x1b30
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: mu
static inline void mu(
        word_t dest[4],
        const word_t x[4])
{
    word_t sum;
    dest[0] = rotl(PI_MU_CONST_0 + x[0] + x[1] + x[2], PI_MU_ROT_CONST_0 );
    dest[1] = rotl(PI_MU_CONST_1 + x[0] + x[1] + x[3], PI_MU_ROT_CONST_1 );
    dest[2] = rotl(PI_MU_CONST_2 + x[0] + x[2] + x[3], PI_MU_ROT_CONST_2 );
    dest[3] = rotl(PI_MU_CONST_3 + x[1] + x[2] + x[3], PI_MU_ROT_CONST_3 );
    sum = dest[0] ^ dest[1] ^ dest[2] ^ dest[3];
    dest[0] ^= sum;
    dest[1] ^= sum;
    dest[2] ^= sum;
    dest[3] ^= sum;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movabsq $0xf0e8e4e2, %rcx       # imm = 0xF0E8E4E2
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0x5, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movabsq $0xe1d8d4d2, %rcx       # imm = 0xE1D8D4D2
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0xb, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movabsq $0xd1cccac9, %rcx       # imm = 0xD1CCCAC9
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0x11, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movabsq $0xc6c5c3b8, %rcx       # imm = 0xC6C5C3B8
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0x17, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
xorl 0x4(%rcx), %eax
movq 0x10(%rsp), %rcx
xorl 0x8(%rcx), %eax
movq 0x10(%rsp), %rcx
xorl 0xc(%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl (%rax), %ecx
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/pi32cipher256v2/ref3/pi-cipher.c
// Function: ny
static inline void ny(
        word_t dest[4],
        const word_t x[4])
{
    word_t sum;
    dest[0] = rotl(PI_NY_CONST_0 + x[0] + x[2] + x[3], PI_NY_ROT_CONST_0 );
    dest[1] = rotl(PI_NY_CONST_1 + x[1] + x[2] + x[3], PI_NY_ROT_CONST_1 );
    dest[2] = rotl(PI_NY_CONST_2 + x[0] + x[1] + x[2], PI_NY_ROT_CONST_2 );
    dest[3] = rotl(PI_NY_CONST_3 + x[0] + x[1] + x[3], PI_NY_ROT_CONST_3 );
    sum = dest[0] ^ dest[1] ^ dest[2] ^ dest[3];
    dest[0] ^= sum;
    dest[1] ^= sum;
    dest[2] ^= sum;
    dest[3] ^= sum;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movabsq $0xb4b2b1ac, %rcx       # imm = 0xB4B2B1AC
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0x3, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movabsq $0xaaa9a6a5, %rcx       # imm = 0xAAA9A6A5
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0xa, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movabsq $0xa39c9a99, %rcx       # imm = 0xA39C9A99
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0x13, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movabsq $0x9695938e, %rcx       # imm = 0x9695938E
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movl %eax, %edi
movl $0x1d, %esi
callq 0x29f0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
xorl 0x4(%rcx), %eax
movq 0x10(%rsp), %rcx
xorl 0x8(%rcx), %eax
movq 0x10(%rsp), %rcx
xorl 0xc(%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl (%rax), %ecx
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
xorl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wcdiff.c
// Function: is_exists
int is_exists(const char *filename)
{
    struct stat st;

    if (stat(filename, &st) != 0) {
        fprintf(stderr, "[-] %s: %s\n", filename, strerror(errno));
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x10f0
cmpl $0x0, %eax
je 0x1304
movq 0x2d3d(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1160
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq 0xd10(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10e0
movl $0x0, -0x4(%rbp)
jmp 0x130b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wcdiff.c
// Function: is_executable
int is_executable(const char *filename)
{
    struct stat st;

    if (stat(filename, &st) != 0) {
        fprintf(stderr, "[-] %s: %s\n", filename, strerror(errno));
        return 0;
    }
    if (!(st.st_mode & S_IXUSR)) {
        fprintf(stderr, "[-] %s: not executable\n", filename);
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x10f0
cmpl $0x0, %eax
je 0x1394
movq 0x2cad(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1160
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq 0xc80(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10e0
movl $0x0, -0x4(%rbp)
jmp 0x13ce
movl -0x88(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x13c7
movq 0x2c4f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xc59(%rip), %rsi       # 0x2010
movb $0x0, %al
callq 0x10e0
movl $0x0, -0x4(%rbp)
jmp 0x13ce
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wcdiff.c
// Function: get_results
struct wcresults
get_results(int fd)
{
    struct wcresults results;

    results.line_count = get_integer(fd);
    results.word_count = get_integer(fd);
    results.char_count = get_integer(fd);

    return results;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x16a0
movq -0x18(%rbp), %rdi
movq %rax, (%rdi)
movl -0x4(%rbp), %edi
callq 0x16a0
movq -0x18(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl -0x4(%rbp), %edi
callq 0x16a0
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wcdiff.c
// Function: get_integer
static long
get_integer(int fd)
{
    int state = 0;
    long result = -1;

    for (;;) {
        char c;
        int count;

        count = read(fd, &c, 1);
        if (count <= 0)
            return -1;

        switch (state) {
        case 0:
            if (c == '\n')
                return -1;
            if (isspace(c))
                continue;
            if (isdigit(c)) {
                result = c - '0';
                state++;
                continue;
            }
            return -1;
        case 1:
            if (isspace(c))
                return result;
            if (!isdigit(c))
                return -1;
            result = result * 10 + (c - '0');
            break;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq $-0x1, -0x18(%rbp)
movl -0xc(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x10c0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jg 0x16e1
movq $-0x1, -0x8(%rbp)
jmp 0x17da
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x16fa
jmp 0x16ed
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1771
jmp 0x17d5
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0x1710
movq $-0x1, -0x8(%rbp)
jmp 0x17da
callq 0x1180
movq (%rax), %rax
movsbl -0x19(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x172f
jmp 0x16ba
callq 0x1180
movq (%rax), %rax
movsbl -0x19(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1767
movsbl -0x19(%rbp), %eax
subl $0x30, %eax
cltq
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x16ba
movq $-0x1, -0x8(%rbp)
jmp 0x17da
callq 0x1180
movq (%rax), %rax
movsbl -0x19(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x1798
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17da
callq 0x1180
movq (%rax), %rax
movsbl -0x19(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x17bf
movq $-0x1, -0x8(%rbp)
jmp 0x17da
imulq $0xa, -0x18(%rbp), %rax
movsbl -0x19(%rbp), %ecx
subl $0x30, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x16ba
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wcdiff.c
// Function: word_count
long
word_count(const char *progname, const char *parms, const unsigned char *buf, size_t length)
{
    struct handles h;
    size_t offset = 0;
    struct wcresults results;


    h = my_spawn(progname, parms);
    if (h.child_stdin <= 0 || h.child_stdout <= 0) {
        fprintf(stderr, "[-] spawn failed\n");
        return -1;
    }

    /* keep writing until we've written the entire chunk */
    while (offset < length) {
        size_t count;
        count = write(h.child_stdin, buf+offset, length-offset);
        if (count == 0) {
            perror("write()");
            exit(1);
        }
        offset += count;
    }

    /* Close the handle, telling the child process that input has ended */
    close(h.child_stdin);

    /* Read the results from the child */
    results = get_results(h.child_stdout);

    close(h.child_stdout);
    close(h.child_stderr);
    cleanup_children();

    return results.word_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13e0
movl %edx, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x64(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x64(%rbp), %rax
movq %rax, -0x34(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x184f
cmpl $0x0, -0x30(%rbp)
jg 0x1874
movq 0x27a2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x803(%rip), %rsi       # 0x2063
movb $0x0, %al
callq 0x10e0
movq $-0x1, -0x8(%rbp)
jmp 0x191c
jmp 0x1876
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x18c7
movl -0x34(%rbp), %edi
movq -0x20(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdx
subq -0x40(%rbp), %rdx
callq 0x1050
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x18b9
leaq 0x7cb(%rip), %rdi       # 0x2075
callq 0x1120
movl $0x1, %edi
callq 0x1150
movq -0x80(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1876
movl -0x34(%rbp), %edi
callq 0x10a0
movl -0x30(%rbp), %esi
leaq -0x98(%rbp), %rdi
callq 0x1650
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x30(%rbp), %edi
callq 0x10a0
movl -0x2c(%rbp), %edi
callq 0x10a0
callq 0x1930
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wcdiff.c
// Function: utf8_len
unsigned
utf8_len(unsigned char c)
{
    if (c < 0x80) {
        return 1;
    } else if ((c&0xE0) == 0xC0) {
        return  2;
    } else if ((c&0xF0) == 0xE0) {
        return 3;
    } else if ((c&0xF1) == 0xF0) {
        return 4;
    } else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x80, %eax
jge 0x19ce
movl $0x1, -0x4(%rbp)
jmp 0x1a20
movzbl -0x5(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x19e7
movl $0x2, -0x4(%rbp)
jmp 0x1a20
movzbl -0x5(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x1a00
movl $0x3, -0x4(%rbp)
jmp 0x1a20
movzbl -0x5(%rbp), %eax
andl $0xf1, %eax
cmpl $0xf0, %eax
jne 0x1a19
movl $0x4, -0x4(%rbp)
jmp 0x1a20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/example.c
// Function: main
int main(int argc, char *argv[])
{
    const char *c = "sqrt(5^2+7^2+11^2+(8-2)^2)";
    double r = te_interp(c, 0);
    printf("The expression:\n\t%s\nevaluates to:\n\t%f\n", c, r);
    return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x2e38(%rip), %rax      # 0x4004
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2780
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
leaq 0x2e28(%rip), %rdi      # 0x401f
movb $0x1, %al
callq 0x1060
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/codeplea[P]tinyexpr/tinyexpr.c
// Function: factor
static te_expr *factor(state *s) {
    /* <factor>    =    <power> {"^" <power>} */
    te_expr *ret = power(s);
    CHECK_NULL(ret);

    while (s->type == TOK_INFIX && (s->function == pow)) {
        te_fun2 t = s->function;
        next_token(s);
        te_expr *p = power(s);
        CHECK_NULL(p, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, p);
        CHECK_NULL(ret, te_free(p), te_free(prev));

        ret->function = t;
    }

    return ret;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3190
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x308e
movq $0x0, 0x40(%rsp)
jmp 0x317f
jmp 0x3090
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpl $0x20, 0x10(%rcx)
movb %al, 0x7(%rsp)
jne 0x30b8
movq 0x38(%rsp), %rax
movq 0x2f23(%rip), %rcx      # 0x5fd0
cmpq %rcx, 0x18(%rax)
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x30c5
jmp 0x3175
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x12f0
movq 0x38(%rsp), %rdi
callq 0x3190
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3109
movq 0x30(%rsp), %rdi
callq 0x12c0
movq $0x0, 0x40(%rsp)
jmp 0x317f
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movl $0x2a, %edi
callq 0x2de0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x3162
movq 0x20(%rsp), %rdi
callq 0x12c0
movq 0x18(%rsp), %rdi
callq 0x12c0
movq $0x0, 0x40(%rsp)
jmp 0x317f
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3090
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)