LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/item.c
// Function: shuffleDrugs
void shuffleDrugs(Map map[LONGUEUR][LARGEUR], Drug drugs[], int nbrDrugs, int *nbrDrugsInFloor)
{
	srand(time(NULL));

	int i = 0;

	*nbrDrugsInFloor = rand()%nbrDrugs+4;
	for(i = 0; i < *nbrDrugsInFloor; i++)
	{
		int indiceDrug = rand()%NBR_DRUGS;
		drugs[i].color = indiceDrug+COLOR_DRUGS;
		drugs[i].indice = i;
		drugs[i].type = indiceDrug;
		drugs[i].poisoned = rand()%4;
		drugs[i].discovered = 0;

		int posX = 0;
		int posY = 0;

		while(posX == 0 || posY == 0 || posX == LONGUEUR || posY == LARGEUR)
		{
			posX = rand()%LONGUEUR;
			posY = rand()%LARGEUR;
		}

		drugs[i].x = posX;
		drugs[i].y = posY;
		map[posX][posY].content = DRUG;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2220
movl %eax, %edi
callq 0x2180
movl $0x0, -0x24(%rbp)
callq 0x21e0
cltd
idivl -0x14(%rbp)
addl $0x4, %edx
movq -0x20(%rbp), %rax
movl %edx, (%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd46e
callq 0x21e0
movl $0x7, %ecx
cltd
idivl %ecx
movl %edx, -0x28(%rbp)
movl -0x28(%rbp), %ecx
addl $0x32, %ecx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
callq 0x21e0
movl $0x4, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl %edx, 0x4(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movb $0x1, %al
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x31(%rbp)
je 0xd3e8
movb $0x1, %al
cmpl $0x0, -0x30(%rbp)
movb %al, -0x31(%rbp)
je 0xd3e8
movb $0x1, %al
cmpl $0x27, -0x2c(%rbp)
movb %al, -0x31(%rbp)
je 0xd3e8
cmpl $0x82, -0x30(%rbp)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xd3f1
jmp 0xd413
callq 0x21e0
movl $0x27, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
callq 0x21e0
movl $0x82, %ecx
cltd
idivl %ecx
movl %edx, -0x30(%rbp)
jmp 0xd3ba
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x14(%rax)
movl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x30(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x5, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd317
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/item.c
// Function: testDrug
int testDrug(Drug drugList[], int x, int y, int nbrDrugsInFloor)
{
	int ret = -1;
	int i = 0;

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

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd4f1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd4e4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0xd4e4
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xd4f1
jmp 0xd4e6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd4a6
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/item.c
// Function: testWeapon
int testWeapon(Weapons weapons[],int x, int y, int nbrWeapons)
{
	int ret = -1;
	int i = 0;

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


	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd571
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x34(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd564
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x38(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0xd564
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xd571
jmp 0xd566
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd526
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/item.c
// Function: testArmor
int testArmor(Armor armor[],int x, int y, int nbrArmors)
{
	int ret = -1;
	int i = 0;

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


	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xd5f1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x28(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xd5e4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x2c(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0xd5e4
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xd5f1
jmp 0xd5e6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd5a6
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/map.c
// Function: initMap
void initMap(Map map[LONGUEUR][LARGEUR], WINDOW *win)
{
	wclear(win);
	box(win,0,0);
	
	int i,j = 0;

	for(i = 0; i < LARGEUR; i++)
	{
		for(j = 0; j < LONGUEUR; j++)
		{
			map[j][i].content = 0;
			map[j][i].seen = 0;
			map[j][i].effect = 0;
			map[j][i].typeEnnemy = 0;
			map[j][i].typePnj = -1;
			map[j][i].trap = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x2120
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x82, -0x14(%rbp)
jge 0xf749
movl $0x0, -0x18(%rbp)
cmpl $0x27, -0x18(%rbp)
jge 0xf739
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x18(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf64a
jmp 0xf73b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf636
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x21e0
movl $0x27, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
callq 0x21e0
movl $0x82, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x10(%rbp), %edx
movl $0x5, %edi
movl $0x1e, %esi
callq 0x2130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %r9d, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x2120
callq 0x21e0
movl $0xff, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x21d0
movq -0x8(%rbp), %rdi
movl $0x1, %edx
leaq 0x83c0(%rip), %rcx      # 0x19ba8
movl %edx, %esi
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
leaq 0x83b5(%rip), %rcx      # 0x19bbb
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
leaq 0x839e(%rip), %rcx      # 0x19bc0
movb $0x0, %al
callq 0x2070
callq 0x21e0
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x32, %edx
jle 0x11857
movq -0x8(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
leaq 0x8383(%rip), %rcx      # 0x19bd3
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x2060
movq -0x8(%rbp), %rdi
movl $0x20, %r8d
xorl %r9d, %r9d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x2120
movq -0x8(%rbp), %rdi
movl $0x20, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x20, (%rsp)
movl $0x20, 0x8(%rsp)
movl $0x20, 0x10(%rsp)
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x2110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x21e0
movq -0x30(%rbp), %rcx
movl $0x64, %esi
cltd
idivl %esi
movl $0x64, %eax
subl 0x28(%rcx), %eax
cmpl %eax, %edx
jge 0x12f75
movq -0x38(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x12f73
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, -0x3c(%rbp)
movl 0x20(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x3c(%rbp), %edx
addl %eax, %edx
movl %edx, %eax
negl %eax
cmovnsl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
jmp 0x12fa7
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movl $0x2, -0x1c(%rbp)
movl 0x10(%rcx), %ecx
movl %ecx, -0x40(%rbp)
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x40(%rbp), %edx
imull %eax, %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jg 0x13044
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x12fe6
callq 0x21e0
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x5, %edx
movl %edx, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x13042
movq -0x8(%rbp), %rax
cmpl $0x2, 0x20(%rax)
jne 0x13010
callq 0x21e0
movl $0xf, %ecx
cltd
idivl %ecx
addl $0x7, %edx
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x13040
movq -0x8(%rbp), %rax
cmpl $0x3, 0x20(%rax)
je 0x13024
movq -0x8(%rbp), %rax
cmpl $0x4, 0x20(%rax)
jne 0x1303e
callq 0x21e0
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %ecx
addl $0x5, %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x13040
jmp 0x13042
jmp 0x13044
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movb %sil, %cl
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movl $0x0, -0x14(%rbp)
movl 0x14(%rax), %ecx
movl %ecx, -0x18(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x19, %eax
ja 0x1380d
movq -0x28(%rbp), %rax
leaq 0x692a(%rip), %rcx      # 0x1a0b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
jmp 0x1380d
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x1380d
movl $0x0, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x1380d
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
jmp 0x1380d
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x1380d
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x14(%rbp)
jmp 0x1380d
movl $0x1, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x1380d
movl $0x1, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
jmp 0x1380f
xorl %eax, %eax
cmpl $0x27, -0x18(%rbp)
movb %al, -0x29(%rbp)
jge 0x1383d
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
jle 0x1383d
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x29(%rbp)
jle 0x1383d
cmpl $0x82, -0x1c(%rbp)
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x13846
jmp 0x1387d
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
imulq $0xe38, %rcx, %rcx      # imm = 0xE38
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1380f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/player.c
// Function: initPlayer
void initPlayer(Player *player, Inventory inventory[])
{
	int i = 0;

	player->power = 1;
	player->colorBlind = 0;
	player->state = 0;
	player->state2 = 0;

	player->life = 100;
	player->strength = 11;
	player->hate = 10;
	player->agility = 11;
	player->view = 5;

	player->inventorySize = player->strength+1;

	for(i = 0; i < player->inventorySize; i++)
	{
		inventory[i].type = -1;
		inventory[i].object = 0;
		//inventory[i].number = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x64, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0xb, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xa, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0xb, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jge 0x13944
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,8) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, 0x4(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1390e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x139c1
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x139b4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x139b4
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x139c1
jmp 0x139b6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13976
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/S01den[P]Lost_CavernRL/pnj.c
// Function: clearQuest
void clearQuest(Quest quest[])
{
	int i = 0;
	for(i = 0; i < NBR_QUESTS_MAX; i++)
	{
		quest[i].isSet = 0;
		quest[i].name = "";
		quest[i].description = "";
		quest[i].typeReward = -1;
		quest[i].reward = -1;
		quest[i].indice = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x14179
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
leaq 0x3fdb(%rip), %rcx      # 0x180e7
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
leaq 0x3fc2(%rip), %rcx      # 0x180e7
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x140d6
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x26, -0xc(%rbp)
jge 0x162ab
movl $0x1, -0x10(%rbp)
cmpl $0x81, -0x10(%rbp)
jge 0x1629e
movq -0x8(%rbp), %rdi
movl $0xf400, %esi           # imm = 0xF400
xorl %eax, %eax
movl %eax, %edx
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x1e6c(%rip), %rcx      # 0x180e6
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rdi
movl $0xf400, %esi           # imm = 0xF400
xorl %eax, %eax
movl %eax, %edx
callq 0x2060
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1624e
jmp 0x162a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16241
movq -0x8(%rbp), %rdi
callq 0x2100
movl $0xf, %edi
callq 0x161e0
movl $0x1, -0xc(%rbp)
cmpl $0x26, -0xc(%rbp)
jge 0x16329
movl $0x1, -0x10(%rbp)
cmpl $0x81, -0x10(%rbp)
jge 0x1631c
movq -0x8(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x1deb(%rip), %rcx      # 0x180e6
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2060
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x162d2
jmp 0x1631e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x162c5
movq -0x8(%rbp), %rdi
callq 0x2100
movl $0x9, %edi
callq 0x161e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x2, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x1080
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x100, %esi            # imm = 0x100
movl $0x3, %edx
movl $0x1, %ecx
movq %r9, %rdi
callq 0x1030
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x1050
movq -0x20(%rbp), %rdi
leaq 0xe02(%rip), %rsi       # 0x200b
leaq -0x24(%rbp), %rdx
movb $0x0, %al
callq 0x1060
movl -0x24(%rbp), %esi
leaq 0xde6(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
shll %edx
leaq 0xdd6(%rip), %rsi       # 0x200b
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
leaq 0xc0a9(%rip), %rax      # 0xf938
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x38dd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x38c4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x38ce
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38e5
jmp 0x38d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3896
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0xc01a(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xbe59(%rip), %rax      # 0xf7d0
movq (%rax), %rdx
leaq 0xbe4f(%rip), %rax      # 0xf7d0
movq (%rax), %rcx
leaq -0x20(%rbp), %rax
movl $0x20, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
callq 0x3480
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbee5(%rip), %rax      # 0xf948
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3acd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x3a8c
jmp 0x3b5a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x3abe
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x3abc
movq -0x18(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x40(%rcx), %eax
jne 0x3abe
jmp 0x3acd
jmp 0x3ac0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3a6a
cmpq $0x0, -0x10(%rbp)
jne 0x3ad9
jmp 0x3b5a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0xbe88(%rip), %rax      # 0xf980
movq (%rax), %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %edx
callq 0x35c0
leaq 0xbe38(%rip), %rax      # 0xf948
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x6d90
movq %rax, %rcx
leaq 0xbe22(%rip), %rax      # 0xf948
movq %rcx, (%rax)
leaq 0xbe18(%rip), %rax      # 0xf948
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x6c10
movq %rax, %rcx
leaq 0xbdfe(%rip), %rax      # 0xf948
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x67e0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x16, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0xbdb2(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
xorl %edx, %edx
movl $0x20000, %ecx          # imm = 0x20000
leaq -0x60(%rbp), %r8
callq 0x3050
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x8, %eax
ja 0x3c31
movq -0x20(%rbp), %rax
leaq 0x83dc(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x3c33
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3c97
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3c97
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3c97
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3c97
jmp 0x3c97
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3c97
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3c97
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3c97
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x3cd0
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %eax
leaq 0xbcd1(%rip), %rcx      # 0xf980
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
je 0x3cdd
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x3d16
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
leaq 0xbc8b(%rip), %rcx      # 0xf980
movq (%rcx), %rcx
movq 0xe8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq (%rdx), %rdx
shlq $0x7, %rdx
addq %rdx, %rcx
cmpl 0x1c(%rcx), %eax
je 0x3d23
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xbc0d(%rip), %rax      # 0xf950
cmpq $0x0, (%rax)
je 0x3d78
leaq 0xbc30(%rip), %rax      # 0xf980
movq (%rax), %rdi
leaq 0xbbf6(%rip), %rax      # 0xf950
movq (%rax), %rax
movq 0x8(%rax), %rsi
leaq 0xbbe8(%rip), %rax      # 0xf950
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rdx
callq 0x3370
cmpq $0x0, -0x8(%rbp)
je 0x3dfc
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
jne 0x3d9b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3dab
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0xbbce(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x3370
leaq 0xbbb3(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x36e0
leaq 0xbb9c(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3720
movq -0x8(%rbp), %rcx
leaq 0xbb49(%rip), %rax      # 0xf950
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x6900
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x3e3b
cmpl $0x7, -0xc(%rbp)
ja 0x3e8f
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x74(%rax)
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x40(%rcx), %eax
je 0x3e63
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
jne 0x3e6e
movq -0x8(%rbp), %rdi
callq 0x39b0
jmp 0x3e77
movq -0x8(%rbp), %rdi
callq 0x38f0
movq -0x8(%rbp), %rdi
callq 0x69c0
leaq 0xbac9(%rip), %rax      # 0xf950
movq (%rax), %rdi
callq 0x3d30
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x4125
leaq 0xb8bd(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x3520
cmpl $0x0, %eax
je 0x4125
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x411c
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0xb6df(%rip), %rcx      # 0xf7e0
cmpq (%rcx), %rax
jne 0x410f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4111
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x40e6
movq -0x20(%rbp), %rdi
callq 0x3220
cmpl $0x0, -0x18(%rbp)
je 0x414d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0xb69f(%rip), %rax      # 0xf7d8
movq (%rax), %rsi
leaq 0xb69d(%rip), %rax      # 0xf7e0
movq (%rax), %rdx
callq 0x4170
jmp 0x4163
leaq 0xb82c(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x3180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/client.c
// Function: send_xmessage
static int send_xmessage(Window w, Atom a, long x) {
	XEvent ev;

	ev.type = ClientMessage;
	ev.xclient.window = w;
	ev.xclient.message_type = a;
	ev.xclient.format = 32;
	ev.xclient.data.l[0] = x;
	ev.xclient.data.l[1] = CurrentTime;

	return XSendEvent(dpy, w, False, NoEventMask, &ev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x21, -0xd8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x20, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
leaq 0xb7b2(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
callq 0x3050
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb7ad(%rip), %rax      # 0xf9b0
cmpl $0x0, (%rax)
jne 0x420d
jmp 0x429a
leaq 0xb76c(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0xc(%rbp), %rdx
leaq -0x10(%rbp), %r10
leaq -0x18(%rbp), %rax
leaq -0x14(%rbp), %r11
movq %r10, %rcx
movq %r10, %r8
movq %rax, %r9
movq %rax, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x31f0
cmpl $0x0, %eax
je 0x429a
cmpl $0x0, -0xc(%rbp)
je 0x429a
leaq 0xb715(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %r9
xorl %r8d, %r8d
movl %r8d, %edx
movl %r8d, %ecx
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x3560
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: interruptibleXNextEvent
static int interruptibleXNextEvent(XEvent *event) {
	fd_set fds;
	int rc;
	int dpy_fd = ConnectionNumber(dpy);
	for (;;) {
		if (XPending(dpy)) {
			XNextEvent(dpy, event);
			return 1;
		}
		FD_ZERO(&fds);
		FD_SET(dpy_fd, &fds);
		rc = select(dpy_fd + 1, &fds, NULL, NULL, NULL);
		if (rc < 0) {
			if (errno == EINTR) {
				return 0;
			} else {
				LOG_ERROR("interruptibleXNextEvent(): select()\n");
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xb41a(%rip), %rax      # 0xf980
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x98(%rbp)
leaq 0xb407(%rip), %rax      # 0xf980
movq (%rax), %rdi
callq 0x3170
cmpl $0x0, %eax
je 0x45a5
leaq 0xb3f3(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3440
movl $0x1, -0x4(%rbp)
jmp 0x4691
jmp 0x45a7
leaq -0x90(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpq $0x10, %rax
jae 0x45f1
movq -0xa8(%rbp), %rax
movl -0x9c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x45bf
jmp 0x45f3
movl -0x98(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x98(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movl -0x98(%rbp), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x3400
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jge 0x468c
callq 0x30d0
cmpl $0x4, (%rax)
jne 0x4672
movl $0x0, -0x4(%rbp)
jmp 0x4691
movq 0xa97f(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x7a4d(%rip), %rsi      # 0xc0d0
movb $0x0, %al
callq 0x3350
jmp 0x468c
jmp 0x4572
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_button_event
static void handle_button_event(XButtonEvent *e) {
	Client *c = find_client(e->window);

	if (c) {
		switch (e->button) {
			case Button1:
				drag(c); break;
			case Button2:
				sweep(c); break;
			case Button3:
				client_lower(c); break;
			default: break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ede
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x4eb9
jmp 0x4ea5
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x4ec4
jmp 0x4eaf
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x4ecf
jmp 0x4eda
movq -0x10(%rbp), %rdi
callq 0x9910
jmp 0x4edc
movq -0x10(%rbp), %rdi
callq 0x9030
jmp 0x4edc
movq -0x10(%rbp), %rdi
callq 0x3a50
jmp 0x4edc
jmp 0x4edc
jmp 0x4ede
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_configure_request
static void handle_configure_request(XConfigureRequestEvent *e) {
	Client *c = find_client(e->window);
	XWindowChanges wc;

	wc.x = e->x;
	wc.y = e->y;
	wc.width = e->width;
	wc.height = e->height;
	wc.border_width = 0;
	wc.sibling = e->above;
	wc.stack_mode = e->detail;
	if (c) {
		if (e->value_mask & CWStackMode && e->value_mask & CWSibling) {
			Client *sibling = find_client(e->above);
			if (sibling) {
				wc.sibling = sibling->parent;
			}
		}
		do_window_changes(e->value_mask, &wc, c, 0);
		if (c == current) {
			discard_enter_events(c);
		}
	} else {
		LOG_XENTER("XConfigureWindow(window=%lx, value_mask=%lx)", (unsigned int)e->window, e->value_mask);
		XConfigureWindow(dpy, e->window, e->value_mask, &wc);
		LOG_XLEAVE();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4fd7
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x4fa3
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x4fa3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3880
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4fa1
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4fa3
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rsi
xorl %ecx, %ecx
callq 0x5630
movq -0x10(%rbp), %rax
leaq 0xa989(%rip), %rcx      # 0xf950
cmpq (%rcx), %rax
jne 0x4fd5
movq -0x10(%rbp), %rdi
callq 0x7f30
jmp 0x4ffc
leaq 0xa9a2(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
leaq -0x38(%rbp), %rcx
callq 0x3040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_map_request
static void handle_map_request(XMapRequestEvent *e) {
	Client *c = find_client(e->window);

	LOG_ENTER("handle_map_request(window=%lx)", e->window);
	if (c) {
#ifdef VWM
		if (!is_fixed(c) && c->vdesk != c->screen->vdesk)
			switch_vdesk(c->screen, c->vdesk);
#endif
		client_show(c);
		client_raise(c);
	} else {
		XWindowAttributes attr;
		XGetWindowAttributes(dpy, e->window, &attr);
		make_new_client(e->window, find_screen(attr.root));
	}
	LOG_LEAVE();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x507d
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x5069
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x40(%rcx), %eax
je 0x5069
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x74(%rax), %esi
callq 0xa480
movq -0x10(%rbp), %rdi
callq 0x39b0
movq -0x10(%rbp), %rdi
callq 0x39f0
jmp 0x50c2
leaq 0xa8fc(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x98(%rbp), %rdx
callq 0x35d0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x78(%rbp), %rdi
callq 0xa630
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x7fe0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_colormap_change
static void handle_colormap_change(XColormapEvent *e) {
	Client *c = find_client(e->window);

	if (c && e->new) {
		c->cmap = e->colormap;
		XInstallColormap(dpy, c->cmap);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5125
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x5125
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0xa86b(%rip), %rax      # 0xf980
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x36e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_enter_event
static void handle_enter_event(XCrossingEvent *e) {
	Client *c;

	if ((c = find_client(e->window))) {
#ifdef VWM
		if (!is_fixed(c) && c->vdesk != c->screen->vdesk)
			return;
#endif
		select_client(c);
		ewmh_select_client(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5185
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x5173
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x40(%rcx), %eax
je 0x5173
jmp 0x5185
movq -0x10(%rbp), %rdi
callq 0x3d30
movq -0x10(%rbp), %rdi
callq 0x6660
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kek[P]evilwm/events.c
// Function: handle_property_change
static void handle_property_change(XPropertyEvent *e) {
	Client *c = find_client(e->window);

	if (c) {
		LOG_ENTER("handle_property_change(window=%lx, atom=%s)", e->window, debug_atom_name(e->atom));
		if (e->atom == XA_WM_NORMAL_HINTS) {
			get_wm_normal_hints(c);
			LOG_DEBUG("geometry=%dx%d+%d+%d\n", c->width, c->height, c->x, c->y);
		} else if (e->atom == xa_net_wm_window_type) {
			get_window_type(c);
			if (!c->is_dock
#ifdef VWM
					&& (is_fixed(c) || (c->vdesk == c->screen->vdesk))
#endif
					) {
				client_show(c);
			}
		}
		LOG_LEAVE();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3880
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x521e
movq -0x8(%rbp), %rax
cmpq $0x28, 0x28(%rax)
jne 0x51ca
movq -0x10(%rbp), %rdi
callq 0x8df0
jmp 0x521c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
leaq 0xa6af(%rip), %rcx      # 0xf888
cmpq (%rcx), %rax
jne 0x521a
movq -0x10(%rbp), %rdi
callq 0x9000
movq -0x10(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x5218
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x74(%rax)
je 0x520f
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x40(%rcx), %eax
jne 0x5218
movq -0x10(%rbp), %rdi
callq 0x39b0
jmp 0x521a
jmp 0x521c
jmp 0x521e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)