LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/S01den[P]Lost_CavernRL/menu.c
// Function: popUpArchitect
void popUpArchitect()
{
	WINDOW *win;
	win = newwin(5,30,rand()%LONGUEUR,rand()%LARGEUR);
	box(win,0,0);
	int color = rand()%255+1;
	wattron(win, COLOR_PAIR(color));
	mvwprintw(win,1,1,"PFL TRE'K VJTRGV !");
	mvwprintw(win,2,1,"JKFG");
	mvwprintw(win,3,1,"**WE ALREADY WON**");
	if(rand()%100 > 50)
		mvwprintw(win,4,1,"THEY PAID A LOT FOR THIS WEAPON...");
	wattroff(win, COLOR_PAIR(color));
	box(win, ' ', ' ');
	wborder(win, ' ', ' ', ' ',' ',' ',' ',' ',' ');
	wclear(win);
	wrefresh(win);
	delwin(win);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x11d0
movslq %eax, %rbx
imulq $-0x2df2df2d, %rbx, %rax # imm = 0xD20D20D3
shrq $0x20, %rax
addl %ebx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
imull $0x27, %eax, %eax
subl %eax, %ebx
callq 0x11d0
movslq %eax, %rcx
imulq $0x7e07e07f, %rcx, %rax # imm = 0x7E07E07F
movq %rax, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rax
sarl $0x6, %eax
addl %edx, %eax
movl %eax, %edx
shll $0x7, %edx
leal (%rdx,%rax,2), %eax
subl %eax, %ecx
movl $0x5, %edi
movl $0x1e, %esi
movl %ebx, %edx
callq 0x1130
movq %rax, %rbx
subq $0x8, %rsp
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %r14
pushq %r14
callq 0x1120
addq $0x20, %rsp
callq 0x11d0
cltq
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
shrl $0x7, %ecx
addl %edx, %ecx
addl %eax, %ecx
shll $0x8, %ecx
addl $0x100, %ecx            # imm = 0x100
movzwl %cx, %ebp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x11c0
leaq 0x642e(%rip), %rcx      # 0x10e88
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x1070
leaq 0x6426(%rip), %rcx      # 0x10e9b
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x1070
leaq 0x6410(%rip), %rcx      # 0x10ea0
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x1070
callq 0x11d0
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cmpl $0x33, %eax
jl 0xaae4
leaq 0x63e3(%rip), %rcx      # 0x10eb3
movq %rbx, %rdi
movl $0x4, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x1060
subq $0x8, %rsp
movl $0x20, %r15d
movq %rbx, %rdi
movl $0x20, %esi
movl $0x20, %edx
movl $0x20, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r14
pushq %r14
pushq %r14
callq 0x1120
addq $0x18, %rsp
movq %rbx, %rdi
movl $0x20, %esi
movl $0x20, %edx
movl $0x20, %ecx
movl $0x20, %r8d
movl $0x20, %r9d
pushq %r15
pushq %r15
pushq %r15
callq 0x1120
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/S01den[P]Lost_CavernRL/player.c
// Function: hitEnnemy
int hitEnnemy(Player player, Ennemy *ennemy, Weapons weaponHold, int *components, int *blood)
{
	int ret = 0;
	if(rand()%100 < 100-player.hate)
	{
		if(weaponHold.type == 0)
			ennemy->life -= abs(weaponHold.degat+(int)(player.strength/2));
	}
	else
	{
		ret = 2;
		ennemy->life -= weaponHold.degat*(int)(player.hate/2);
	}
	if(ennemy->life <= 0)
	{
		ret = 1;
		if(ennemy->type == 1)
		{
			int compWin = rand()%10+5;
			*components += compWin;	
		}
		else if(ennemy->type == 2)
		{
			int compWin = rand()%15+7;
			*components += compWin;	
		}
		else if(ennemy->type == 3 || ennemy->type == 4)
		{
			*blood += rand()%10+5;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x70(%rsp), %r12
callq 0x11d0
movslq %eax, %rcx
imulq $0x51eb851f, %rcx, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %eax
subl %eax, %ecx
movl 0x58(%rsp), %eax
movl $0x64, %edx
subl %eax, %edx
cmpl %edx, %ecx
jge 0xbbbd
xorl %ebp, %ebp
cmpl $0x0, 0x24(%r12)
jne 0xbbd7
leaq 0x30(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl 0x10(%r12), %ecx
movl %ecx, %eax
negl %eax
cmovnsl %ecx, %eax
addl %eax, 0x8(%r15)
jmp 0xbbd7
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
negl %ecx
imull 0x10(%r12), %ecx
addl %ecx, 0x8(%r15)
movl $0x2, %ebp
cmpl $0x0, 0x8(%r15)
jg 0xbc24
movl 0x20(%r15), %eax
movl $0x5, %r15d
movl $0xa, %r12d
movl $0x1, %ebp
leal -0x3(%rax), %ecx
cmpl $0x2, %ecx
jb 0xbc13
cmpl $0x1, %eax
je 0xbc16
cmpl $0x2, %eax
jne 0xbc24
movl $0x7, %r15d
movl $0xf, %r12d
jmp 0xbc16
movq %r14, %rbx
callq 0x11d0
cltd
idivl %r12d
addl %r15d, %edx
addl %edx, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/S01den[P]Lost_CavernRL/player.c
// Function: crystalCanon
void crystalCanon(Map map[LONGUEUR][LARGEUR], Player player, char dir)
{

		int x, y = 0;
		int posX = player.x;
		int posY = player.y;

		switch(dir)
		{
			case 'z':
				x = -1;
				y = 0;
				break;
			case 's':
				x = 1;
				y = 0;
				break;
			case 'q':
				x = 0;
				y = -1;
				break;
			case 'd':
				x = 0;
				y = 1;
				break;
			case 'a':
				x = -1;
				y = -1;
				break;
			case 'e':
				x = -1;
				y = 1;
				break;
			case 'w':
				x = 1;
				y = -1;
				break;
			case 'x':
				x = 1;
				y = 1;
				break;
		}

		while(posX < LONGUEUR && posX > 0 && posY > 0 && posY < LARGEUR)
		{
			map[posX][posY].content = FLOOR;
			posX += x;
			posY += y;
		}
}

// Assembly:
pushq %rbx
movl 0x24(%rsp), %eax
movl 0x28(%rsp), %ecx
xorl %edx, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
cmpl $0x70, %esi
jle 0xc1d0
addl $-0x71, %esi
cmpl $0x7, %esi
ja 0xc210
leaq 0x50a4(%rip), %r9       # 0x11264
movslq (%r9,%rsi,4), %rsi
addq %r9, %rsi
jmpq *%rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0xc20d
cmpl $0x61, %esi
je 0xc1fb
cmpl $0x64, %esi
je 0xc208
cmpl $0x65, %esi
je 0xc1f4
jmp 0xc210
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %r8d
jmp 0xc210
movl $0x1, %r8d
movl $0x1, %edx
jmp 0xc210
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
jmp 0xc210
movl $0x1, %edx
xorl %r8d, %r8d
leal -0x1(%rax), %esi
cmpl $0x26, %esi
setb %sil
leal -0x1(%rcx), %r9d
cmpl $0x81, %r9d
setb %r9b
andb %sil, %r9b
cmpb $0x1, %r9b
jne 0xc278
leal -0x1(%rdx), %esi
leal -0x1(%r8), %r9d
movl %eax, %r10d
movl %ecx, %r11d
imulq $0xe38, %r10, %r10      # imm = 0xE38
addq %rdi, %r10
leaq (%r11,%r11,8), %rbx
leaq (%rbx,%rbx,2), %rbx
addq %r11, %rbx
movl $0x1, (%r10,%rbx)
leal (%r9,%rax), %r10d
cmpl $0x25, %r10d
ja 0xc278
addl %r8d, %eax
leal (%rsi,%rcx), %r10d
addl %edx, %ecx
cmpl $0x81, %r10d
jb 0xc239
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/S01den[P]Lost_CavernRL/pnj.c
// Function: testPnjOnPos
int testPnjOnPos(Pnj pnj[], int x, int y, int nbrPnj)
{
	int ret = -1;
	int i = 0;

	for(i = 0; i < nbrPnj; i++)
	{
		if(pnj[i].x == x && pnj[i].y == y)
		{
			ret = i;
			break;
		}
	}

	return ret;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0xc2df
movl %ecx, %ecx
addq $0x18, %rdi
xorl %r8d, %r8d
cmpl %esi, -0x4(%rdi)
jne 0xc2d3
cmpl %edx, (%rdi)
je 0xc2e0
incq %r8
addq $0x20, %rdi
cmpq %r8, %rcx
jne 0xc2ca
retq
movl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/S01den[P]Lost_CavernRL/screen.c
// Function: flashBomb
void flashBomb(WINDOW *win_map)
{
	int k = 0;
	int l = 0;
	
	for(k = 1; k < LONGUEUR-1; k++)
	{
		for(l = 1; l < LARGEUR-1; l++)
		{
			wattron(win_map,COLOR_PAIR(244));
			mvwprintw(win_map,k,l," ");
			wattroff(win_map,COLOR_PAIR(244));
		}
	}
	
	wrefresh(win_map);
	delay(15);
	for(k = 1; k < LONGUEUR-1; k++)
	{
		for(l = 1; l < LARGEUR-1; l++)
		{
			wattron(win_map,COLOR_BLACK);
			mvwprintw(win_map,k,l," ");
			wattroff(win_map,COLOR_BLACK);
		}
	}
	wrefresh(win_map);
	delay(9);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
leaq 0x1920(%rip), %r14      # 0xf1fe
movl $0x1, %r15d
movq %rbx, %rdi
movl $0xf400, %esi           # imm = 0xF400
xorl %edx, %edx
callq 0x11c0
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movl $0xf400, %esi           # imm = 0xF400
xorl %edx, %edx
callq 0x1060
incl %r15d
cmpl $0x81, %r15d
jne 0xd8e4
incl %ebp
cmpl $0x26, %ebp
jne 0xd8de
movq %rbx, %rdi
callq 0x1100
movl $0x1, %ebp
leaq 0x18c3(%rip), %r14      # 0xf1fe
movl $0x1, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11c0
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1060
incl %r15d
cmpl $0x81, %r15d
jne 0xd941
incl %ebp
cmpl $0x26, %ebp
jne 0xd93b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.6/mmap-read.c
// Function: main
int main (int argc, char* const argv[])
{
	int fd;
	void* file_memory;
	int integer;

	/*	Open the file */
	fd = open (argv[1], O_RDWR, S_IRUSR | S_IWUSR);
	/*	Create the memory mapping.	*/
	file_memory = mmap (0, FILE_LENGTH, PROT_READ | PROT_WRITE,
											MAP_SHARED, fd, 0);
	close (fd);
	/*	Read the integer, print ir out, and double it.	*/
	sscanf (file_memory, "%d\n", &integer);
	printf ("value: %d\n", integer);
	sprintf ((char*) file_memory, "%d\n", 2 * integer);
	/*	Release the memory (unnecessary because the program exits).	)*/
	munmap (file_memory, FILE_LENGTH);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdi
movl $0x2, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1080
movl %eax, %r14d
movl $0x100, %esi            # imm = 0x100
xorl %edi, %edi
movl $0x3, %edx
movl $0x1, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x1030
movq %rax, %rbx
movl %r14d, %edi
callq 0x1050
leaq 0xe1f(%rip), %r14       # 0x200b
leaq -0x1c(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1060
movl (%r15), %esi
leaq 0xdfa(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1040
movl (%r15), %edx
addl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1090
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: find_client
Client *find_client(Window w) {
	struct list *iter;

	for (iter = clients_tab_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (w == c->parent || w == c->window)
			return c;
	}
	return NULL;
}

// Assembly:
leaq 0x8de5(%rip), %rcx      # 0xc798
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x39dd
movq 0x8(%rcx), %rax
cmpq %rdi, 0x8(%rax)
jne 0x39c9
xorl %esi, %esi
jmp 0x39d4
cmpq %rdi, (%rax)
setne %sil
cmovneq %rdx, %rax
movq %rax, %rdx
testb %sil, %sil
jne 0x39b3
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: set_wm_state
void set_wm_state(Client *c, int state) {
	/* Using "long" for the type of "data" looks wrong, but the
	 * fine people in the X Consortium defined it this way
	 * (even on 64-bit machines).
	 */
	long data[2];
	data[0] = state;
	data[1] = None;
	XChangeProperty(dpy, c->window, xa_wm_state, xa_wm_state, 32,
			PropModeReplace, (unsigned char *)data, 2);
}

// Assembly:
subq $0x18, %rsp
movslq %esi, %rax
movq %rsp, %r10
movq %rax, (%r10)
movq $0x0, 0x8(%r10)
leaq 0x8d86(%rip), %rax      # 0xc7e0
movq (%rax), %rax
movq (%rdi), %rsi
leaq 0x8bc9(%rip), %rcx      # 0xc630
movq (%rcx), %rcx
movq %rax, %rdi
movq %rcx, %rdx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x2
pushq %r10
callq 0x3460
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: client_lower
void client_lower(Client *c) {
	struct list *iter;
	Client *below;
	Window order[2];
	/* Find lowest other client in stacking order that is visible on the
	 * same screen. */
	for (iter = clients_stacking_order; iter; iter = iter->next) {
		below = iter->data;
		if (below == c)
			return;
		if (below->screen == c->screen && (is_fixed(below) || below->vdesk == c->screen->vdesk))
			break;
	}
	if (!iter) return;
	order[0] = below->parent;
	order[1] = c->parent;
	XRestackWindows(dpy, order, 2);
	clients_stacking_order = list_delete(clients_stacking_order, c);
	clients_stacking_order = list_insert_before(clients_stacking_order, iter, c);
	ewmh_set_net_client_list_stacking(c->screen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8c74(%rip), %r15      # 0xc7a8
movq (%r15), %r14
testq %r14, %r14
sete %al
je 0x3b6c
movq 0x8(%r14), %rcx
cmpq %rbx, %rcx
je 0x3bbe
movq 0x10(%rbx), %rdx
cmpq %rdx, 0x10(%rcx)
jne 0x3b5f
movl 0x74(%rcx), %esi
cmpl $-0x1, %esi
je 0x3b6c
cmpl 0x40(%rdx), %esi
je 0x3b6c
movq (%r14), %r14
testq %r14, %r14
sete %al
jne 0x3b3f
jmp 0x3b6c
testb $0x1, %al
jne 0x3bbe
movq 0x8(%rcx), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsi)
leaq 0x8c57(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movl $0x2, %edx
callq 0x35a0
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5c1a
movq %rax, (%r15)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5b6c
movq %rax, (%r15)
movq 0x10(%rbx), %rdi
callq 0x588d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: send_config
void send_config(Client *c) {
	XConfigureEvent ce;

	ce.type = ConfigureNotify;
	ce.event = c->window;
	ce.window = c->window;
	ce.x = c->x;
	ce.y = c->y;
	ce.width = c->width;
	ce.height = c->height;
	ce.border_width = 0;
	ce.above = None;
	ce.override_redirect = False;

	XSendEvent(dpy, c->window, False, StructureNotifyMask, (XEvent *)&ce);
}

// Assembly:
subq $0x58, %rsp
movq %rsp, %r8
movl $0x16, (%r8)
movq (%rdi), %rsi
movq %rsi, 0x20(%r8)
movq %rsi, 0x28(%r8)
movl 0x24(%rdi), %eax
movl %eax, 0x30(%r8)
movl 0x28(%rdi), %eax
movl %eax, 0x34(%r8)
movl 0x2c(%rdi), %eax
movl %eax, 0x38(%r8)
movl 0x30(%rdi), %eax
movl %eax, 0x3c(%r8)
xorl %eax, %eax
movl %eax, 0x40(%r8)
movq $0x0, 0x48(%r8)
movl %eax, 0x50(%r8)
leaq 0x8bca(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movl $0x20000, %ecx          # imm = 0x20000
xorl %edx, %edx
callq 0x3050
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: gravitate_border
void gravitate_border(Client *c, int bw) {
	int dx = 0, dy = 0;
	switch (c->win_gravity) {
	default:
	case NorthWestGravity:
		dx = bw;
		dy = bw;
		break;
	case NorthGravity:
		dy = bw;
		break;
	case NorthEastGravity:
		dx = -bw;
		dy = bw;
		break;
	case EastGravity:
		dx = -bw;
		break;
	case CenterGravity:
		break;
	case WestGravity:
		dx = bw;
		break;
	case SouthWestGravity:
		dx = bw;
		dy = -bw;
		break;
	case SouthGravity:
		dy = -bw;
		break;
	case SouthEastGravity:
		dx = -bw;
		dy = -bw;
		break;
	}
	if (c->x != 0 || c->width != DisplayWidth(dpy, c->screen->screen)) {
		c->x += dx;
	}
	if (c->y != 0 || c->height != DisplayHeight(dpy, c->screen->screen)) {
		c->y += dy;
	}
}

// Assembly:
movl 0x6c(%rdi), %ecx
addl $-0x2, %ecx
cmpl $0x7, %ecx
ja 0x3c55
xorl %eax, %eax
leaq 0x53c6(%rip), %rdx      # 0x9004
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorl %eax, %eax
jmp 0x3c63
negl %esi
movl %esi, %eax
xorl %esi, %esi
jmp 0x3c63
negl %esi
movl %esi, %eax
jmp 0x3c63
movl %esi, %eax
negl %eax
jmp 0x3c63
movl %esi, %eax
negl %esi
movl 0x24(%rdi), %ecx
testl %ecx, %ecx
jne 0x3c90
movl 0x2c(%rdi), %edx
leaq 0x8b6c(%rip), %r8       # 0xc7e0
movq (%r8), %r8
movq 0xe8(%r8), %r8
movq 0x10(%rdi), %r9
movslq (%r9), %r9
shlq $0x7, %r9
cmpl 0x18(%r8,%r9), %edx
je 0x3c95
addl %eax, %ecx
movl %ecx, 0x24(%rdi)
movl 0x28(%rdi), %eax
testl %eax, %eax
jne 0x3cc2
movl 0x30(%rdi), %ecx
leaq 0x8b3a(%rip), %rdx      # 0xc7e0
movq (%rdx), %rdx
movq 0xe8(%rdx), %rdx
movq 0x10(%rdi), %r8
movslq (%r8), %r8
shlq $0x7, %r8
cmpl 0x1c(%rdx,%r8), %ecx
je 0x3cc7
addl %esi, %eax
movl %eax, 0x28(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: select_client
void select_client(Client *c) {
	if (current)
		XSetWindowBorder(dpy, current->parent, current->screen->bg.pixel);
	if (c) {
		unsigned long bpixel;
#ifdef VWM
		if (is_fixed(c))
			bpixel = c->screen->fc.pixel;
		else
#endif
			bpixel = c->screen->fg.pixel;
		XSetWindowBorder(dpy, c->parent, bpixel);
		XInstallColormap(dpy, c->cmap);
		XSetInputFocus(dpy, c->window, RevertToPointerRoot, CurrentTime);
	}
	current = c;
	ewmh_set_net_active_window(c);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8ad9(%rip), %r14      # 0xc7b0
movq (%r14), %rax
testq %rax, %rax
je 0x3cfa
leaq 0x8afa(%rip), %rcx      # 0xc7e0
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rax
movq 0x30(%rax), %rdx
callq 0x3350
testq %rbx, %rbx
je 0x3d4a
cmpl $-0x1, 0x74(%rbx)
movq 0x8(%rbx), %rsi
movl $0x48, %eax
movl $0x20, %ecx
cmoveq %rax, %rcx
movq 0x10(%rbx), %rax
movq (%rax,%rcx), %rdx
leaq 0x8abc(%rip), %r15      # 0xc7e0
movq (%r15), %rdi
callq 0x3350
movq (%r15), %rdi
movq 0x18(%rbx), %rsi
callq 0x36d0
movq (%r15), %rdi
movq (%rbx), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3710
movq %rbx, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5934
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: client_to_vdesk
void client_to_vdesk(Client *c, unsigned int vdesk) {
	if (valid_vdesk(vdesk)) {
		c->vdesk = vdesk;
		if (c->vdesk == c->screen->vdesk || c->vdesk == VDESK_FIXED) {
			client_show(c);
		} else {
			client_hide(c);
		}
		ewmh_set_net_wm_desktop(c);
		select_client(current);
	}
}

// Assembly:
leal 0x1(%rsi), %eax
cmpl $0x8, %eax
ja 0x3d81
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x74(%rdi)
cmpl $-0x1, %esi
je 0x3d82
movq 0x10(%rbx), %rax
cmpl %esi, 0x40(%rax)
je 0x3d82
movq %rbx, %rdi
callq 0x39e0
jmp 0x3d8a
retq
movq %rbx, %rdi
callq 0x3a87
movq %rbx, %rdi
callq 0x59d6
leaq 0x8a17(%rip), %rax      # 0xc7b0
movq (%rax), %rdi
popq %rbx
jmp 0x3cc8
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: send_wm_delete
void send_wm_delete(Client *c, int kill_client) {
	int i, n, found = 0;
	Atom *protocols;

	if (!kill_client && XGetWMProtocols(dpy, c->window, &protocols, &n)) {
		for (i = 0; i < n; i++)
			if (protocols[i] == xa_wm_delete)
				found++;
		XFree(protocols);
	}
	if (found)
		send_xmessage(c->window, xa_wm_protos, xa_wm_delete);
	else
		XKillClient(dpy, c->window);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x3f52
leaq 0x88a7(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq (%rbx), %rsi
callq 0x3180
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8887(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0x3500
testl %eax, %eax
je 0x3f32
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rdi
testq %rax, %rax
jle 0x3ffa
leaq 0x86b8(%rip), %r15      # 0xc640
movq (%r15), %rcx
xorl %edx, %edx
xorl %ebp, %ebp
xorl %esi, %esi
cmpq %rcx, (%rdi,%rdx,8)
sete %sil
addl %esi, %ebp
incq %rdx
cmpq %rdx, %rax
jne 0x3f8f
movq 0x10(%rsp), %rdi
callq 0x3210
testl %ebp, %ebp
je 0x3f32
movq (%rbx), %rsi
leaq 0x867d(%rip), %rax      # 0xc638
movq (%rax), %rax
movq (%r15), %rcx
leaq 0x18(%rsp), %r8
movl $0x21, (%r8)
movq %rsi, 0x20(%r8)
movq %rax, 0x28(%r8)
movl $0x20, 0x30(%r8)
movq %rcx, 0x38(%r8)
movq $0x0, 0x40(%r8)
movq (%r14), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3050
jmp 0x3f44
callq 0x3210
jmp 0x3f32
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/client.c
// Function: set_shape
void set_shape(Client *c) {
	int bounding_shaped;
	int i, b;  unsigned int u;  /* dummies */

	if (!have_shape) return;
	/* Logic to decide if we have a shaped window cribbed from fvwm-2.5.10.
	 * Previous method (more than one rectangle returned from
	 * XShapeGetRectangles) worked _most_ of the time. */
	if (XShapeQueryExtents(dpy, c->window, &bounding_shaped, &i, &i,
				&u, &u, &b, &i, &i, &u, &u) && bounding_shaped) {
		LOG_DEBUG("%d shape extents\n", bounding_shaped);
		XShapeCombineShape(dpy, c->parent, ShapeBounding, 0, 0,
				c->window, ShapeBounding, ShapeSet);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x87fe(%rip), %rax      # 0xc810
cmpl $0x0, (%rax)
je 0x4079
movq %rdi, %rbx
leaq 0x87bf(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq (%rbx), %rsi
leaq 0xc(%rsp), %r9
leaq 0x14(%rsp), %rcx
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %rdx
movq %rcx, %r8
pushq %r9
pushq %r9
pushq %rcx
pushq %rcx
pushq %rax
pushq %r9
callq 0x31f0
addq $0x30, %rsp
testl %eax, %eax
je 0x4079
cmpl $0x0, 0x8(%rsp)
je 0x4079
movq (%r14), %rdi
movq (%rbx), %r9
movq 0x8(%rbx), %rsi
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %rax
callq 0x3540
addq $0x10, %rsp
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_deinit_screen
void ewmh_deinit_screen(ScreenInfo *s) {
	XDeleteProperty(dpy, s->root, xa_net_supported);
	XDeleteProperty(dpy, s->root, xa_net_client_list);
	XDeleteProperty(dpy, s->root, xa_net_client_list_stacking);
#ifdef VWM
	XDeleteProperty(dpy, s->root, xa_net_number_of_desktops);
#endif
	XDeleteProperty(dpy, s->root, xa_net_desktop_geometry);
	XDeleteProperty(dpy, s->root, xa_net_desktop_viewport);
#ifdef VWM
	XDeleteProperty(dpy, s->root, xa_net_current_desktop);
#endif
	XDeleteProperty(dpy, s->root, xa_net_active_window);
	XDeleteProperty(dpy, s->root, xa_net_workarea);
	XDeleteProperty(dpy, s->root, xa_net_supporting_wm_check);
	XDestroyWindow(dpy, s->supporting);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x71e6(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7060(%rip), %rdx      # 0xc668
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7055(%rip), %rdx      # 0xc670
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x704a(%rip), %rdx      # 0xc678
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x703f(%rip), %rdx      # 0xc680
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7034(%rip), %rdx      # 0xc688
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7029(%rip), %rdx      # 0xc690
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x701e(%rip), %rdx      # 0xc698
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7013(%rip), %rdx      # 0xc6a0
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x7008(%rip), %rdx      # 0xc6a8
callq 0x3230
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movq 0x6ffd(%rip), %rdx      # 0xc6b0
callq 0x3230
movq (%r14), %rdi
movq 0x10(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3300
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_init_client
void ewmh_init_client(Client *c) {
	Atom allowed_actions[] = {
		xa_net_wm_action_move,
		xa_net_wm_action_maximize_horz,
		xa_net_wm_action_maximize_vert,
		xa_net_wm_action_fullscreen,
		xa_net_wm_action_change_desktop,
		xa_net_wm_action_close,
		/* nelements reduced to omit this if not possible: */
		xa_net_wm_action_resize,
	};
	int nelements = sizeof(allowed_actions) / sizeof(Atom);
	/* Omit resize element if resizing not possible: */
	if (c->max_width && c->max_width == c->min_width
			&& c->max_height && c->max_height == c->min_height)
		nelements--;
	XChangeProperty(dpy, c->window, xa_net_wm_allowed_actions,
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&allowed_actions,
			nelements);
}

// Assembly:
subq $0x38, %rsp
movq 0x705a(%rip), %rax      # 0xc730
movq %rax, (%rsp)
movq 0x705f(%rip), %rax      # 0xc740
movq %rax, 0x8(%rsp)
movq 0x705b(%rip), %rax      # 0xc748
movq %rax, 0x10(%rsp)
movq 0x7057(%rip), %rax      # 0xc750
movq %rax, 0x18(%rsp)
movq 0x7053(%rip), %rax      # 0xc758
movq %rax, 0x20(%rsp)
movq 0x704f(%rip), %rax      # 0xc760
movq %rax, 0x28(%rsp)
movq 0x701b(%rip), %rax      # 0xc738
movq %rax, 0x30(%rsp)
movl 0x50(%rdi), %eax
movl $0x7, %r10d
testl %eax, %eax
je 0x5749
cmpl 0x48(%rdi), %eax
jne 0x5749
movl 0x54(%rdi), %eax
testl %eax, %eax
je 0x5749
xorl %r10d, %r10d
cmpl 0x4c(%rdi), %eax
sete %r10b
xorl $0x7, %r10d
leaq 0x7090(%rip), %rax      # 0xc7e0
movq (%rax), %rax
movq (%rdi), %rsi
movq 0x6fcb(%rip), %rdx      # 0xc728
movq %rsp, %r11
movl $0x4, %ecx
movq %rax, %rdi
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %r11
callq 0x3460
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_client_list
void ewmh_set_net_client_list(ScreenInfo *s) {
	Window *windows = alloc_window_array();
	struct list *iter;
	int i = 0;
	for (iter = clients_mapping_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen == s) {
			windows[i++] = c->window;
		}
	}
	XChangeProperty(dpy, s->root, xa_net_client_list,
			XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)windows, i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5854
leaq 0x6fa4(%rip), %rcx      # 0xc7a0
movq (%rcx), %rcx
xorl %r10d, %r10d
testq %rcx, %rcx
je 0x5823
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x581e
movq (%rdx), %rdx
movslq %r10d, %rsi
incl %r10d
movq %rdx, (%rax,%rsi,8)
movq (%rcx), %rcx
jmp 0x5802
leaq 0x6fb6(%rip), %rcx      # 0xc7e0
movq (%rcx), %rdi
movq 0x8(%rbx), %rsi
movq 0x6e38(%rip), %rdx      # 0xc670
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x3460
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: alloc_window_array
static Window *alloc_window_array(void) {
	struct list *iter;
	unsigned int count = 0;
	for (iter = clients_mapping_order; iter; iter = iter->next) {
		count++;
	}
	if (count == 0) count++;
	/* Round up to next block of 128 */
	count = (count + 127) & ~127;
	window_array = realloc(window_array, count * sizeof(Window));
	return window_array;
}

// Assembly:
pushq %rax
leaq 0x6f44(%rip), %rax      # 0xc7a0
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq (%rax), %rax
incl %esi
testq %rax, %rax
jne 0x5861
cmpl $0x1, %esi
adcl $0x7f, %esi
andl $-0x80, %esi
movq 0x6efd(%rip), %rdi      # 0xc778
shlq $0x3, %rsi
callq 0x3510
movq %rax, 0x6eed(%rip)      # 0xc778
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_client_list_stacking
void ewmh_set_net_client_list_stacking(ScreenInfo *s) {
	Window *windows = alloc_window_array();
	struct list *iter;
	int i = 0;
	for (iter = clients_stacking_order; iter; iter = iter->next) {
		Client *c = iter->data;
		if (c->screen == s) {
			windows[i++] = c->window;
		}
	}
	XChangeProperty(dpy, s->root, xa_net_client_list_stacking,
			XA_WINDOW, 32, PropModeReplace,
			(unsigned char *)windows, i);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x5854
leaq 0x6f0b(%rip), %rcx      # 0xc7a8
movq (%rcx), %rcx
xorl %r10d, %r10d
testq %rcx, %rcx
je 0x58c4
movq 0x8(%rcx), %rdx
cmpq %rbx, 0x10(%rdx)
jne 0x58bf
movq (%rdx), %rdx
movslq %r10d, %rsi
incl %r10d
movq %rdx, (%rax,%rsi,8)
movq (%rcx), %rcx
jmp 0x58a3
leaq 0x6f15(%rip), %rcx      # 0xc7e0
movq (%rcx), %rdi
movq 0x8(%rbx), %rsi
movq 0x6d9f(%rip), %rdx      # 0xc678
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %rax
callq 0x3460
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_active_window
void ewmh_set_net_active_window(Client *c) {
	int i;
	for (i = 0; i < num_screens; i++) {
		Window w;
		if (c && i == c->screen->screen) {
			w = c->window;
		} else {
			w = None;
		}
		XChangeProperty(dpy, screens[i].root, xa_net_active_window,
				XA_WINDOW, 32, PropModeReplace,
				(unsigned char *)&w, 1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x6eaa(%rip), %rax      # 0xc7f0
cmpl $0x0, (%rax)
jle 0x59c7
movq %rdi, %rbx
movl $0x8, %r15d
xorl %r12d, %r12d
leaq 0x6e82(%rip), %r13      # 0xc7e0
leaq 0x6e93(%rip), %rbp      # 0xc7f8
movq %rsp, %r14
testq %rbx, %rbx
je 0x597d
movq 0x10(%rbx), %rax
movl (%rax), %eax
cmpq %rax, %r12
jne 0x597d
movq (%rbx), %rax
jmp 0x597f
xorl %eax, %eax
movq %rax, (%rsp)
movq (%r13), %rdi
movq (%rbp), %rax
movq (%rax,%r15), %rsi
movq 0x6d0a(%rip), %rdx      # 0xc6a0
movl $0x21, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq %r14
callq 0x3460
addq $0x10, %rsp
incq %r12
leaq 0x6e35(%rip), %rax      # 0xc7f0
movslq (%rax), %rax
addq $0x70, %r15
cmpq %rax, %r12
jl 0x5968
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_get_net_wm_window_type
unsigned int ewmh_get_net_wm_window_type(Window w) {
	Atom *aprop;
	unsigned long nitems, i;
	unsigned int type = 0;
	if ( (aprop = get_property(w, xa_net_wm_window_type, XA_ATOM, &nitems)) ) {
		for (i = 0; i < nitems; i++) {
			if (aprop[i] == xa_net_wm_window_type_desktop)
				type |= EWMH_WINDOW_TYPE_DESKTOP;
			if (aprop[i] == xa_net_wm_window_type_dock)
				type |= EWMH_WINDOW_TYPE_DOCK;
		}
		XFree(aprop);
	}
	return type;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x6cc8(%rip), %rsi      # 0xc6e8
leaq 0x8(%rsp), %rcx
movl $0x4, %edx
callq 0x4081
testq %rax, %rax
je 0x5a78
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x5a7c
movq 0x6cab(%rip), %rdx      # 0xc6f0
xorl %ebx, %ebx
movq 0x6caa(%rip), %rsi      # 0xc6f8
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
xorl %r9d, %r9d
cmpq %rdx, %r8
sete %r9b
orl %ebx, %r9d
movl %r9d, %ebx
orl $0x2, %ebx
cmpq %rsi, %r8
cmovnel %r9d, %ebx
incq %rdi
cmpq %rdi, %rcx
jne 0x5a50
jmp 0x5a7e
xorl %ebx, %ebx
jmp 0x5a86
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x3210
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/ewmh.c
// Function: ewmh_set_net_wm_state
void ewmh_set_net_wm_state(Client *c) {
	Atom state[3];
	int i = 0;
	if (c->oldh)
		state[i++] = xa_net_wm_state_maximized_vert;
	if (c->oldw)
		state[i++] = xa_net_wm_state_maximized_horz;
	if (c->oldh && c->oldw)
		state[i++] = xa_net_wm_state_fullscreen;
	XChangeProperty(dpy, c->window, xa_net_wm_state,
			XA_ATOM, 32, PropModeReplace,
			(unsigned char *)&state, i);
}

// Assembly:
subq $0x18, %rsp
movl 0x44(%rdi), %eax
testl %eax, %eax
je 0x5aac
movq 0x6c68(%rip), %rcx      # 0xc708
movq %rcx, (%rsp)
movl $0x1, %r10d
jmp 0x5aaf
xorl %r10d, %r10d
movl 0x40(%rdi), %ecx
testl %ecx, %ecx
je 0x5ac7
movq 0x6c53(%rip), %rdx      # 0xc710
movl %r10d, %esi
incl %r10d
movq %rdx, (%rsp,%rsi,8)
testl %ecx, %ecx
sete %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x5ae6
movq 0x6c3c(%rip), %rax      # 0xc718
movl %r10d, %ecx
incl %r10d
movq %rax, (%rsp,%rcx,8)
leaq 0x6cf3(%rip), %rax      # 0xc7e0
movq (%rax), %rax
movq (%rdi), %rsi
movq 0x6c06(%rip), %rdx      # 0xc700
movq %rsp, %r11
movl $0x4, %ecx
movq %rax, %rdi
movl $0x20, %r8d
xorl %r9d, %r9d
pushq %r10
pushq %r11
callq 0x3460
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/list.c
// Function: list_insert_before
struct list *list_insert_before(struct list *list, struct list *before, void *data) {
	struct list *elem = list_new(data);
	struct list *iter;
	if (!elem) return list;
	if (!list) return elem;
	elem->next = before;
	if (before == list) return elem;
	for (iter = list; iter; iter = iter->next) {
		if (!iter->next || iter->next == before) {
			iter->next = elem;
			break;
		}
	}
	return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x3430
testq %rax, %rax
je 0x5b96
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
jmp 0x5b98
xorl %eax, %eax
testq %rax, %rax
je 0x5bc5
testq %rbx, %rbx
je 0x5bc2
movq %r14, (%rax)
cmpq %rbx, %r14
je 0x5bc2
movq %rbx, %rdx
movq %rdx, %rcx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x5bbd
cmpq %r14, %rdx
jne 0x5bad
movq %rax, (%rcx)
jmp 0x5bc5
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/list.c
// Function: list_delete
struct list *list_delete(struct list *list, void *data) {
	struct list **elemp;
	if (!data) return list;
	for (elemp = &list; *elemp; elemp = &(*elemp)->next) {
		if ((*elemp)->data == data) break;
	}
	if (*elemp) {
		struct list *elem = *elemp;
		*elemp = elem->next;
		free(elem);
	}
	return list;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x5c4f
movq %rsp, %rdi
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5c4b
cmpq %rsi, 0x8(%rdi)
jne 0x5c2a
testq %rdi, %rdi
je 0x5c4b
movq (%rdi), %rcx
movq %rcx, (%rax)
callq 0x3090
movq (%rsp), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/main.c
// Function: parse_modifiers
static unsigned int parse_modifiers(char *s) {
	static struct {
		const char *name;
		unsigned int mask;
	} modifiers[9] = {
		{ "shift", ShiftMask },
		{ "lock", LockMask },
		{ "control", ControlMask },
		{ "alt", Mod1Mask },
		{ "mod1", Mod1Mask },
		{ "mod2", Mod2Mask },
		{ "mod3", Mod3Mask },
		{ "mod4", Mod4Mask },
		{ "mod5", Mod5Mask }
	};
	char *tmp = strtok(s, ",+");
	unsigned int ret = 0;
	int i;
	if (!tmp)
		return 0;
	do {
		for (i = 0; i < 9; i++) {
			if (!strcmp(modifiers[i].name, tmp))
				ret |= modifiers[i].mask;
		}
		tmp = strtok(NULL, ",+");
	} while (tmp);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x32e5(%rip), %rsi      # 0x9753
callq 0x35d0
testq %rax, %rax
je 0x64c8
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x58ac(%rip), %r12      # 0xbd30
leaq 0x32c8(%rip), %r14      # 0x9753
movl $0x8, %r13d
movq -0x8(%r13,%r12), %rdi
movq %r15, %rsi
callq 0x3310
testl %eax, %eax
jne 0x64a7
orl (%r13,%r12), %ebx
addq $0x10, %r13
cmpq $0x98, %r13
jne 0x6491
xorl %edi, %edi
movq %r14, %rsi
callq 0x35d0
movq %rax, %r15
testq %rax, %rax
jne 0x648b
jmp 0x64ca
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/main.c
// Function: set_app
static void set_app(const char *arg) {
	Application *new = xmalloc(sizeof(Application));
	char *tmp;
	new->res_name = new->res_class = NULL;
	new->geometry_mask = 0;
	new->is_dock = 0;
#ifdef VWM
	new->vdesk = VDESK_NONE;
#endif
	if ((tmp = strchr(arg, '/'))) {
		*(tmp++) = 0;
	}
	if (strlen(arg) > 0) {
		new->res_name = xmalloc(strlen(arg)+1);
		strcpy(new->res_name, arg);
	}
	if (tmp && strlen(tmp) > 0) {
		new->res_class = xmalloc(strlen(tmp)+1);
		strcpy(new->res_class, tmp);
	}
	applications = list_prepend(applications, new);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x30, %edi
callq 0x643a
movq %rax, %rbx
movabsq $-0x200000000, %rax     # imm = 0xFFFFFFFE00000000
movq %rax, 0x24(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movl $0x0, 0x10(%rbx)
movq %r15, %rdi
movl $0x2f, %esi
callq 0x3200
testq %rax, %rax
je 0x6523
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x6526
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x31e0
testq %rax, %rax
je 0x654c
incq %rax
movq %rax, %rdi
callq 0x643a
movq %rax, (%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3100
testq %r14, %r14
je 0x6578
movq %r14, %rdi
callq 0x31e0
testq %rax, %rax
je 0x6578
incq %rax
movq %rax, %rdi
callq 0x643a
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3100
movq 0x6211(%rip), %rdi      # 0xc790
movq %rbx, %rsi
callq 0x5bce
movq %rax, 0x6202(%rip)      # 0xc790
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/main.c
// Function: set_app_geometry
static void set_app_geometry(const char *arg) {
	if (applications) {
		Application *app = applications->data;
		app->geometry_mask = XParseGeometry(arg,
				&app->x, &app->y, &app->width, &app->height);
	}
}

// Assembly:
movq 0x61f5(%rip), %rax      # 0xc790
testq %rax, %rax
je 0x65be
pushq %rbx
movq 0x8(%rax), %rbx
leaq 0x14(%rbx), %rsi
leaq 0x18(%rbx), %rdx
leaq 0x1c(%rbx), %rcx
leaq 0x20(%rbx), %r8
callq 0x31b0
movl %eax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/main.c
// Function: set_app_vdesk
static void set_app_vdesk(const char *arg) {
	unsigned int v = atoi(arg);
	if (applications && valid_vdesk(v)) {
		Application *app = applications->data;
		app->vdesk = v;
	}
}

// Assembly:
pushq %rax
callq 0x3630
movq 0x61ac(%rip), %rcx      # 0xc790
testq %rcx, %rcx
setne %dl
leal 0x1(%rax), %esi
cmpl $0x9, %esi
setb %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x6604
movq 0x8(%rcx), %rcx
movl %eax, 0x28(%rcx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/misc.c
// Function: spawn
void spawn(const char *const cmd[]) {
	ScreenInfo *current_screen = find_current_screen();
	pid_t pid;

	if (current_screen && current_screen->display)
		putenv(current_screen->display);
	if (!(pid = fork())) {
		setsid();
		switch (fork()) {
			/* execvp()'s prototype is (char *const *) suggesting that it
			 * modifies the contents of the strings.  The prototype is this
			 * way due to SUS maintaining compatability with older code.
			 * However, execvp guarantees not to modify argv, so the following
			 * cast is valid. */
			case 0: execvp(cmd[0], (char *const *)cmd);
			default: _exit(0);
		}
	}
	if (pid > 0)
		wait(NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8050
testq %rax, %rax
je 0x663c
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0x663c
callq 0x32f0
callq 0x3720
testl %eax, %eax
je 0x6651
jle 0x664f
xorl %edi, %edi
popq %rbx
jmp 0x3700
popq %rbx
retq
callq 0x32b0
callq 0x3720
testl %eax, %eax
jne 0x666a
movq (%rbx), %rdi
movq %rbx, %rsi
callq 0x3620
xorl %edi, %edi
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/misc.c
// Function: discard_enter_events
void discard_enter_events(Client *except) {
	XEvent tmp, putback_ev;
	int putback = 0;
	XSync(dpy, False);
	while (XCheckMaskEvent(dpy, EnterWindowMask, &tmp)) {
		if (tmp.xcrossing.window == except->parent) {
			memcpy(&putback_ev, &tmp, sizeof(XEvent));
			putback = 1;
		}
	}
	if (putback) {
		XPutBackEvent(dpy, &putback_ev);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdi, %rbx
leaq 0x60ee(%rip), %r12      # 0xc7e0
movq (%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x3490
movq (%r12), %rdi
movq %rsp, %rdx
movl $0x10, %esi
callq 0x35e0
testl %eax, %eax
je 0x6769
leaq 0xc0(%rsp), %r14
movq %rsp, %r15
movq 0x20(%rsp), %rax
cmpq 0x8(%rbx), %rax
jne 0x673f
movl $0xc0, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3380
movl $0x1, %ebp
movq (%r12), %rdi
movl $0x10, %esi
movq %r15, %rdx
callq 0x35e0
testl %eax, %eax
jne 0x671f
testl %ebp, %ebp
je 0x6769
movq (%r12), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x34c0
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/new.c
// Function: get_wm_normal_hints
long get_wm_normal_hints(Client *c) {
	XSizeHints *size;
	long flags;
	long dummy;
	size = XAllocSizeHints();

	LOG_XENTER("XGetWMNormalHints(window=%lx)", c->window);
	XGetWMNormalHints(dpy, c->window, size, &dummy);
	debug_wm_normal_hints(size);
	LOG_XLEAVE();
	flags = size->flags;
	if (flags & PMinSize) {
		c->min_width = size->min_width;
		c->min_height = size->min_height;
	} else {
		c->min_width = c->min_height = 0;
	}
	if (flags & PMaxSize) {
		c->max_width = size->max_width;
		c->max_height = size->max_height;
	} else {
		c->max_width = c->max_height = 0;
	}
	if (flags & PBaseSize) {
		c->base_width = size->base_width;
		c->base_height = size->base_height;
	} else {
		c->base_width = c->min_width;
		c->base_height = c->min_height;
	}
	c->width_inc = c->height_inc = 1;
	if (flags & PResizeInc) {
		c->width_inc = size->width_inc ? size->width_inc : 1;
		c->height_inc = size->height_inc ? size->height_inc : 1;
	}
	if (!(flags & PMinSize)) {
		c->min_width = c->base_width + c->width_inc;
		c->min_height = c->base_height + c->height_inc;
	}
	if (flags & PWinGravity) {
		c->win_gravity_hint = size->win_gravity;
	} else {
		c->win_gravity_hint = NorthWestGravity;
	}
	c->win_gravity = c->win_gravity_hint;
	XFree(size);
	return flags;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3400
movq %rax, %r14
leaq 0x5838(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq (%rbx), %rsi
leaq 0x8(%rsp), %rcx
movq %r14, %rdx
callq 0x31c0
movq (%r14), %r15
testb $0x10, %r15b
jne 0x6fce
movq $0x0, 0x48(%rbx)
jmp 0x6fdc
movl 0x18(%r14), %eax
movl %eax, 0x48(%rbx)
movl 0x1c(%r14), %eax
movl %eax, 0x4c(%rbx)
testb $0x20, %r15b
jne 0x6fec
movq $0x0, 0x50(%rbx)
jmp 0x6ffa
movl 0x20(%r14), %eax
movl %eax, 0x50(%rbx)
movl 0x24(%r14), %eax
movl %eax, 0x54(%rbx)
btl $0x8, %r15d
jb 0x700d
movl 0x48(%rbx), %eax
movl %eax, 0x60(%rbx)
leaq 0x4c(%rbx), %rax
jmp 0x701b
movl 0x40(%r14), %eax
movl %eax, 0x60(%rbx)
movq %r14, %rax
addq $0x44, %rax
movl (%rax), %eax
movl %eax, 0x64(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x58(%rbx)
testb $0x40, %r15b
je 0x704e
movl 0x28(%r14), %eax
cmpl $0x1, %eax
adcl $0x0, %eax
movl %eax, 0x58(%rbx)
movl 0x2c(%r14), %eax
cmpl $0x1, %eax
adcl $0x0, %eax
movl %eax, 0x5c(%rbx)
testb $0x10, %r15b
jne 0x7066
movl 0x58(%rbx), %eax
movl 0x5c(%rbx), %ecx
addl 0x60(%rbx), %eax
movl %eax, 0x48(%rbx)
addl 0x64(%rbx), %ecx
movl %ecx, 0x4c(%rbx)
movl $0x1, %eax
btl $0x9, %r15d
jae 0x7076
movl 0x48(%r14), %eax
movl %eax, 0x68(%rbx)
movl %eax, 0x6c(%rbx)
movq %r14, %rdi
callq 0x3210
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/screen.c
// Function: draw_outline
static void draw_outline(Client *c) {
#ifndef INFOBANNER_MOVERESIZE
	char buf[27];
	int width_inc = c->width_inc, height_inc = c->height_inc;
#endif  /* ndef INFOBANNER_MOVERESIZE */

	XDrawRectangle(dpy, c->screen->root, c->screen->invert_gc,
		c->x - c->border, c->y - c->border,
		c->width + 2*c->border-1, c->height + 2*c->border-1);

#ifndef INFOBANNER_MOVERESIZE
	snprintf(buf, sizeof(buf), "%dx%d+%d+%d", (c->width-c->base_width)/width_inc,
			(c->height-c->base_height)/height_inc, c->x, c->y);
	XDrawString(dpy, c->screen->root, c->screen->invert_gc,
		c->x + c->width - XTextWidth(font, buf, strlen(buf)) - SPACE,
		c->y + c->height - SPACE,
		buf, strlen(buf));
#endif  /* ndef INFOBANNER_MOVERESIZE */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl 0x58(%rdi), %r14d
movl 0x5c(%rdi), %ebp
leaq 0x550b(%rip), %r15      # 0xc7e0
movq (%r15), %rdi
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
movl 0x24(%rbx), %ecx
movl 0x34(%rbx), %eax
subl %eax, %ecx
movl 0x28(%rbx), %r8d
subl %eax, %r8d
leal -0x1(,%rax,2), %eax
movl 0x2c(%rbx), %r9d
addl %eax, %r9d
addl 0x30(%rbx), %eax
movl %eax, (%rsp)
callq 0x3120
movl 0x2c(%rbx), %eax
subl 0x60(%rbx), %eax
cltd
idivl %r14d
movl %eax, %ecx
movl 0x30(%rbx), %eax
subl 0x64(%rbx), %eax
cltd
idivl %ebp
movl 0x24(%rbx), %r9d
movl 0x28(%rbx), %edx
movl %edx, (%rsp)
leaq 0x25c6(%rip), %rdx      # 0x98f8
leaq 0x10(%rsp), %r14
movl $0x1b, %esi
movq %r14, %rdi
movl %eax, %r8d
xorl %eax, %eax
callq 0x3240
movq (%r15), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rbx), %rax
movq 0x8(%rax), %r12
movq 0x18(%rax), %r13
movl 0x24(%rbx), %ebp
leaq 0x5481(%rip), %rax      # 0xc7e8
movq (%rax), %r15
addl 0x2c(%rbx), %ebp
movq %r14, %rdi
callq 0x31e0
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x3610
subl %eax, %ebp
addl $-0x3, %ebp
movl 0x28(%rbx), %eax
movl 0x30(%rbx), %ecx
leal (%rax,%rcx), %ebx
addl $-0x3, %ebx
movq %r14, %rdi
callq 0x31e0
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
movq %r14, %r9
callq 0x34e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/screen.c
// Function: moveresize
void moveresize(Client *c) {
	client_raise(c);
	XMoveResizeWindow(dpy, c->parent, c->x - c->border, c->y - c->border,
			c->width, c->height);
	XMoveResizeWindow(dpy, c->window, 0, 0, c->width, c->height);
	send_config(c);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3ae2
leaq 0x5408(%rip), %r14      # 0xc7e0
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
movl 0x24(%rbx), %edx
movl 0x34(%rbx), %eax
subl %eax, %edx
movl 0x28(%rbx), %ecx
subl %eax, %ecx
movl 0x2c(%rbx), %r8d
movl 0x30(%rbx), %r9d
callq 0x3250
movq (%r14), %rdi
movq (%rbx), %rsi
movl 0x2c(%rbx), %r8d
movl 0x30(%rbx), %r9d
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3250
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3bc8
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/screen.c
// Function: predicate_keyrepeatpress
static Bool predicate_keyrepeatpress(Display *dummy, XEvent *ev, XPointer arg) {
	(void) dummy;
	XEvent* release_event = (XEvent*) arg;
	if (ev->type != KeyPress)
		return False;
	if (release_event->xkey.keycode != ev->xkey.keycode)
		return False;
	return release_event->xkey.time == ev->xkey.time;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, (%rsi)
jne 0x77a8
movl 0x54(%rdx), %ecx
cmpl 0x54(%rsi), %ecx
jne 0x77a8
movq 0x38(%rdx), %rcx
xorl %eax, %eax
cmpq 0x38(%rsi), %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/kek[P]evilwm/screen.c
// Function: next
void next(void) {
	struct list *newl = list_find(clients_tab_order, current);
	Client *newc = current;
	do {
		if (newl) {
			newl = newl->next;
			if (!newl && !current)
				return;
		}
		if (!newl)
			newl = clients_tab_order;
		if (!newl)
			return;
		newc = newl->data;
		if (newc == current)
			return;
	}
#ifdef VWM
	/* NOTE: Checking against newc->screen->vdesk implies we can Alt+Tab
	 * across screen boundaries.  Is this what we want? */
	while ((!is_fixed(newc) && (newc->vdesk != newc->screen->vdesk)) || (newc->is_dock && !newc->screen->docks_visible));
#else
	while (0);
#endif
	if (!newc)
		return;
	client_show(newc);
	client_raise(newc);
	select_client(newc);
#ifdef WARP_POINTER
	setmouse(newc->window, newc->width + newc->border - 1,
			newc->height + newc->border - 1);
#endif
	discard_enter_events(newc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4945(%rip), %rbx      # 0xc798
movq (%rbx), %rdi
leaq 0x4953(%rip), %r14      # 0xc7b0
movq (%r14), %rsi
callq 0x5cc3
movq (%r14), %rcx
movq (%rbx), %rdx
testq %rax, %rax
je 0x7e80
movq (%rax), %rax
movq %rax, %rsi
orq %rcx, %rsi
jne 0x7e82
jmp 0x7f24
xorl %eax, %eax
testq %rax, %rax
cmoveq %rdx, %rax
testq %rax, %rax
je 0x7f24
movq 0x8(%rax), %rbx
cmpq %rcx, %rbx
je 0x7f24
movl 0x74(%rbx), %esi
cmpl $-0x1, %esi
je 0x7eb0
movq 0x10(%rbx), %rdi
cmpl 0x40(%rdi), %esi
jne 0x7e6b
cmpl $0x0, 0x78(%rbx)
je 0x7ec0
movq 0x10(%rbx), %rsi
cmpl $0x0, 0x68(%rsi)
je 0x7e6b
testq %rbx, %rbx
je 0x7f24
movq %rbx, %rdi
callq 0x3a87
movq %rbx, %rdi
callq 0x3ae2
movq %rbx, %rdi
callq 0x3cc8
leaq 0x48fc(%rip), %rax      # 0xc7e0
movq (%rax), %rdi
movq (%rbx), %rdx
movl 0x34(%rbx), %eax
decl %eax
movl 0x2c(%rbx), %r10d
addl %eax, %r10d
addl 0x30(%rbx), %eax
subq $0x8, %rsp
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq $0x0
callq 0x32c0
addq $0x20, %rsp
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x66d9
addq $0x8, %rsp
popq %rbx
popq %r14
retq