LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/KeccakP-800-compact.c
// Function: KeccakP800_ExtractAndAddBytes
void KeccakP800_ExtractAndAddBytes(const void *argState, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    tSmallUInt i;
    const unsigned char * state = (const unsigned char*)argState + offset;

    for(i=0; i<length; i++)
        output[i] = input[i] ^ state[i];
}

// Assembly:
testl %r8d, %r8d
je 0x6e58
movl %ecx, %eax
addq %rax, %rdi
movl %r8d, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %r8b
xorb (%rsi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x6e44
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LunarKeyak_Instance instance;

    LunarKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    LunarKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x668, %rsp            # imm = 0x668
movq %r9, (%rsp)
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbp
movq 0x6b0(%rsp), %rsi
movq 0x6a8(%rsp), %rcx
subq $0x8, %rsp
xorl %r15d, %r15d
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
pushq %r15
pushq %r15
pushq $0x0
callq 0x51e0
addq $0x20, %rsp
leaq (%rbx,%rbp), %rax
subq $0x8, %rsp
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq 0x8(%rsp), %r9
pushq %r15
pushq %r15
pushq %rax
callq 0x54b0
addq $0x20, %rsp
addq $0x10, %rbx
movq 0x8(%rsp), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x668, %rsp            # imm = 0x668
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/compact/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LunarKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    LunarKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( LunarKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char*)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x10, %r8
jb 0xda49
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x658, %rsp            # imm = 0x658
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq 0x6a0(%rsp), %rsi
movq 0x698(%rsp), %rcx
subq $0x8, %rsp
xorl %r10d, %r10d
movl $0x1, %eax
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movl $0x10, %edx
movl $0x96, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
pushq $0x0
callq 0x51e0
addq $0x20, %rsp
leaq -0x10(%r12), %rcx
movq %rcx, (%r13)
leaq (%r14,%r12), %rax
addq $-0x10, %rax
subq $0x8, %rsp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
movq 0x698(%rsp), %r9
xorl %r10d, %r10d
pushq %r10
movl $0x1, %ebx
pushq %rbx
pushq %rax
callq 0x54b0
addq $0x20, %rsp
movl %eax, %ecx
xorl %eax, %eax
cmpl %ebx, %ecx
setne %al
negl %eax
addq $0x658, %rsp            # imm = 0x658
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: main
int
main(int argc, char * argv[])
{
	int i;

	if (argc == 2) {
		/* Run the relevant function. */
		for (i = 0; i < num_tests; i++) {
			if ((strcmp(argv[1], tests[i].name)) == 0) {
				tests[i].func();
				goto success;
			}
		}

		/* We didn't find the desired function name. */
		goto err0;
	} else {
		/* Print test names. */
		for (i = 0; i < num_tests; i++)
			printf("%s\n", tests[i].name);
	}

success:
	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x2, %edi
jne 0x135c
movq 0x8(%rsi), %rbx
movl $0x8, %r14d
leaq 0x2a29(%rip), %r15      # 0x3d60
movq -0x8(%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x10b0
testl %eax, %eax
je 0x137a
addq $0x10, %r14
cmpq $0x78, %r14
jne 0x1337
movl $0x1, %edi
callq 0x1050
xorl %ebx, %ebx
leaq 0x29fb(%rip), %r14      # 0x3d60
movq (%rbx,%r14), %rdi
callq 0x1040
addq $0x10, %rbx
cmpq $0x70, %rbx
jne 0x1365
jmp 0x1380
movq (%r14,%r15), %rax
callq *%rax
xorl %edi, %edi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_strlen
static void
pl_freebsd_strlen(void)
{
	/* More than 8 bytes, and not a multiple of 8. */
	char problem[] = {1, 2, 3, 4, 5, 6, 7, 8, 0};

	/* Play games to avoid the compiler optimizing away strlen(). */
	size_t (* const volatile strlen_func)(const char *) = strlen;
	volatile size_t len = strlen_func(problem);
	(void)len;
}

// Assembly:
subq $0x28, %rsp
movabsq $0x807060504030201, %rax # imm = 0x807060504030201
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
movq 0x2c27(%rip), %rax      # 0x3fd0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_pthread_nothing
static void
pl_freebsd_pthread_nothing(void)
{
	pthread_t thr;
	int rc;

	if ((rc = pthread_create(&thr, NULL, pl_workthread_nothing, NULL)))
		fprintf(stderr, "pthread_create: %s", strerror(rc));
	if ((rc = pthread_join(thr, NULL)))
		fprintf(stderr, "pthread_join: %s", strerror(rc));
}

// Assembly:
pushq %rax
leaq 0xa9(%rip), %rdx        # 0x148b
movq %rsp, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1080
testl %eax, %eax
jne 0x1403
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1030
testl %eax, %eax
jne 0x140c
popq %rax
retq
movl %eax, %edi
callq 0x1110
jmp 0x13f2
movl %eax, %edi
callq 0x1136
jmp 0x1401
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_pthread_strerror_localtime
static void
pl_freebsd_pthread_strerror_localtime(void)
{
	pthread_t thr;
	int rc;

	if ((rc = pthread_create(&thr, NULL,
	    pl_workthread_strerror_localtime, NULL)))
		fprintf(stderr, "pthread_create: %s", strerror(rc));
	if ((rc = pthread_join(thr, NULL)))
		fprintf(stderr, "pthread_join: %s", strerror(rc));
}

// Assembly:
pushq %rax
leaq 0x71(%rip), %rdx        # 0x148e
movq %rsp, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1080
testl %eax, %eax
jne 0x143e
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1030
testl %eax, %eax
jne 0x1447
popq %rax
retq
movl %eax, %edi
callq 0x115c
jmp 0x142d
movl %eax, %edi
callq 0x1182
jmp 0x143c
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_freebsd_pthread_getaddrinfo
static void
pl_freebsd_pthread_getaddrinfo(void)
{
	pthread_t thr;
	int rc;

	if ((rc = pthread_create(&thr, NULL,
	    pl_workthread_getaddrinfo, NULL)))
		fprintf(stderr, "pthread_create: %s", strerror(rc));
	if ((rc = pthread_join(thr, NULL)))
		fprintf(stderr, "pthread_join: %s", strerror(rc));
}

// Assembly:
pushq %rax
leaq 0x65(%rip), %rdx        # 0x14bd
movq %rsp, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x1080
testl %eax, %eax
jne 0x1479
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x1030
testl %eax, %eax
jne 0x1482
popq %rax
retq
movl %eax, %edi
callq 0x11a8
jmp 0x1468
movl %eax, %edi
callq 0x11ce
jmp 0x1477
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]spiped/tests/valgrind/potential-memleaks.c
// Function: pl_workthread_strerror_localtime
static void *
pl_workthread_strerror_localtime(void * cookie)
{
	char * str = strerror(1);
	time_t now;
	struct tm tm;

	(void)cookie; /* UNUSED */
	(void)str; /* UNUSED */

	time(&now);
	localtime_r(&now, &tm);

	return (NULL);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movl $0x1, %edi
callq 0x10a0
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x10f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10c0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: str_quote
const char *str_quote(const char *s)
{
	static char buf[1024];
	int r = snprintf(buf, sizeof(buf), "\"%.*s\"", (int)sizeof(buf) - 4, s);
	if (r >= (int)sizeof(buf)) {
		buf[sizeof(buf) - 1] = 0;
	}
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %r8
leaq 0xe798a(%rip), %rdi     # 0x4ea470
leaq 0xb1782(%rip), %rdx     # 0x4b426f
movl $0x400, %esi            # imm = 0x400
movl $0x3fc, %ecx            # imm = 0x3FC
xorl %eax, %eax
callq 0x40d910
cmpl $0x400, %eax            # imm = 0x400
jl 0x402b0c
movb $0x0, 0xe7d63(%rip)     # 0x4ea86f
leaq 0xe795d(%rip), %rax     # 0x4ea470
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: parse_addr
void parse_addr(struct net_addr *netaddr, const char *addr)
{
	char *colon = strrchr(addr, ':');
	if (colon == NULL) {
		FATAL("You forgot to specify port");
	}
	int port = atoi(colon + 1);
	if (port < 0 || port > 65535) {
		FATAL("Invalid port number %d", port);
	}
	char host[255];
	int addr_len = colon - addr > 254 ? 254 : colon - addr;
	strncpy(host, addr, addr_len);
	host[addr_len] = '\0';
	net_gethostbyname(netaddr, host, port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x3a, %esi
callq 0x401058
testq %rax, %rax
je 0x402bad
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x40bb60
movl %eax, %r15d
cmpl $0x10000, %eax          # imm = 0x10000
jae 0x402bb2
subq %r14, %r12
movl $0xfe, %eax
cmpq %rax, %r12
cmovgeq %rax, %r12
movslq %r12d, %r12
leaq -0x130(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x401088
movb $0x0, -0x130(%rbp,%r12)
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
callq 0x402bba
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40114b
movl %r15d, %edi
callq 0x401100
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_gethostbyname
void net_gethostbyname(struct net_addr *shost, const char *host, int port)
{
	memset(shost, 0, sizeof(struct net_addr));

	struct in_addr in_addr;
	struct in6_addr in6_addr;

	/* Try ipv4 address first */
	if (inet_pton(AF_INET, host, &in_addr) == 1) {
		goto got_ipv4;
	}

	/* Then ipv6 */
	if (inet_pton(AF_INET6, host, &in6_addr) == 1) {
		goto got_ipv6;
	}

	FATAL("inet_pton(%s)", str_quote(host));
	return;

got_ipv4:
	shost->ipver = 4;
	shost->sockaddr = (struct sockaddr *)&shost->sin4;
	shost->sockaddr_len = sizeof(shost->sin4);
	shost->sin4.sin_family = AF_INET;
	shost->sin4.sin_port = htons(port);
	shost->sin4.sin_addr = in_addr;
	return;

got_ipv6:
	shost->ipver = 6;
	shost->sockaddr = (struct sockaddr *)&shost->sin6;
	shost->sockaddr_len = sizeof(shost->sin4);
	shost->sin6.sin6_family = AF_INET6;
	shost->sin6.sin6_port = htons(port);
	shost->sin6.sin6_addr = in6_addr;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq -0x1c(%rbp), %rdx
movl $0x2, %edi
callq 0x460ba0
cmpl $0x1, %eax
jne 0x402c22
movl $0x4, (%rbx)
leaq 0x4(%rbx), %rax
movq %rax, 0x30(%rbx)
movl $0x10, 0x38(%rbx)
rolw $0x8, %r14w
movw $0x2, 0x4(%rbx)
movw %r14w, 0x6(%rbx)
movl -0x1c(%rbp), %eax
movl %eax, 0x8(%rbx)
jmp 0x402c65
leaq -0x2c(%rbp), %rdx
movl $0xa, %edi
movq %r15, %rsi
callq 0x460ba0
cmpl $0x1, %eax
jne 0x402c70
movl $0x6, (%rbx)
leaq 0x14(%rbx), %rax
movq %rax, 0x30(%rbx)
movl $0x10, 0x38(%rbx)
rolw $0x8, %r14w
movw $0xa, 0x14(%rbx)
movw %r14w, 0x16(%rbx)
movups -0x2c(%rbp), %xmm0
movups %xmm0, 0x1c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x401198
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: addr_to_str
const char *addr_to_str(struct net_addr *addr)
{
	char dst[INET6_ADDRSTRLEN + 1];
	int port = 0;

	switch (addr->ipver) {
	case 4: {
		inet_ntop(AF_INET, &addr->sin4.sin_addr, dst, INET6_ADDRSTRLEN);
		port = ntohs(addr->sin4.sin_port);
	} break;
	case 16: {
		inet_ntop(AF_INET6, &addr->sin6.sin6_addr, dst,
			  INET6_ADDRSTRLEN);
		port = ntohs(addr->sin6.sin6_port);
	} break;
	default:
		dst[0] = '?';
		dst[1] = 0x00;
	}

	static char buf[255];
	snprintf(buf, sizeof(buf), "%s:%i", dst, port);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x10, %eax
je 0x402cad
cmpl $0x4, %eax
jne 0x402cce
leaq 0x8(%rbx), %rsi
leaq -0x40(%rbp), %rdx
movl $0x2, %edi
movl $0x2e, %ecx
callq 0x460060
movzwl 0x6(%rbx), %eax
jmp 0x402cc8
leaq 0x1c(%rbx), %rsi
leaq -0x40(%rbp), %rdx
movl $0xa, %edi
movl $0x2e, %ecx
callq 0x460060
movzwl 0x16(%rbx), %eax
rolw $0x8, %ax
jmp 0x402cd6
movw $0x3f, -0x40(%rbp)
xorl %eax, %eax
movzwl %ax, %r8d
leaq 0xe7b8f(%rip), %rbx     # 0x4ea870
leaq 0xb162d(%rip), %rdx     # 0x4b4315
leaq -0x40(%rbp), %rcx
movl $0xff, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x40d910
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_bind_udp
int net_bind_udp(struct net_addr *shost, int reuseport, int busy_poll)
{
	int sd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sd < 0) {
		PFATAL("socket()");
	}

	int one = 1;
	int r = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&one,
			   sizeof(one));
	if (r < 0) {
		PFATAL("setsockopt(SO_REUSEADDR)");
	}

	if (reuseport) {
		one = 1;
		r = setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, (char *)&one,
			       sizeof(one));
		if (r < 0) {
			PFATAL("setsockopt(SO_REUSEPORT)");
		}
	}

	one = 1;
	r = setsockopt(sd, SOL_IP, IP_PKTINFO, (char *)&one, sizeof(one));
	if (r < 0) {
		PFATAL("setsockopt(IP_PKTINFO)");
	}

	if (bind(sd, shost->sockaddr, shost->sockaddr_len) < 0) {
		PFATAL("bind()");
	}

	if (busy_poll) {
		r = setsockopt(sd, SOL_SOCKET, SO_BUSY_POLL, (char *)&busy_poll,
			       sizeof(busy_poll));
		if (r < 0) {
			PFATAL("setsockopt(SO_BUSY_POLL)");
		}
	}

	return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movl %edx, -0x20(%rbp)
movl $0x2, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x45fc80
testl %eax, %eax
js 0x402df0
movl %eax, %ebx
leaq -0x1c(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x402df5
testl %r15d, %r15d
je 0x402d89
leaq -0x1c(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
movl $0x1, %esi
movl $0xf, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x402e04
leaq -0x1c(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
xorl %esi, %esi
movl $0x8, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x402dfa
movq 0x30(%r14), %rsi
movl 0x38(%r14), %edx
movl %ebx, %edi
callq 0x45f9f0
testl %eax, %eax
js 0x402dff
cmpl $0x0, -0x20(%rbp)
je 0x402de3
leaq -0x20(%rbp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x2e, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x402e09
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4013ef
callq 0x401389
callq 0x401323
callq 0x4012bd
callq 0x4011f1
callq 0x401257
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_bind_tcp
int net_bind_tcp(struct net_addr *shost, int reuseport)
{
	int sd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sd < 0) {
		PFATAL("socket()");
	}

	int one = 1;
	int r = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&one,
			   sizeof(one));
	if (r < 0) {
		PFATAL("setsockopt(SO_REUSEADDR)");
	}

	if (reuseport) {
		one = 1;
		r = setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, (char *)&one,
			       sizeof(one));
		if (r < 0) {
			PFATAL("setsockopt(SO_REUSEPORT)");
		}
	}

	r = bind(sd, shost->sockaddr, shost->sockaddr_len);
	if (r < 0) {
		PFATAL("bind()");
	}

	r = listen(sd, 128);
	if (r < 0) {
		PFATAL("listen()");
	}

	return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x45fc80
testl %eax, %eax
js 0x402ebb
movl %eax, %ebx
leaq -0x1c(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x402ec0
testl %r15d, %r15d
je 0x402e8b
leaq -0x1c(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
movl $0x1, %esi
movl $0xf, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x402ecf
movq 0x30(%r14), %rsi
movl 0x38(%r14), %edx
movl %ebx, %edi
callq 0x45f9f0
testl %eax, %eax
js 0x402ec5
movl %ebx, %edi
movl $0x80, %esi
callq 0x45fac0
testl %eax, %eax
js 0x402eca
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4015ed
callq 0x401587
callq 0x401521
callq 0x4014bb
callq 0x401455
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: thread_spawn
struct thread *thread_spawn(void (*callback)(void *), void *userdata)
{
	struct thread *thread = calloc(1, sizeof(struct thread));
	thread->callback = callback;
	thread->userdata = userdata;
	int r = pthread_create(&thread->thread_id, NULL, _thread_start, thread);
	if (r != 0) {
		PFATAL("pthread_create()");
	}
	return thread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x426fe0
movq %rax, %rbx
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
leaq 0x24(%rip), %rdx        # 0x402f29
movq %rax, %rdi
xorl %esi, %esi
movq %rax, %rcx
callq 0x41da80
testl %eax, %eax
jne 0x402f24
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x401653
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: thread_start
static void *_thread_start(void *userdata)
{
	struct thread *thread = userdata;

	/* Direct all signals to main thread. */
	sigset_t set;
	sigfillset(&set);
	int r = pthread_sigmask(SIG_SETMASK, &set, NULL);
	if (r != 0) {
		PFATAL("pthread_sigmask()");
	}

	thread->callback(thread->userdata);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x40bb30
movl $0x2, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x421040
testl %eax, %eax
jne 0x402f71
movq 0x10(%rbx), %rdi
callq *0x8(%rbx)
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4016b9
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_connect_udp
int net_connect_udp(struct net_addr *shost, int src_port, int busy_poll)
{
	int sd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sd < 0) {
		PFATAL("socket()");
	}

	int one = 1;
	int r = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&one,
			   sizeof(one));
	if (r < 0) {
		PFATAL("setsockopt(SO_REUSEADDR)");
	}

	if (busy_poll) {
		r = setsockopt(sd, SOL_SOCKET, SO_BUSY_POLL, (char *)&busy_poll,
			       sizeof(busy_poll));
		if (r < 0) {
			PFATAL("setsockopt(SO_BUSY_POLL)");
		}
	}

	one = 1;
	r = setsockopt(sd, SOL_SOCKET, SO_TIMESTAMPNS, (char *)&one,
		       sizeof(one));
	if (r < 0) {
		PFATAL("setsockopt(SO_TIMESTAMPNS)");
	}

	if (src_port > 1 && src_port < 65536) {
		struct net_addr src;
		memset(&src, 0, sizeof(struct net_addr));
		char buf[32];
		snprintf(buf, sizeof(buf), "0.0.0.0:%d", src_port);
		parse_addr(&src, buf);
		if (bind(sd, src.sockaddr, src.sockaddr_len) < 0) {
			PFATAL("bind()");
		}
	}

	if (-1 == connect(sd, shost->sockaddr, shost->sockaddr_len)) {
		/* is non-blocking, so we don't get error at that point yet */
		if (EINPROGRESS != errno) {
			PFATAL("connect()");
			return -1;
		}
	}

	return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %edx, -0x2c(%rbp)
movl $0x2, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x45fc80
testl %eax, %eax
js 0x4030c1
movl %eax, %ebx
leaq -0x30(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x4030c6
cmpl $0x0, -0x2c(%rbp)
je 0x403000
leaq -0x2c(%rbp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x2e, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x4030d0
leaq -0x30(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
movl $0x1, %esi
movl $0x23, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x4030cb
leal -0x2(%r15), %eax
cmpl $0xfffd, %eax           # imm = 0xFFFD
ja 0x403092
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %r12
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0xb1448(%rip), %rdx     # 0x4b44a4
leaq -0x50(%rbp), %r13
movl $0x20, %esi
movq %r13, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x40d910
movq %r12, %rdi
movq %r13, %rsi
callq 0x402b1b
movq 0x30(%r12), %rsi
movl 0x38(%r12), %edx
movl %ebx, %edi
callq 0x45f9f0
testl %eax, %eax
js 0x4030d5
movq 0x30(%r14), %rsi
movl 0x38(%r14), %edx
movl %ebx, %edi
callq 0x45fa20
cmpl $-0x1, %eax
jne 0x4030b0
callq 0x405e80
cmpl $0x73, (%rax)
jne 0x4030da
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40191d
callq 0x4018b7
callq 0x401851
callq 0x40171f
callq 0x4017eb
callq 0x401785
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: net_connect_tcp
int net_connect_tcp(struct net_addr *shost, int src_port, int busy_poll)
{
	int sd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sd < 0) {
		PFATAL("socket()");
	}

	int one = 1;
	int r = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&one,
			   sizeof(one));
	if (r < 0) {
		PFATAL("setsockopt(SO_REUSEADDR)");
	}

	if (busy_poll) {
		r = setsockopt(sd, SOL_SOCKET, SO_BUSY_POLL, (char *)&busy_poll,
			       sizeof(busy_poll));
		if (r < 0) {
			PFATAL("setsockopt(SO_BUSY_POLL)");
		}
	}

	if (src_port > 1 && src_port < 65536) {
		struct net_addr src;
		memset(&src, 0, sizeof(struct net_addr));
		char buf[32];
		snprintf(buf, sizeof(buf), "0.0.0.0:%d", src_port);
		parse_addr(&src, buf);
		if (bind(sd, src.sockaddr, src.sockaddr_len) < 0) {
			PFATAL("bind()");
		}
	}

	if (-1 == connect(sd, shost->sockaddr, shost->sockaddr_len)) {
		/* is non-blocking, so we don't get error at that point yet */
		if (EINPROGRESS != errno) {
			PFATAL("connect()");
			return -1;
		}
	}

	one = 1;
	setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char *)&one, sizeof(one));

	return sd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %edx, -0x2c(%rbp)
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x45fc80
testl %eax, %eax
js 0x403222
movl %eax, %ebx
leaq -0x30(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x403227
cmpl $0x0, -0x2c(%rbp)
je 0x403169
leaq -0x2c(%rbp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x2e, %edx
movl $0x4, %r8d
callq 0x45fc40
testl %eax, %eax
js 0x40322c
leal -0x2(%r15), %eax
cmpl $0xfffd, %eax           # imm = 0xFFFD
ja 0x4031d2
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %r12
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0xb1308(%rip), %rdx     # 0x4b44a4
leaq -0x50(%rbp), %r13
movl $0x20, %esi
movq %r13, %rdi
movl %r15d, %ecx
xorl %eax, %eax
callq 0x40d910
movq %r12, %rdi
movq %r13, %rsi
callq 0x402b1b
movq 0x30(%r12), %rsi
movl 0x38(%r12), %edx
movl %ebx, %edi
callq 0x45f9f0
testl %eax, %eax
js 0x403231
movq 0x30(%r14), %rsi
movl 0x38(%r14), %edx
movl %ebx, %edi
callq 0x45fa20
cmpl $-0x1, %eax
jne 0x4031f0
callq 0x405e80
cmpl $0x73, (%rax)
jne 0x403236
leaq -0x30(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x45fc40
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x401b1b
callq 0x401ab5
callq 0x401983
callq 0x401a4f
callq 0x4019e9
// File: /workspace/github_c_makefile_star2_O1/unixlab[P]cloudflare-udp-ping/net.c
// Function: optstring_from_long_options
const char *optstring_from_long_options(const struct option *opt)
{
	static char optstring[256] = {0};
	char *osp = optstring;

	for (; opt->name != NULL; opt++) {
		if (opt->flag == 0 && opt->val > 0 && opt->val < 256) {
			*osp++ = opt->val;
			switch (opt->has_arg) {
			case optional_argument:
				*osp++ = ':';
				*osp++ = ':';
				break;
			case required_argument:
				*osp++ = ':';
				break;
			}
		}
	}
	*osp++ = '\0';

	if (osp - optstring >= (int)sizeof(optstring)) {
		abort();
	}

	return optstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe7701(%rip), %rax     # 0x4ea970
cmpq $0x0, (%rdi)
movq %rax, %rdx
je 0x4032d6
addq $0x20, %rdi
leaq 0xe76ed(%rip), %rcx     # 0x4ea970
cmpq $0x0, -0x10(%rdi)
jne 0x4032c6
movl -0x8(%rdi), %esi
leal -0x1(%rsi), %edx
cmpl $0xfe, %edx
ja 0x4032c6
leaq 0x1(%rcx), %rdx
movb %sil, (%rcx)
movl -0x18(%rdi), %esi
cmpl $0x1, %esi
je 0x4032bb
cmpl $0x2, %esi
jne 0x4032c9
leaq 0x2(%rcx), %rdx
movb $0x3a, 0x1(%rcx)
movl $0x3, %esi
jmp 0x4032c0
movl $0x2, %esi
addq %rsi, %rcx
movb $0x3a, (%rdx)
movq %rcx, %rdx
cmpq $0x0, (%rdi)
leaq 0x20(%rdi), %rdi
movq %rdx, %rcx
jne 0x403283
movb $0x0, (%rdx)
negq %rax
addq %rdx, %rax
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0x4032f3
leaq 0xe767f(%rip), %rax     # 0x4ea970
popq %rbp
retq
callq 0x401b95
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Help_Menu
void Help_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i,j, start;

	// Calculate our page
	start = 15*ent->client->menupage;

	// Find if last page was the last
	if (start > 14)
	{
		for (i=start-15;i < start; i++)
		{
			if (!helptext[i][0]) // Last entry
			{
				start = 0;			// Go to first page
				ent->client->menupage = 0;
			}
		}
	}

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	Menu_Set(ent, 0, "LMCTF Commands", Main_Menu);
	Menu_Set(ent, 1, "--------------", NULL);
	for (i=2, j=start; i < 17 && helptext[j][0]; i++, j++)
	{
		sprintf(text, "%.24s", helptext[j]);
		Menu_Set(ent, i, text, NULL);
	}
	Menu_Set(ent, 17, "<next page>", Help_Menu);

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movl 0x10c0(%rax), %ecx
leal (%rcx,%rcx,4), %edx
leal (%rdx,%rdx,2), %r14d
testl %ecx, %ecx
jle 0x19ec5
leal -0xf(%r14), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,4), %rdx
leaq (%rdx,%rdx,4), %rdx
addq 0x4fe7c(%rip), %rdx     # 0x69d20
cmpb $0x0, (%rdx)
jne 0x19eb6
movl $0x0, 0x10c0(%rax)
xorl %r14d, %r14d
incq %rcx
movslq %r14d, %rsi
addq $0x19, %rdx
cmpq %rsi, %rcx
jl 0x19ea4
xorl %r15d, %r15d
movq 0x4f731(%rip), %r13     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x19ef7
callq *0x110(%r13)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x19ecf
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x19f26
callq *0x110(%r13)
leaq 0x39f07(%rip), %rdi     # 0x53e34
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4f85c(%rip), %rax     # 0x697a0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x19f5e
callq *0x110(%r13)
leaq 0x39281(%rip), %rdi     # 0x531e6
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movslq %r14d, %rax
leaq (%rax,%rax,4), %rax
leaq (%rax,%rax,4), %r14
addq 0x4fd99(%rip), %r14     # 0x69d20
movq $0x0, 0xfa8(%rcx)
movl $0x2, %ebp
leaq 0x39775(%rip), %r15     # 0x53713
movq %rsp, %r12
cmpb $0x0, (%r14)
je 0x19fd1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x18370
incl %ebp
addq $0x19, %r14
cmpl $0x11, %ebp
jne 0x19fa1
movq 0x58(%rbx), %rax
movq 0x10a0(%rax), %rdi
testq %rdi, %rdi
je 0x19fe8
callq *0x110(%r13)
leaq 0x39377(%rip), %rdi     # 0x53366
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x10a0(%rcx)
movq 0x4f80a(%rip), %rax     # 0x69810
movq %rax, 0x10a8(%rcx)
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: PickSound
void PickSound (edict_t *ent)
{
	PlayTeamSound(ent, radiosound[ent->client->menuselect]);

	ent->client->showmenu = false;
	Menu_Blank(ent);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movslq 0xf88(%rax), %rax
movq 0x4f6f2(%rip), %rcx     # 0x69ad0
movq (%rcx,%rax,8), %rsi
callq 0x18d60
movq 0x58(%rbx), %rax
movl $0x0, 0xf80(%rax)
movq 0x4f204(%rip), %r14     # 0x69600
movl $0x4, %edi
callq *0xc8(%r14)
leaq 0x3aaf6(%rip), %rdi     # 0x54f05
callq *0xe8(%r14)
movq 0xb8(%r14), %rax
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ctf_Menu
void Ctf_Menu (edict_t *ent)
{
	gclient_t	*cl;

	cl = ent->client;

	cl->showscores = false;
	cl->showhelp = false;
	cl->showinventory = false;
	cl->showmod = false;
	cl->showctfhud = false;
	cl->showsquadboard = false; // ADC

	if (cl->showmenu)
	{
		cl->showmenu = false;
		Menu_Blank(ent);
		return;
	}

	cl->showmenu = true;
	Main_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
xorl %ecx, %ecx
movq %rcx, 0xe24(%rax)
movl %ecx, 0xe2c(%rax)
movq %rcx, 0xf74(%rax)
movl %ecx, 0xe34(%rax)
cmpl %ecx, 0xf80(%rax)
je 0x1a4a0
movl $0x0, 0xf80(%rax)
movq 0x4f192(%rip), %r14     # 0x69600
movl $0x4, %edi
callq *0xc8(%r14)
leaq 0x3aa84(%rip), %rdi     # 0x54f05
callq *0xe8(%r14)
movq 0xb8(%r14), %rax
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movl $0x1, 0xf80(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19aa8
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Menu_Free
void Menu_Free (edict_t *ent)
{
	int i;
	for (i=0; i < 18; i++)
	{
		if (ent->client->localmenu[i].text)
		{
			gi.TagFree(ent->client->localmenu[i].text);
			ent->client->localmenu[i].text = NULL;
			ent->client->localmenu[i].func = NULL;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x4f0f5(%rip), %r15     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x1a533
callq *0x110(%r15)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r14)
addq $0x10, %r14
cmpq $0x120, %r14            # imm = 0x120
jne 0x1a50b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Menu_Set
void Menu_Set (edict_t *ent, int item, char *text, void	(*func)(edict_t *ent))
{
	if (ent->client->localmenu[item].text)
			gi.TagFree(ent->client->localmenu[item].text);

	// Set the menu text to a TagMalloc'ed string, kind of like strdup
	ent->client->localmenu[item].text = G_CopyString(text);
	ent->client->localmenu[item].func = func;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq 0x58(%rdi), %rax
movslq %esi, %r12
shlq $0x4, %r12
movq 0xf90(%rax,%r12), %rdi
testq %rdi, %rdi
je 0x1a57c
movq 0x4f08a(%rip), %rax     # 0x69600
callq *0x110(%rax)
movq %r15, %rdi
callq 0x18100
movq 0x58(%r14), %rcx
movq %rax, 0xf90(%rcx,%r12)
movq %rbx, 0xf98(%rcx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Obs_Main_Menu
void Obs_Main_Menu (edict_t *ent)
{
char text[MAX_INFO_STRING];

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 1;


	Menu_Set(ent, 1, "LMCTF Observer Menu", NULL);
	Menu_Set(ent, 2, "-------------------", NULL);
	Menu_Set(ent, 4, "Play CTF", Observe_Exec);

	sprintf(text, "Observe Red");
	Menu_Set(ent, 6, text, Observe_Red);

	sprintf(text, "Observe_Blue");
	Menu_Set(ent, 7, text, Observe_Blue);

	sprintf(text, "Observe_All");
	Menu_Set(ent, 8, text, Observe);

	Menu_Set(ent, 10, "Help", Help_Menu);

	Menu_Draw (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x4f041(%rip), %r15     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r14), %rdi
testq %rdi, %rdi
je 0x1a5e7
callq *0x110(%r15)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r14)
addq $0x10, %r14
cmpq $0x120, %r14            # imm = 0x120
jne 0x1a5bf
movq 0x58(%rbx), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0xf84(%rax)
movq 0xfa0(%rax), %rdi
testq %rdi, %rdi
je 0x1a61c
callq *0x110(%r15)
leaq 0x38d4f(%rip), %rdi     # 0x53372
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movq 0xfb0(%rcx), %rdi
testq %rdi, %rdi
je 0x1a651
callq *0x110(%r15)
leaq 0x38b89(%rip), %rdi     # 0x531e1
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfb0(%rcx)
movq $0x0, 0xfb8(%rcx)
movq 0xfd0(%rcx), %rdi
testq %rdi, %rdi
je 0x1a686
callq *0x110(%r15)
leaq 0x38cf9(%rip), %rdi     # 0x53386
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfd0(%rcx)
movq 0x4ee24(%rip), %rax     # 0x694c8
movq %rax, 0xfd8(%rcx)
movabsq $0x206576726573624f, %rax # imm = 0x206576726573624F
movq %rax, (%rsp)
movl $0x646552, 0x8(%rsp)    # imm = 0x646552
movq 0xff0(%rcx), %rdi
testq %rdi, %rdi
je 0x1a6d4
callq *0x110(%r15)
movq %rsp, %r14
movq %r14, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xff0(%rcx)
movq 0x4f277(%rip), %rax     # 0x69968
movq %rax, 0xff8(%rcx)
movabsq $0x5f6576726573624f, %r12 # imm = 0x5F6576726573624F
movq %r12, (%r14)
movabsq $0x65756c425f6576, %rax # imm = 0x65756C425F6576
movq %rax, 0x5(%r14)
movq 0x1000(%rcx), %rdi
testq %rdi, %rdi
je 0x1a726
callq *0x110(%r15)
movq %rsp, %r14
movq %r14, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x1000(%rcx)
movq 0x4f845(%rip), %rax     # 0x69f88
movq %rax, 0x1008(%rcx)
movq %r12, (%r14)
movl $0x6c6c41, 0x8(%r14)    # imm = 0x6C6C41
movq 0x1010(%rcx), %rdi
testq %rdi, %rdi
je 0x1a768
callq *0x110(%r15)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x1010(%rcx)
movq 0x4ecfe(%rip), %rax     # 0x69480
movq %rax, 0x1018(%rcx)
movq 0x1030(%rcx), %rdi
testq %rdi, %rdi
je 0x1a79c
callq *0x110(%r15)
leaq 0x38cdc(%rip), %rdi     # 0x5347f
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x1030(%rcx)
movq 0x4f056(%rip), %rax     # 0x69810
movq %rax, 0x1038(%rcx)
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Observe_Exec
void Observe_Exec(edict_t *ent)
{
	if(ent->client->ctf.teamnum <= CTF_TEAM_OBSERVER)
		TeamJoin(ent);
	else
		Observe(ent);

	Ctf_Menu(ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cmpl $0x0, 0x1100(%rax)
js 0x1a7f8
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x196a0
jmp 0x1a800
movq %rbx, %rdi
callq 0x19890
movq %rbx, %rdi
popq %rbx
jmp 0x197e0
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Voice_Menu
void Voice_Menu (edict_t *ent)
{
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	Menu_Set(ent, 0, "Play_Voice Menu", Main_Menu);
	Menu_Set(ent, 1, "---------------", NULL);
	for (i=2; i < 18; i++)
	{
		if (voicelist[i])
			Menu_Set(ent, i, voicelist[i], Voice_Exec);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4edb5(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1a873
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1a84b
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1a8a2
callq *0x110(%r14)
leaq 0x3957b(%rip), %rdi     # 0x53e24
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4eee0(%rip), %rax     # 0x697a0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1a8da
callq *0x110(%r14)
leaq 0x38904(%rip), %rdi     # 0x531e5
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movl $0x2, %r14d
movq 0x4f6af(%rip), %r12     # 0x69fb8
movq 0x4f360(%rip), %r15     # 0x69c70
movq (%r12,%r14,8), %rdx
testq %rdx, %rdx
je 0x1a927
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rcx
callq 0x18370
incq %r14
cmpq $0x12, %r14
jne 0x1a910
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x196c0
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: SetSkin
void SetSkin (edict_t *ent)
{
	int i;
	char **skinlist;

	i = (ent->client->menuselect - 2)+ent->client->menulastpage*15;

	skinlist = SkinGetList(ent);

	ClientSetSkin(ent, skinlist[i]);
	ent->client->currmenu = Skin_Menu;
	ent->client->menupage = 0;
	Skin_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movslq 0xf88(%rax), %rcx
movslq 0x10c4(%rax), %rax
leaq (%rax,%rax,4), %rax
leaq (%rax,%rax,2), %r14
addq %rcx, %r14
callq 0x18710
movq -0x10(%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x196f0
movq 0x58(%rbx), %rax
movq 0x4eae9(%rip), %rcx     # 0x699d8
movq %rcx, 0x10b0(%rax)
movl $0x0, 0x10c0(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19b00
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Toggle_Radio_Menu
void Toggle_Radio_Menu (edict_t *ent)
{
	gclient_t	*cl;

	cl = ent->client;

	cl->showscores = false;
	cl->showhelp = false;
	cl->showinventory = false;
	cl->showmod = false;
	cl->showctfhud = false;
	cl->showsquadboard = false; // ADC

	if (cl->showmenu)
	{
		cl->showmenu = false;
		Menu_Blank(ent);
		return;
	}

	cl->showmenu = true;
	Radio_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
xorl %ecx, %ecx
movq %rcx, 0xe24(%rax)
movl %ecx, 0xe2c(%rax)
movq %rcx, 0xf74(%rax)
movl %ecx, 0xe34(%rax)
cmpl %ecx, 0xf80(%rax)
je 0x1af95
movl $0x0, 0xf80(%rax)
movq 0x4e69d(%rip), %r14     # 0x69600
movl $0x4, %edi
callq *0xc8(%r14)
leaq 0x39f8f(%rip), %rdi     # 0x54f05
callq *0xe8(%r14)
movq 0xb8(%r14), %rax
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movabsq $0x600000001, %rcx      # imm = 0x600000001
movq %rcx, 0xf80(%rax)
movl $0x1, 0xf88(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x196c0
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Main_Load
void Ref_Main_Load (edict_t *ent)
{
	gclient_t	*cl;

	cl = ent->client;

	cl->showscores = false;
	cl->showhelp = false;
	cl->showinventory = false;
	cl->showmod = false;
	cl->showctfhud = false;
	cl->showsquadboard = false; // ADC

	if (cl->showmenu)
	{
		cl->showmenu = false;
		Menu_Blank(ent);
		return;
	}

	cl->showmenu = true;

	cl->menu = MENU_LOCAL;
	cl->menuselect = 1;

	Ref_Main_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
xorl %ecx, %ecx
movq %rcx, 0xe24(%rax)
movl %ecx, 0xe2c(%rax)
movq %rcx, 0xf74(%rax)
movl %ecx, 0xe34(%rax)
cmpl %ecx, 0xf80(%rax)
je 0x1b031
movl $0x0, 0xf80(%rax)
movq 0x4e601(%rip), %r14     # 0x69600
movl $0x4, %edi
callq *0xc8(%r14)
leaq 0x39ef3(%rip), %rdi     # 0x54f05
callq *0xe8(%r14)
movq 0xb8(%r14), %rax
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq $0x1, 0xf80(%rax)
movl $0x1, 0xf88(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19b20
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Map_Menu
void Ref_Map_Menu (edict_t *ent)
{
	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	//gi.dprintf("Ref_Map_Menu\n");
	Menu_Set(ent, 0, "Map Menu", Ref_Main_Menu);
	Menu_Set(ent, 1, "--------", NULL);
	Menu_Set(ent, 2, "LMCTF Set 1", Ref_Map_A_Menu);
	Menu_Set(ent, 3, "LMCTF Set 2", Ref_Map_B_Menu);
	Menu_Set(ent, 4, "LMCTF Set 3", Ref_Map_C_Menu);
	Menu_Set(ent, 5, "LMCTF Set 4", Ref_Map_D_Menu);
	Menu_Set(ent, 6, "LMCTF Set 5", Ref_Map_E_Menu);
	if (maplistindex != -2) // No list
		Menu_Set(ent, 7, "Maplist", Ref_Map_Maplist_Menu);

	Menu_Draw (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4e599(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1b08f
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1b067
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1b0be
callq *0x110(%r14)
leaq 0x38cf1(%rip), %rdi     # 0x53db6
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4ea14(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b0f6
callq *0x110(%r14)
leaq 0x380ef(%rip), %rdi     # 0x531ec
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movq 0xfb0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b12b
callq *0x110(%r14)
leaq 0x38c40(%rip), %rdi     # 0x53d72
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfb0(%rcx)
movq 0x4e617(%rip), %rax     # 0x69760
movq %rax, 0xfb8(%rcx)
movq 0xfc0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b163
callq *0x110(%r14)
leaq 0x38c14(%rip), %rdi     # 0x53d7e
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfc0(%rcx)
movq 0x4e9ef(%rip), %rax     # 0x69b70
movq %rax, 0xfc8(%rcx)
movq 0xfd0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b19b
callq *0x110(%r14)
leaq 0x38be8(%rip), %rdi     # 0x53d8a
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfd0(%rcx)
movq 0x4e85f(%rip), %rax     # 0x69a18
movq %rax, 0xfd8(%rcx)
movq 0xfe0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b1d3
callq *0x110(%r14)
leaq 0x38bbc(%rip), %rdi     # 0x53d96
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfe0(%rcx)
movq 0x4e1cf(%rip), %rax     # 0x693c0
movq %rax, 0xfe8(%rcx)
movq 0xff0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b20b
callq *0x110(%r14)
leaq 0x38b90(%rip), %rdi     # 0x53da2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xff0(%rcx)
movq 0x4e517(%rip), %rax     # 0x69740
movq %rax, 0xff8(%rcx)
movq 0x4eba1(%rip), %rax     # 0x69dd8
cmpl $-0x2, (%rax)
je 0x1b274
movq 0x1000(%rcx), %rdi
testq %rdi, %rdi
je 0x1b24f
callq *0x110(%r14)
leaq 0x38b58(%rip), %rdi     # 0x53dae
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x1000(%rcx)
movq 0x4e8a3(%rip), %rax     # 0x69b10
movq %rax, 0x1008(%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x196c0
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_PingFloor_Menu
void Ref_PingFloor_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(text, "Current Ping Floor:  %3d", ent->client->ctf.pingalertfloor);
	Menu_Set(ent, 0, text, Ref_Main_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2; i < 18; i++)
	{
		sprintf(text, "%d", pingfloor[i]);
		Menu_Set(ent, i, text, PingFloor_Exec);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4df20(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1b708
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1b6e0
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movl 0x1110(%rax), %edx
leaq 0x38033(%rip), %rsi     # 0x53764
movq %rsp, %rdi
xorl %eax, %eax
callq 0x19700
movq 0x58(%rbx), %rax
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1b752
callq *0x110(%r14)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4e384(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b786
callq *0x110(%r14)
leaq 0x37a55(%rip), %rdi     # 0x531e2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movl $0x2, %r14d
movq 0x4df0b(%rip), %rbp     # 0x696c0
leaq 0x380ca(%rip), %r15     # 0x53886
movq %rsp, %r12
movq 0x4dd4a(%rip), %r13     # 0x69510
movl (%rbp,%r14,4), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x18370
incq %r14
cmpq $0x12, %r14
jne 0x1b7c6
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_PingCeiling_Menu
void Ref_PingCeiling_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(text, "Current Ping Ceiling: %3d", ent->client->ctf.pingalertceiling);
	Menu_Set(ent, 0, text, Ref_Main_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2; i < 18; i++)
	{
		sprintf(text, "%d", pingfloor[i]);
		Menu_Set(ent, i, text, PingCeiling_Exec);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4ddd6(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1b852
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1b82a
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movl 0x1114(%rax), %edx
leaq 0x37f02(%rip), %rsi     # 0x5377d
movq %rsp, %rdi
xorl %eax, %eax
callq 0x19700
movq 0x58(%rbx), %rax
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1b89c
callq *0x110(%r14)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4e23a(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1b8d0
callq *0x110(%r14)
leaq 0x3790b(%rip), %rdi     # 0x531e2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movl $0x2, %r14d
movq 0x4ddc1(%rip), %rbp     # 0x696c0
leaq 0x37f80(%rip), %r15     # 0x53886
movq %rsp, %r12
movq 0x4dce8(%rip), %r13     # 0x695f8
movl (%rbp,%r14,4), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x18370
incq %r14
cmpq $0x12, %r14
jne 0x1b910
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq