LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/init.c
// Function: interface_listen_sockets
void interface_listen_sockets(void)
{
	struct list_head *list_pos;
	struct batman_if *batman_if;

	FD_ZERO(&receive_wait_set);
	receive_max_sock = 0;

	list_for_each(list_pos, &if_list) {
		batman_if = list_entry(list_pos, struct batman_if, list);

		if (batman_if->if_active) {
			if (batman_if->udp_recv_sock > receive_max_sock)
				receive_max_sock = batman_if->udp_recv_sock;

			FD_SET(batman_if->udp_recv_sock, &receive_wait_set);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xcbed(%rip), %rax      # 0x1b428
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x10, %rax
jae 0xe869
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe846
jmp 0xe86b
leaq 0xcb16(%rip), %rax      # 0x1b388
movl $0x0, (%rax)
leaq 0xcb31(%rip), %rax      # 0x1b3b0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xcb23(%rip), %rax      # 0x1b3b0
cmpq %rax, -0x8(%rbp)
je 0xe928
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1d(%rax)
je 0xe916
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
leaq 0xcad1(%rip), %rcx      # 0x1b388
cmpl (%rcx), %eax
jle 0xe8cb
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
leaq 0xcabf(%rip), %rax      # 0x1b388
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rdx
movslq %eax, %rcx
leaq 0xcb21(%rip), %rax      # 0x1b428
orq (%rax,%rcx,8), %rdx
leaq 0xcb16(%rip), %rax      # 0x1b428
movq %rdx, (%rax,%rcx,8)
jmp 0xe918
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xe886
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/init.c
// Function: deactivate_interface
void deactivate_interface(struct batman_if *batman_if)
{
	if (batman_if->udp_recv_sock != 0)
		close(batman_if->udp_recv_sock);

	if (batman_if->udp_send_sock != 0)
		close(batman_if->udp_send_sock);

	batman_if->udp_recv_sock = 0;
	batman_if->udp_send_sock = 0;

	if ((batman_if->netaddr > 0) && (batman_if->netmask > 0)) {

		add_del_rule(batman_if->netaddr, batman_if->netmask, BATMAN_RT_TABLE_HOSTS, BATMAN_RT_PRIO_DEFAULT + batman_if->if_num, 0, RULE_TYPE_DST, RULE_DEL);
		add_del_rule(batman_if->netaddr, batman_if->netmask, BATMAN_RT_TABLE_UNREACH, BATMAN_RT_PRIO_UNREACH + batman_if->if_num, 0, RULE_TYPE_DST, RULE_DEL);

	}

	batman_if->if_active = 0;
	active_ifs--;

	if (batman_if->if_rp_filter_old > -1)
		set_rp_filter(batman_if->if_rp_filter_old, batman_if->dev);

	if (batman_if->if_send_redirects_old > -1)
		set_send_redirects(batman_if->if_send_redirects_old, batman_if->dev);

	batman_if->if_rp_filter_old = -1;
	batman_if->if_send_redirects_old = -1;

	interface_listen_sockets();
	debug_output(3, "Interface deactivated: %s\n", batman_if->dev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0xe952
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x2210
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xe968
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x2210
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
jbe 0xea0f
movq -0x8(%rbp), %rax
movzbl 0x54(%rax), %eax
cmpl $0x0, %eax
jle 0xea0f
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edi
movq -0x8(%rbp), %rax
movb 0x54(%rax), %al
movq -0x8(%rbp), %rcx
movzbl 0x1c(%rcx), %ecx
addl $0x19c8, %ecx           # imm = 0x19C8
movl $0x42, %edx
xorl %esi, %esi
movl %esi, %r8d
movl $0x1, %r9d
movzbl %al, %esi
movl $0x1, (%rsp)
callq 0xacd0
movq -0x8(%rbp), %rax
movl 0x50(%rax), %edi
movq -0x8(%rbp), %rax
movb 0x54(%rax), %al
movq -0x8(%rbp), %rcx
movzbl 0x1c(%rcx), %ecx
addl $0x1a2c, %ecx           # imm = 0x1A2C
movl $0x43, %edx
xorl %esi, %esi
movl %esi, %r8d
movl $0x1, %r9d
movzbl %al, %esi
movl $0x1, (%rsp)
callq 0xacd0
movq -0x8(%rbp), %rax
movb $0x0, 0x1d(%rax)
leaq 0xc967(%rip), %rax      # 0x1b385
movb (%rax), %cl
addb $-0x1, %cl
leaq 0xc95b(%rip), %rax      # 0x1b385
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movsbl 0x24(%rax), %eax
cmpl $-0x1, %eax
jle 0xea4e
movq -0x8(%rbp), %rax
movsbl 0x24(%rax), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc750
movq -0x8(%rbp), %rax
movsbl 0x25(%rax), %eax
cmpl $-0x1, %eax
jle 0xea70
movq -0x8(%rbp), %rax
movsbl 0x25(%rax), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xc920
movq -0x8(%rbp), %rax
movb $-0x1, 0x24(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x25(%rax)
callq 0xe830
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x3, %edi
leaq 0x858e(%rip), %rsi      # 0x17027
movb $0x0, %al
callq 0x123f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/init.c
// Function: is_interface_up
static int is_interface_up(char *dev)
{
	struct ifreq int_req;
	int sock;

	if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
		return 0;

	memset(&int_req, 0, sizeof (struct ifreq));
	strncpy(int_req.ifr_name, dev, IFNAMSIZ - 1);

	if (ioctl(sock, SIOCGIFFLAGS, &int_req) < 0)
		goto failure;

	if (!(int_req.ifr_flags & IFF_UP))
		goto failure;

	if (ioctl(sock, SIOCGIFADDR, &int_req) < 0)
		goto failure;

	close(sock);
	return 1;

failure:
	close(sock);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2500
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jge 0xeade
movl $0x0, -0x4(%rbp)
jmp 0xeb62
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x21e0
leaq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xf, %edx
callq 0x2090
movl -0x3c(%rbp), %edi
movl $0x8913, %esi           # imm = 0x8913
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x21f0
cmpl $0x0, %eax
jge 0xeb1a
jmp 0xeb53
movswl -0x28(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xeb28
jmp 0xeb53
movl -0x3c(%rbp), %edi
movl $0x8915, %esi           # imm = 0x8915
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x21f0
cmpl $0x0, %eax
jge 0xeb42
jmp 0xeb53
movl -0x3c(%rbp), %edi
callq 0x2210
movl $0x1, -0x4(%rbp)
jmp 0xeb62
movl -0x3c(%rbp), %edi
callq 0x2210
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/init.c
// Function: check_inactive_interfaces
void check_inactive_interfaces(void)
{
	struct list_head *list_pos;
	struct batman_if *batman_if;

	/* all available interfaces are active */
	if (found_ifs == active_ifs)
		return;

	list_for_each(list_pos, &if_list) {
		batman_if = list_entry(list_pos, struct batman_if, list);

		if ((!batman_if->if_active) && (is_interface_up(batman_if->dev)))
			activate_interface(batman_if);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc215(%rip), %rax      # 0x1b384
movzbl (%rax), %eax
leaq 0xc20c(%rip), %rcx      # 0x1b385
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xf182
jmp 0xf1d9
leaq 0xc227(%rip), %rax      # 0x1b3b0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xc219(%rip), %rax      # 0x1b3b0
cmpq %rax, -0x8(%rbp)
je 0xf1d9
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x1d(%rax)
jne 0xf1ca
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xeab0
cmpl $0x0, %eax
je 0xf1ca
movq -0x10(%rbp), %rdi
callq 0xeb70
jmp 0xf1cc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xf190
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/init.c
// Function: check_active_interfaces
void check_active_interfaces(void)
{
	struct list_head *list_pos;
	struct batman_if *batman_if;

	/* all available interfaces are deactive */
	if (active_ifs == 0)
		return;

	list_for_each(list_pos, &if_list) {
		batman_if = list_entry(list_pos, struct batman_if, list);

		if ((batman_if->if_active) && (!is_interface_up(batman_if->dev)))
			deactivate_interface(batman_if);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc196(%rip), %rax      # 0x1b385
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xf1f9
jmp 0xf253
leaq 0xc1b0(%rip), %rax      # 0x1b3b0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
leaq 0xc1a2(%rip), %rax      # 0x1b3b0
cmpq %rax, -0x8(%rbp)
je 0xf253
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1d(%rax), %eax
cmpl $0x0, %eax
je 0xf244
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xeab0
cmpl $0x0, %eax
jne 0xf244
movq -0x10(%rbp), %rdi
callq 0xe930
jmp 0xf246
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xf207
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: get_time_msec
uint32_t get_time_msec(void)
{
	uint32_t time;

	pthread_mutex_lock(&batman_clock_mutex);
	update_internal_clock();
	time = (uint32_t)(((float)(batman_clock_ticks) * 1000) / system_tick);
	pthread_mutex_unlock(&batman_clock_mutex);

	return time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc4c1(%rip), %rdi      # 0x1b730
callq 0x24e0
callq 0xf300
leaq 0xc120(%rip), %rax      # 0x1b3a0
movq (%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0xc(%rbp)
testq %rax, %rax
movss %xmm0, -0x8(%rbp)
js 0xf2b8
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
movss 0x80cb(%rip), %xmm1     # 0x17390
mulss %xmm1, %xmm0
movss 0xc487(%rip), %xmm1     # 0x1b758
divss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0x4(%rbp)
leaq 0xc44c(%rip), %rdi      # 0x1b730
callq 0x2300
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: get_time_msec64
uint64_t get_time_msec64(void)
{
	uint64_t time;

	pthread_mutex_lock(&batman_clock_mutex);
	update_internal_clock();
	time = (uint64_t)(((float)(batman_clock_ticks) * 1000) / system_tick);
	pthread_mutex_unlock(&batman_clock_mutex);

	return time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xc3d1(%rip), %rdi      # 0x1b730
callq 0x24e0
callq 0xf300
leaq 0xc030(%rip), %rax      # 0x1b3a0
movq (%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x10(%rbp)
testq %rax, %rax
movss %xmm0, -0xc(%rbp)
js 0xf3a8
movss -0x10(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x7fdb(%rip), %xmm1     # 0x17390
mulss %xmm1, %xmm0
movss 0xc397(%rip), %xmm1     # 0x1b758
divss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movss 0x7fb8(%rip), %xmm1     # 0x17394
subss %xmm1, %xmm0
cvttss2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
leaq 0xc33a(%rip), %rdi      # 0x1b730
callq 0x2300
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: bat_wait
static void bat_wait( int32_t T, int32_t t ) {

	struct timeval time;

	time.tv_sec = T;
	time.tv_usec = ( t * 10000 );

	select( 0, NULL, NULL, NULL, &time );

	return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x18(%rbp)
imull $0x2710, -0x8(%rbp), %eax # imm = 0x2710
cltq
movq %rax, -0x10(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x18(%rbp), %r8
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x22f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: sym_print
static void sym_print( char x, char y, const char *z ) {

	char i = 0, Z;

	do{

		BAT_LOGO_PRINT( 25 + (int)x + (int)i, (int)y, z[(int)i] );

		switch ( z[(int)i] ) {

			case 92:
				Z = 47;   /* "\" --> "/" */
				break;

			case 47:
				Z = 92;   /* "/" --> "\" */
				break;

			case 41:
				Z = 40;   /* ")" --> "(" */
				break;

			default:
				Z = z[(int)i];
				break;

		}

		BAT_LOGO_PRINT( 24 - (int)x - (int)i, (int)y, Z );
		i++;

	} while( z[(int)i - 1] );

	return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movsbl -0x2(%rbp), %esi
incl %esi
movsbl -0x1(%rbp), %edx
movsbq -0x11(%rbp), %rcx
movl %ecx, %edi
movl %edx, %eax
movl %edi, %edx
leal 0x19(%rax,%rdx), %edx
movq -0x10(%rbp), %rax
movsbl (%rax,%rcx), %ecx
leaq 0x7be1(%rip), %rdi      # 0x175c5
xorl %eax, %eax
callq 0x21a0
movq -0x10(%rbp), %rax
movsbq -0x11(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
subl $0x29, %eax
je 0xfa22
jmp 0xfa02
movl -0x18(%rbp), %eax
subl $0x2f, %eax
je 0xfa1c
jmp 0xfa0c
movl -0x18(%rbp), %eax
subl $0x5c, %eax
jne 0xfa28
jmp 0xfa16
movb $0x2f, -0x12(%rbp)
jmp 0xfa39
movb $0x5c, -0x12(%rbp)
jmp 0xfa39
movb $0x28, -0x12(%rbp)
jmp 0xfa39
movq -0x10(%rbp), %rax
movsbl -0x11(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x12(%rbp)
movsbl -0x2(%rbp), %esi
addl $0x1, %esi
movsbl -0x1(%rbp), %eax
movl $0x18, %edx
subl %eax, %edx
movsbl -0x11(%rbp), %eax
subl %eax, %edx
movsbl -0x12(%rbp), %ecx
leaq 0x7b69(%rip), %rdi      # 0x175c5
movb $0x0, %al
callq 0x21a0
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movsbl -0x11(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpb $0x0, (%rax,%rcx)
jne 0xf9bc
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: add_default_route
void add_default_route(void)
{
	struct curr_gw_data *curr_gw_data;

	if (tunnel_running) {
		debug_output(3, "Error - couldn't create tunnel: old tunnel is still active\n");
		return;
	}

	curr_gw_data = debugMalloc( sizeof(struct curr_gw_data), 207 );
	curr_gw_data->orig = curr_gateway->orig_node->orig;
	curr_gw_data->gw_node = curr_gateway;
	curr_gw_data->batman_if = curr_gateway->orig_node->batman_if;

	tunnel_running = 1;

	if (pthread_create(&curr_gateway_thread_id, NULL, &client_to_gw_tun, curr_gw_data) != 0) {

		debug_output(0, "Error - couldn't spawn thread: %s\n", strerror(errno));
		debugFree(curr_gw_data, 1213);
		curr_gateway = NULL;
		tunnel_running = 0;

	} else {

		pthread_detach(curr_gateway_thread_id);

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0xbbc9(%rip)      # 0x1b728
je 0xfb79
movl $0x3, %edi
leaq 0x78d3(%rip), %rsi      # 0x17440
movb $0x0, %al
callq 0x123f0
jmp 0xfc48
movl $0x18, %edi
movl $0xcf, %esi
callq 0x7220
movq %rax, -0x8(%rbp)
leaq 0xb7cd(%rip), %rax      # 0x1b360
movq (%rax), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0xb7b7(%rip), %rax      # 0x1b360
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0xb7a5(%rip), %rax      # 0x1b360
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, 0xbb53(%rip)      # 0x1b728
movq -0x8(%rbp), %rcx
leaq 0xb788(%rip), %rdi      # 0x1b368
xorl %eax, %eax
movl %eax, %esi
leaq 0x9e5(%rip), %rdx       # 0x105d0
callq 0x23b0
cmpl $0x0, %eax
je 0xfc39
callq 0x2070
movl (%rax), %edi
callq 0x24a0
movq %rax, %rdx
xorl %edi, %edi
leaq 0x786f(%rip), %rsi      # 0x1747c
movb $0x0, %al
callq 0x123f0
movq -0x8(%rbp), %rdi
movl $0x4bd, %esi            # imm = 0x4BD
callq 0x7720
leaq 0xb737(%rip), %rax      # 0x1b360
movq $0x0, (%rax)
movb $0x0, 0xbaf1(%rip)      # 0x1b728
jmp 0xfc48
leaq 0xb728(%rip), %rax      # 0x1b368
movq (%rax), %rdi
callq 0x2330
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: send_udp_packet
int8_t send_udp_packet(unsigned char *packet_buff, int32_t packet_buff_len, struct sockaddr_in *broad, int32_t send_sock, struct batman_if *batman_if)
{
	if ((batman_if != NULL) && (!batman_if->if_active))
		return 0;

	if ( sendto( send_sock, packet_buff, packet_buff_len, 0, (struct sockaddr *)broad, sizeof(struct sockaddr_in) ) < 0 ) {

		if ( errno == 1 ) {

			debug_output(0, "Error - can't send udp packet: %s.\nDoes your firewall allow outgoing packets on port %i ?\n", strerror(errno), ntohs(broad->sin_port));

		} else {

			debug_output(0, "Error - can't send udp packet: %s\n", strerror(errno));

		}

		return -1;

	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xfea4
movq -0x30(%rbp), %rax
cmpb $0x0, 0x1d(%rax)
jne 0xfea4
movb $0x0, -0x1(%rbp)
jmp 0xff37
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2200
cmpq $0x0, %rax
jge 0xff33
callq 0x2070
cmpl $0x1, (%rax)
jne 0xff0e
callq 0x2070
movl (%rax), %edi
callq 0x24a0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x2390
movq -0x40(%rbp), %rdx
movzwl %ax, %ecx
xorl %edi, %edi
leaq 0x75e7(%rip), %rsi      # 0x174ec
movb $0x0, %al
callq 0x123f0
jmp 0xff2d
callq 0x2070
movl (%rax), %edi
callq 0x24a0
movq %rax, %rdx
xorl %edi, %edi
leaq 0x7621(%rip), %rsi      # 0x17547
movb $0x0, %al
callq 0x123f0
movb $-0x1, -0x1(%rbp)
jmp 0xff37
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: del_gw_interface
void del_gw_interface(void)
{
	struct batman_if *batman_if = (struct batman_if *)if_list.next;

	if (batman_if->udp_tunnel_sock > 0) {

		if (batman_if->listen_thread_id != 0) {
			pthread_join(batman_if->listen_thread_id, NULL);
		}

		close(batman_if->udp_tunnel_sock);

		batman_if->listen_thread_id = 0;
		batman_if->udp_tunnel_sock = 0;

	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb461(%rip), %rax      # 0x1b3b0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0xff9f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xff7c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2490
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x2210
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: restore_and_exit
void restore_and_exit( uint8_t is_sigsegv ) {

	struct orig_node *orig_node;
	struct hash_it_t *hashit = NULL;

	if ( !unix_client ) {

		/* remove tun interface first */
		stop = 1;

		del_gw_interface();

		if ( ( routing_class != 0 ) && ( curr_gateway != NULL ) )
			del_default_route();

		/* all rules and routes were purged in segmentation_fault() */
		if ( !is_sigsegv ) {

			while ( NULL != ( hashit = hash_iterate( orig_hash, hashit ) ) ) {

				orig_node = hashit->bucket->data;

				update_routes( orig_node, NULL, NULL, 0 );

			}

		}

		restore_defaults();

	}

	if (is_sigsegv)
		raise(SIGSEGV);

	/* call exit always even if it will not be reached to make the compiler happy */
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xb1ef(%rip), %rax      # 0x1b38c
cmpb $0x0, (%rax)
jne 0x10229
leaq 0xb573(%rip), %rax      # 0x1b720
movb $0x1, (%rax)
callq 0xff40
leaq 0xb19e(%rip), %rax      # 0x1b35a
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x101d6
leaq 0xb195(%rip), %rax      # 0x1b360
cmpq $0x0, (%rax)
je 0x101d6
callq 0xfb30
cmpb $0x0, -0x1(%rbp)
jne 0x10224
jmp 0x101de
leaq 0xb1eb(%rip), %rax      # 0x1b3d0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x7fb0
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
je 0x10222
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
movq %rdx, %rsi
callq 0x30b0
jmp 0x101de
jmp 0x10224
callq 0xffb0
cmpb $0x0, -0x1(%rbp)
je 0x10239
movl $0xb, %edi
callq 0x2040
movl $0x1, %edi
callq 0x2470
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: segmentation_fault
void segmentation_fault(int32_t BATMANUNUSED(sig)) {

	signal(SIGSEGV, SIG_DFL);

	debug_output( 0, "Error - SIGSEGV received, trying to clean up ... \n" );

	flush_routes_rules(0);
	flush_routes_rules(1);

	restore_and_exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x2290
xorl %edi, %edi
leaq 0x72f8(%rip), %rsi      # 0x1756a
movb $0x0, %al
callq 0x123f0
xorl %edi, %edi
callq 0xb720
movl $0x1, %edi
callq 0xb720
movl $0x1, %edi
callq 0x10180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: cleanup
void cleanup(void) {

	int8_t i;
	struct list_head *debug_pos, *debug_pos_tmp;


	for ( i = 0; i < debug_level_max; i++ ) {

		if ( debug_clients.clients_num[i] > 0 ) {

			list_for_each_safe( debug_pos, debug_pos_tmp, (struct list_head *)debug_clients.fd_list[i] ) {

				list_del( (struct list_head *)debug_clients.fd_list[i], debug_pos, (struct list_head_first *)debug_clients.fd_list[i] );
				debugFree( debug_pos, 1218 );

			}

		}

		debugFree( debug_clients.fd_list[i], 1219 );
		debugFree( debug_clients.mutex[i], 1220 );

	}

	debugFree( debug_clients.fd_list, 1221 );
	debugFree( debug_clients.mutex, 1222 );
	debugFree( debug_clients.clients_num, 1223 );

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
leaq 0xafe9(%rip), %rcx      # 0x1b2a0
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x103b9
leaq 0xb11f(%rip), %rax      # 0x1b3e8
movq 0x8(%rax), %rax
movsbq -0x1(%rbp), %rcx
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x10371
leaq 0xb102(%rip), %rax      # 0x1b3e8
movq (%rax), %rax
movsbq -0x1(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
leaq 0xb0d9(%rip), %rcx      # 0x1b3e8
movq (%rcx), %rcx
movsbq -0x1(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x1036f
leaq 0xb0c4(%rip), %rax      # 0x1b3e8
movq (%rax), %rax
movsbq -0x1(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
leaq 0xb0ad(%rip), %rax      # 0x1b3e8
movq (%rax), %rax
movsbq -0x1(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x6ed0
movq -0x10(%rbp), %rdi
movl $0x4c2, %esi            # imm = 0x4C2
callq 0x7720
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10304
jmp 0x10371
leaq 0xb070(%rip), %rax      # 0x1b3e8
movq (%rax), %rax
movsbq -0x1(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x4c3, %esi            # imm = 0x4C3
callq 0x7720
leaq 0xb053(%rip), %rax      # 0x1b3e8
movq 0x10(%rax), %rax
movsbq -0x1(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0x4c4, %esi            # imm = 0x4C4
callq 0x7720
movb -0x1(%rbp), %al
addb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x102ac
leaq 0xb028(%rip), %rax      # 0x1b3e8
movq (%rax), %rdi
movl $0x4c5, %esi            # imm = 0x4C5
callq 0x7720
leaq 0xb014(%rip), %rax      # 0x1b3e8
movq 0x10(%rax), %rdi
movl $0x4c6, %esi            # imm = 0x4C6
callq 0x7720
leaq 0xafff(%rip), %rax      # 0x1b3e8
movq 0x8(%rax), %rdi
movl $0x4c7, %esi            # imm = 0x4C7
callq 0x7720
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/posix.c
// Function: main
int main(int argc, char *argv[])
{
	int8_t res;

	/* check if user is root */
	if ((getuid()) || (getgid())) {
		fprintf(stderr, "Error - you must be root to run '%s' !\n", argv[0]);
		exit(EXIT_FAILURE);
	}


	INIT_LIST_HEAD_FIRST(forw_list);
	INIT_LIST_HEAD_FIRST(gw_list);
	INIT_LIST_HEAD_FIRST(if_list);

	hna_init();

	/* save start value */
	system_tick = (float)sysconf(_SC_CLK_TCK);
	last_clock_tick = times_wrapper();
	update_internal_clock();

	apply_init_args(argc, argv);

	init_bh_ports();

	srand(getpid());

	res = batman();

	/* cleaning up */
	hna_free();

	restore_defaults();
	cleanup();
	checkLeak();
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2140
cmpl $0x0, %eax
jne 0x1042a
callq 0x22e0
cmpl $0x0, %eax
je 0x10453
movq 0xabbf(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x715b(%rip), %rsi      # 0x1759d
movb $0x0, %al
callq 0x22a0
movl $0x1, %edi
callq 0x2470
leaq 0xaf7e(%rip), %rax      # 0x1b3d8
movq %rax, (%rax)
leaq 0xaf74(%rip), %rax      # 0x1b3d8
movq %rax, 0x8(%rax)
leaq 0xaf51(%rip), %rax      # 0x1b3c0
movq %rax, (%rax)
leaq 0xaf47(%rip), %rax      # 0x1b3c0
movq %rax, 0x8(%rax)
leaq 0xaf2c(%rip), %rax      # 0x1b3b0
movq %rax, (%rax)
leaq 0xaf22(%rip), %rax      # 0x1b3b0
movq %rax, 0x8(%rax)
callq 0x8a60
movl $0x2, %edi
callq 0x2420
cvtsi2ss %rax, %xmm0
movss %xmm0, 0xb2aa(%rip)     # 0x1b758
callq 0x10510
movq %rax, 0xb2a6(%rip)      # 0x1b760
callq 0xf300
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xcb90
callq 0x10580
callq 0x2100
movl %eax, %edi
callq 0x2260
callq 0x3780
movb %al, -0x11(%rbp)
callq 0xa2c0
callq 0xffb0
callq 0x102a0
callq 0x71c0
movsbl -0x11(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/open-mesh-mirror[P]batmand/posix/tunnel.c
// Function: choose_vip
static int choose_vip(void *data, int32_t size)
{
	unsigned char *key= data;
	uint32_t hash = 0;
	size_t i;

	for (i = 4; i < 8; i++) {
		hash += key[i];
		hash += (hash << 10);
		hash ^= (hash >> 6);
	}

	hash += (hash << 3);
	hash ^= (hash >> 11);
	hash += (hash << 15);

	return (hash%size);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x4, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x121a1
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll $0xa, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x6, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12162
movl -0x1c(%rbp), %eax
shll $0x3, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl $0xb, %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll $0xf, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/example.c
// Function: main
int main(int argc, char **argv)
{
   if (argc != 2) {
      fprintf(stderr, "Usage: %s <sentence>\n", *argv);
      return EXIT_FAILURE;
   }

   /* Prepare ourselves for processing. */
   struct mascara *mr;
   int ret = mr_alloc(&mr, "en fsm", MR_SENTENCE);
   if (ret) {
      fprintf(stderr, "cannot create tokenizer: %s\n", mr_strerror(ret));
      return EXIT_FAILURE;
   }
   struct gourgandine *gn = gn_alloc();

   /* Tokenize the string at argv[1]. */
   struct mr_token *sent;
   size_t sent_len;
   mr_set_text(mr, argv[1], strlen(argv[1]));
   while ((sent_len = mr_next(mr, &sent))) {
      /* Iterate over all acronym definitions in this sentence. */
      struct gn_acronym acr = {0};
      while (gn_search(gn, sent, sent_len, &acr))
         printf("%s\t%s\n", acr.acronym, acr.expansion);
   }

   mr_dealloc(mr);
   gn_dealloc(gn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x233a
movq 0x117ce2(%rip), %rax    # 0x119ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xfcdd(%rip), %rsi      # 0x12004
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x2442
leaq -0x18(%rbp), %rdi
leaq 0xfcd5(%rip), %rsi      # 0x1201a
movl $0x1, %edx
callq 0x3e70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x238f
movq 0x117c99(%rip), %rax    # 0x119ff8
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movl -0x1c(%rbp), %edi
callq 0x3df0
movq -0x80(%rbp), %rdi
movq %rax, %rdx
leaq 0xfca5(%rip), %rsi      # 0x12021
movb $0x0, %al
callq 0x2160
movl $0x1, -0x4(%rbp)
jmp 0x2442
callq 0x2ac0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x20a0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x43b0
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4450
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2430
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2100
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x2450
cmpl $0x0, %eax
je 0x242e
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq 0xfc19(%rip), %rdi      # 0x1203e
movb $0x0, %al
callq 0x20c0
jmp 0x23fc
jmp 0x23d5
movq -0x18(%rbp), %rdi
callq 0x4480
movq -0x28(%rbp), %rdi
callq 0x2b90
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/src/lib/utf8proc.c
// Function: utf8proc_errmsg
UTF8PROC_DLLEXPORT const char *utf8proc_errmsg(utf8proc_ssize_t errcode) {
  switch (errcode) {
    case UTF8PROC_ERROR_NOMEM:
    return "Memory for processing UTF-8 data could not be allocated.";
    case UTF8PROC_ERROR_OVERFLOW:
    return "UTF-8 string is too long to be processed.";
    case UTF8PROC_ERROR_INVALIDUTF8:
    return "Invalid UTF-8 string";
    case UTF8PROC_ERROR_NOTASSIGNED:
    return "Unassigned Unicode code point found in UTF-8 string.";
    case UTF8PROC_ERROR_INVALIDOPTS:
    return "Invalid options for UTF-8 processing chosen.";
    default:
    return "An unknown error occurred while processing UTF-8 data.";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0xf82f
movq -0x18(%rbp), %rax
leaq 0x917cb(%rip), %rcx     # 0xa0fb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1065ab(%rip), %rax    # 0x115da0
movq %rax, -0x8(%rbp)
jmp 0xf83a
leaq 0x1065d7(%rip), %rax    # 0x115dd9
movq %rax, -0x8(%rbp)
jmp 0xf83a
leaq 0x1065f4(%rip), %rax    # 0x115e03
movq %rax, -0x8(%rbp)
jmp 0xf83a
leaq 0x1065fc(%rip), %rax    # 0x115e18
movq %rax, -0x8(%rbp)
jmp 0xf83a
leaq 0x106624(%rip), %rax    # 0x115e4d
movq %rax, -0x8(%rbp)
jmp 0xf83a
leaq 0x106644(%rip), %rax    # 0x115e7a
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/src/lib/utf8proc.c
// Function: utf8proc_encode_char
UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) {
  if (uc < 0x00) {
    return 0;
  } else if (uc < 0x80) {
    dst[0] = uc;
    return 1;
  } else if (uc < 0x800) {
    dst[0] = 0xC0 + (uc >> 6);
    dst[1] = 0x80 + (uc & 0x3F);
    return 2;
  // Note: we allow encoding 0xd800-0xdfff here, so as not to change
  // the API, however, these are actually invalid in UTF-8
  } else if (uc < 0x10000) {
    dst[0] = 0xE0 + (uc >> 12);
    dst[1] = 0x80 + ((uc >> 6) & 0x3F);
    dst[2] = 0x80 + (uc & 0x3F);
    return 3;
  } else if (uc < 0x110000) {
    dst[0] = 0xF0 + (uc >> 18);
    dst[1] = 0x80 + ((uc >> 12) & 0x3F);
    dst[2] = 0x80 + ((uc >> 6) & 0x3F);
    dst[3] = 0x80 + (uc & 0x3F);
    return 4;
  } else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xfb4e
movq $0x0, -0x8(%rbp)
jmp 0xfc6d
cmpl $0x80, -0xc(%rbp)
jge 0xfb6f
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0xfc6d
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jge 0xfbac
movl -0xc(%rbp), %eax
sarl $0x6, %eax
addl $0xc0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq $0x2, -0x8(%rbp)
jmp 0xfc6d
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0xfbfd
movl -0xc(%rbp), %eax
sarl $0xc, %eax
addl $0xe0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq $0x3, -0x8(%rbp)
jmp 0xfc6d
cmpl $0x110000, -0xc(%rbp)   # imm = 0x110000
jge 0xfc65
movl -0xc(%rbp), %eax
sarl $0x12, %eax
addl $0xf0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq $0x4, -0x8(%rbp)
jmp 0xfc6d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/src/lib/utf8proc.c
// Function: unsafe_get_property
static const utf8proc_property_t *unsafe_get_property(utf8proc_int32_t uc) {
  /* ASSERT: uc >= 0 && uc < 0x110000 */
  return utf8proc_properties + (
    utf8proc_stage2table[
      utf8proc_stage1table[uc >> 8] + (uc & 0xFF)
    ]
  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
sarl $0x8, %eax
movslq %eax, %rcx
leaq 0x9d5b9(%rip), %rax     # 0xad290
movzwl (%rax,%rcx,2), %eax
movl -0x4(%rbp), %ecx
andl $0xff, %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x9f7a0(%rip), %rax     # 0xaf490
movzwl (%rax,%rcx,2), %eax
movslq %eax, %rcx
leaq 0xb1d92(%rip), %rax     # 0xc1a90
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/src/lib/utf8proc.c
// Function: grapheme_break
static utf8proc_bool grapheme_break(int lbc, int tbc) {
  return
    (lbc == UTF8PROC_BOUNDCLASS_START) ? true :
    (lbc == UTF8PROC_BOUNDCLASS_CR &&
     tbc == UTF8PROC_BOUNDCLASS_LF) ? false :
    (lbc >= UTF8PROC_BOUNDCLASS_CR && lbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true :
    (tbc >= UTF8PROC_BOUNDCLASS_CR && tbc <= UTF8PROC_BOUNDCLASS_CONTROL) ? true :
    (tbc == UTF8PROC_BOUNDCLASS_EXTEND) ? false :
    (lbc == UTF8PROC_BOUNDCLASS_L &&
     (tbc == UTF8PROC_BOUNDCLASS_L ||
      tbc == UTF8PROC_BOUNDCLASS_V ||
      tbc == UTF8PROC_BOUNDCLASS_LV ||
      tbc == UTF8PROC_BOUNDCLASS_LVT)) ? false :
    ((lbc == UTF8PROC_BOUNDCLASS_LV ||
      lbc == UTF8PROC_BOUNDCLASS_V) &&
     (tbc == UTF8PROC_BOUNDCLASS_V ||
      tbc == UTF8PROC_BOUNDCLASS_T)) ? false :
    ((lbc == UTF8PROC_BOUNDCLASS_LVT ||
      lbc == UTF8PROC_BOUNDCLASS_T) &&
     tbc == UTF8PROC_BOUNDCLASS_T) ? false :
    (lbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR &&
     tbc == UTF8PROC_BOUNDCLASS_REGIONAL_INDICATOR) ? false :
    (tbc != UTF8PROC_BOUNDCLASS_SPACINGMARK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xfd7d
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfe84
cmpl $0x2, -0x4(%rbp)
jne 0xfd93
cmpl $0x3, -0x8(%rbp)
jne 0xfd93
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0xfe7e
cmpl $0x2, -0x4(%rbp)
jl 0xfdac
cmpl $0x4, -0x4(%rbp)
jg 0xfdac
movl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfe78
cmpl $0x2, -0x8(%rbp)
jl 0xfdc5
cmpl $0x4, -0x8(%rbp)
jg 0xfdc5
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xfe72
cmpl $0x5, -0x8(%rbp)
jne 0xfdd5
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfe6c
cmpl $0x6, -0x4(%rbp)
jne 0xfdfa
cmpl $0x6, -0x8(%rbp)
je 0xfdf3
cmpl $0x7, -0x8(%rbp)
je 0xfdf3
cmpl $0x9, -0x8(%rbp)
je 0xfdf3
cmpl $0xa, -0x8(%rbp)
jne 0xfdfa
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xfe66
cmpl $0x9, -0x4(%rbp)
je 0xfe06
cmpl $0x7, -0x4(%rbp)
jne 0xfe19
cmpl $0x7, -0x8(%rbp)
je 0xfe12
cmpl $0x8, -0x8(%rbp)
jne 0xfe19
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xfe60
cmpl $0xa, -0x4(%rbp)
je 0xfe25
cmpl $0x8, -0x4(%rbp)
jne 0xfe32
cmpl $0x8, -0x8(%rbp)
jne 0xfe32
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0xfe5a
cmpl $0xb, -0x4(%rbp)
jne 0xfe45
cmpl $0xb, -0x8(%rbp)
jne 0xfe45
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xfe54
cmpl $0xc, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/src/lib/utf8proc.c
// Function: unsafe_encode_char
static utf8proc_ssize_t unsafe_encode_char(utf8proc_int32_t uc, utf8proc_uint8_t *dst) {
   if (uc < 0x00) {
      return 0;
   } else if (uc < 0x80) {
      dst[0] = uc;
      return 1;
   } else if (uc < 0x800) {
      dst[0] = 0xC0 + (uc >> 6);
      dst[1] = 0x80 + (uc & 0x3F);
      return 2;
   } else if (uc == 0xFFFF) {
       dst[0] = 0xFF;
       return 1;
   } else if (uc == 0xFFFE) {
       dst[0] = 0xFE;
       return 1;
   } else if (uc < 0x10000) {
      dst[0] = 0xE0 + (uc >> 12);
      dst[1] = 0x80 + ((uc >> 6) & 0x3F);
      dst[2] = 0x80 + (uc & 0x3F);
      return 3;
   } else if (uc < 0x110000) {
      dst[0] = 0xF0 + (uc >> 18);
      dst[1] = 0x80 + ((uc >> 12) & 0x3F);
      dst[2] = 0x80 + ((uc >> 6) & 0x3F);
      dst[3] = 0x80 + (uc & 0x3F);
      return 4;
   } else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x10f4e
movq $0x0, -0x8(%rbp)
jmp 0x110a7
cmpl $0x80, -0xc(%rbp)
jge 0x10f6f
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x110a7
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jge 0x10fac
movl -0xc(%rbp), %eax
sarl $0x6, %eax
addl $0xc0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq $0x2, -0x8(%rbp)
jmp 0x110a7
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jne 0x10fc9
movq -0x18(%rbp), %rax
movb $-0x1, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x110a7
cmpl $0xfffe, -0xc(%rbp)     # imm = 0xFFFE
jne 0x10fe6
movq -0x18(%rbp), %rax
movb $-0x2, (%rax)
movq $0x1, -0x8(%rbp)
jmp 0x110a7
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jge 0x11037
movl -0xc(%rbp), %eax
sarl $0xc, %eax
addl $0xe0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq $0x3, -0x8(%rbp)
jmp 0x110a7
cmpl $0x110000, -0xc(%rbp)   # imm = 0x110000
jge 0x1109f
movl -0xc(%rbp), %eax
sarl $0x12, %eax
addl $0xf0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
addl $0x80, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
movq $0x4, -0x8(%rbp)
jmp 0x110a7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/michaelnmmeyer[P]gourgandine/src/lib/utf8proc.c
// Function: utf8proc_map
UTF8PROC_DLLEXPORT utf8proc_ssize_t utf8proc_map(
  const utf8proc_uint8_t *str, utf8proc_ssize_t strlen, utf8proc_uint8_t **dstptr, utf8proc_option_t options
) {
  utf8proc_int32_t *buffer;
  utf8proc_ssize_t result;
  *dstptr = NULL;
  result = utf8proc_decompose(str, strlen, NULL, 0, options);
  if (result < 0) return result;
  buffer = (utf8proc_int32_t *) malloc(result * sizeof(utf8proc_int32_t) + 1);
  if (!buffer) return UTF8PROC_ERROR_NOMEM;
  result = utf8proc_decompose(str, strlen, buffer, result, options);
  if (result < 0) {
    free(buffer);
    return result;
  }
  result = utf8proc_reencode(buffer, result, options);
  if (result < 0) {
    free(buffer);
    return result;
  }
  {
    utf8proc_int32_t *newptr;
    newptr = (utf8proc_int32_t *) realloc(buffer, (size_t)result+1);
    if (newptr) buffer = newptr;
  }
  *dstptr = (utf8proc_uint8_t *)buffer;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %r8d
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x10740
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x11102
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x111c7
movq -0x38(%rbp), %rdi
shlq $0x2, %rdi
addq $0x1, %rdi
callq 0x2190
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1112b
movq $-0x1, -0x8(%rbp)
jmp 0x111c7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x10740
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x11162
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x111c7
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x10a20
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x11190
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x111c7
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x1, %rsi
callq 0x21b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x111b4
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/cwm.c
// Function: main
int
main(int argc, char **argv)
{
	const char	*conf_file = NULL;
	char		*display_name = NULL;
	int		 ch;

	if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
		warnx("no locale support");
	mbtowc(NULL, NULL, MB_CUR_MAX);

	cwm_argv = argv;
	while ((ch = getopt(argc, argv, "c:d:")) != -1) {
		switch (ch) {
		case 'c':
			conf_file = optarg;
			break;
		case 'd':
			display_name = optarg;
			break;
		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	if (signal(SIGCHLD, sigchld_cb) == SIG_ERR)
		err(1, "signal");

	dpy_init(display_name);

	bzero(&Conf, sizeof(Conf));
	conf_setup(&Conf, conf_file);
	xu_getatoms();
	x_setup();

	xev_loop();

	x_teardown();

	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %edi, %edi
leaq 0xe928(%rip), %rsi      # 0x14317
callq 0x57e0
cmpq $0x0, %rax
je 0x5a04
callq 0x52d0
cmpl $0x0, %eax
jne 0x5a12
leaq 0xe5f9(%rip), %rdi      # 0x14004
movb $0x0, %al
callq 0x5140
callq 0x5370
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x5080
movq -0x10(%rbp), %rax
movq %rax, 0x14c87(%rip)     # 0x1a6b8
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xe5d7(%rip), %rdx      # 0x14016
callq 0x51c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
je 0x5a8a
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x63, %eax
je 0x5a63
jmp 0x5a59
movl -0x28(%rbp), %eax
subl $0x64, %eax
je 0x5a73
jmp 0x5a83
movq 0x1356e(%rip), %rax     # 0x18fd8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5a88
movq 0x1355e(%rip), %rax     # 0x18fd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5a88
callq 0x5b30
jmp 0x5a31
movq 0x1352f(%rip), %rax     # 0x18fc0
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0x1351e(%rip), %rax     # 0x18fc0
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x11, %edi
leaq 0x9e(%rip), %rsi        # 0x5b60
callq 0x5500
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x5ae6
movl $0x1, %edi
leaq 0xe53c(%rip), %rsi      # 0x1401b
movb $0x0, %al
callq 0x54b0
movq -0x20(%rbp), %rdi
callq 0x5be0
leaq 0x14bca(%rip), %rdi     # 0x1a6c0
xorl %esi, %esi
movl $0x20e8, %edx           # imm = 0x20E8
callq 0x5090
movq -0x18(%rbp), %rsi
leaq 0x14bb3(%rip), %rdi     # 0x1a6c0
callq 0xc600
callq 0xb230
callq 0x5cb0
callq 0xd5f0
callq 0x5de0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/cwm.c
// Function: usage
__dead void
usage(void)
{
	extern char	*__progname;

	(void)fprintf(stderr, "usage: %s [-c file] [-d display]\n",
	    __progname);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x134ad(%rip), %rax     # 0x18fe8
movq (%rax), %rdi
movq 0x1349b(%rip), %rax     # 0x18fe0
movq (%rax), %rdx
leaq 0xe4d3(%rip), %rsi      # 0x14022
movb $0x0, %al
callq 0x5820
movl $0x1, %edi
callq 0x5180
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/cwm.c
// Function: sigchld_cb
static void
sigchld_cb(int which)
{
	pid_t	 pid;
	int	 save_errno = errno;
	int	 status;

	/* Collect dead children. */
	while ((pid = waitpid(-1, &status, WNOHANG)) > 0 ||
	    (pid < 0 && errno == EINTR))
		;

	errno = save_errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x5580
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x5530
movl %eax, %ecx
movl %ecx, -0x8(%rbp)
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jg 0x5bb6
xorl %eax, %eax
cmpl $0x0, -0x8(%rbp)
movb %al, -0x12(%rbp)
jge 0x5bb0
callq 0x5580
cmpl $0x4, (%rax)
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5bbf
jmp 0x5bc1
jmp 0x5b75
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x5580
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenlinux[P]cwm/cwm.c
// Function: dpy_init
static void
dpy_init(const char *dpyname)
{
	int	i;

	XSetErrorHandler(x_errorhandler);

	if ((X_Dpy = XOpenDisplay(dpyname)) == NULL)
		errx(1, "unable to open display \"%s\"",
		    XDisplayName(dpyname));

	XSetErrorHandler(x_wmerrorhandler);
	XSelectInput(X_Dpy, DefaultRootWindow(X_Dpy), SubstructureRedirectMask);
	XSync(X_Dpy, False);
	XSetErrorHandler(x_errorhandler);

	HasRandr = XRRQueryExtension(X_Dpy, &Randr_ev, &i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x23d(%rip), %rdi       # 0x5e30
callq 0x5770
movq -0x8(%rbp), %rdi
callq 0x52b0
movq %rax, 0x16ba0(%rip)     # 0x1c7a8
cmpq $0x0, %rax
jne 0x5c2d
movq -0x8(%rbp), %rdi
callq 0x5430
movq %rax, %rdx
movl $0x1, %edi
leaq 0xe41e(%rip), %rsi      # 0x14044
movb $0x0, %al
callq 0x56f0
leaq 0x20c(%rip), %rdi       # 0x5e40
callq 0x5770
movq 0x16b68(%rip), %rdi     # 0x1c7a8
movq 0x16b61(%rip), %rax     # 0x1c7a8
movq 0xe8(%rax), %rax
movq 0x16b53(%rip), %rcx     # 0x1c7a8
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x5560
movq 0x16b30(%rip), %rdi     # 0x1c7a8
xorl %esi, %esi
callq 0x55b0
leaq 0x1aa(%rip), %rdi       # 0x5e30
callq 0x5770
movq 0x16b16(%rip), %rdi     # 0x1c7a8
leaq 0x16b43(%rip), %rsi     # 0x1c7dc
leaq -0xc(%rbp), %rdx
callq 0x5240
movl %eax, 0x16b30(%rip)     # 0x1c7d8
addq $0x10, %rsp
popq %rbp
retq
nop