LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::Recarrega()
void Mapa::Recarrega(){
	Mapa &mapa = GetMapaGlobal();
	for(int y = 0; y < ALTURA; y++){
		for(int x = 0; x < LARGURA; x++){
			ElementoMapa elem = mapa._original[x][y];
			mapa._mapa[x][y] = elem;

			if(elem == Ponto || elem == Especial){
				mapa._pontosRestantes++;
				Object3D* ponto = new Object3D(modeloElemento[elem], BLUE);
				ponto->position.x = x;
				ponto->position.z = y;
				mapa._objetosMapa.push_back(ponto);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
callq 0xb940
leaq 0xcdbf3(%rip), %r15     # 0xd9f28
xorl %eax, %eax
leaq -0x50(%rbp), %rbx
movq %rax, -0x58(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movq %r15, -0x60(%rbp)
xorl %r13d, %r13d
movl 0x8dc(%r15), %r14d
movl %r14d, (%r15)
movl %r14d, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0xc41a
incl 0xced6f(%rip)           # 0xdb0e0
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x8850
movq %rax, %r12
shlq $0x5, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xcdb0f(%rip), %rax     # 0xd9ea0
movq (%r14,%rax), %rsi
movq 0x8(%r14,%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xcddc
movq %r12, %rdi
movq %rbx, %rsi
movl $0xfff17900, %edx       # imm = 0xFFF17900
callq 0xe496
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xc3ce
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
movq %r12, -0x68(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %r13d, %xmm0
movss %xmm0, 0x10(%r12)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x18(%r12)
movq 0xcecfc(%rip), %rsi     # 0xdb0f0
cmpq 0xcecfd(%rip), %rsi     # 0xdb0f8
je 0xc40a
movq %r12, (%rsi)
addq $0x8, 0xcece8(%rip)     # 0xdb0f0
jmp 0xc41a
leaq 0xcecd7(%rip), %rdi     # 0xdb0e8
leaq -0x68(%rbp), %rdx
callq 0xd084
incq %r13
addq $0x6c, %r15
cmpq $0x15, %r13
jne 0xc352
movq -0x58(%rbp), %rax
incq %rax
movq -0x60(%rbp), %r15
addq $0x4, %r15
cmpq $0x1b, %rax
jne 0xc33b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc474
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xc474
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
movl $0x2b8, %esi            # imm = 0x2B8
movq %r12, %rdi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::ObtemDirecao(unsigned int, unsigned int, unsigned int, unsigned int, int&, int&)
void Mapa::ObtemDirecao(unsigned int startX, unsigned int startY, unsigned int goalX, unsigned int goalY, int &stepX, int &stepY){
	if(startX >= LARGURA || startY >= ALTURA|| goalX >= LARGURA || goalY >=ALTURA){
		stepX = 0;
		stepY = 0;
		return;
	}

	int u = startX + (startY*LARGURA);
	int v = goalX + (goalY*LARGURA);
	Mapa &mapa = GetMapaGlobal();
	if(mapa._proximo[u][v] >= 0 && (startX != goalX || startY != goalY)){
		stepX = mapa._proximo[u][v] % LARGURA;
		stepY = (mapa._proximo[u][v] - stepX)/LARGURA;

		stepX -= startX;
		stepY -= startY;
	}else{
		stepX = 0;
		stepY = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
cmpl $0x15, %edi
setb %al
cmpl $0x1b, %esi
setb %cl
andb %al, %cl
cmpl $0x15, %edx
setb %al
andb %cl, %al
cmpl $0x1b, %r13d
setb %cl
testb %cl, %al
jne 0xc4cd
movl $0x0, (%r8)
xorl %eax, %eax
jmp 0xc593
movl %edx, %ebx
movl %esi, %r15d
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
leal (%r15,%r15,4), %eax
leal (%r15,%rax,4), %r12d
addl %edi, %r12d
leal (%r13,%r13,4), %eax
leal (%r13,%rax,4), %r14d
addl %edx, %r14d
movl %edi, -0x2c(%rbp)
callq 0xb940
movl -0x2c(%rbp), %edi
imulq $0x8dc, %r12, %rax      # imm = 0x8DC
leaq 0xcda15(%rip), %rcx     # 0xd9f20
addq %rax, %rcx
movl 0x1218(%rcx,%r14,4), %eax
testl %eax, %eax
js 0xc524
xorl %edi, %ebx
xorl %r15d, %r13d
orl %ebx, %r13d
jne 0xc536
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %eax, %eax
movq -0x40(%rbp), %r9
jmp 0xc593
leaq (%rcx,%r14,4), %rcx
addq $0x1218, %rcx           # imm = 0x1218
movl %eax, %edx
movl $0x86186187, %esi       # imm = 0x86186187
imulq %rdx, %rsi
shrq $0x20, %rsi
movl %eax, %edx
subl %esi, %edx
shrl %edx
addl %esi, %edx
shrl $0x4, %edx
leal (%rdx,%rdx,4), %esi
leal (%rdx,%rsi,4), %edx
subl %edx, %eax
movq -0x38(%rbp), %rdx
movl %eax, (%rdx)
movl (%rcx), %ecx
subl %eax, %ecx
movslq %ecx, %rax
imulq $0x30c30c31, %rax, %rax # imm = 0x30C30C31
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
movq -0x40(%rbp), %r9
movl %eax, (%r9)
subl %edi, (%rdx)
movl (%r9), %eax
subl %r15d, %eax
movl %eax, (%r9)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::RemoveElementoMapa(unsigned int, unsigned int)
void Mapa::RemoveElementoMapa(unsigned int x, unsigned int y){
	if(x >= LARGURA || y >=ALTURA) return ;

	Mapa& mapa = GetMapaGlobal();
	if(mapa._mapa[x][y] == Ponto || mapa._mapa[x][y] == Especial)
		mapa._pontosRestantes--;

	mapa._mapa[x][y] = ElementoMapa::Vazio;
	for(unsigned int i=0; i < mapa._objetosMapa.size(); i++){
		Object3D* objMapa = mapa._objetosMapa.at(i);
		if(objMapa->position.x == x && objMapa->position.z == y){
			delete objMapa;
			mapa._objetosMapa.erase(mapa._objetosMapa.begin()+i);
			break;
		}	
	}
}

// Assembly:
cmpl $0x15, %edi
setae %al
cmpl $0x1b, %esi
setae %cl
orb %al, %cl
jne 0xc6f4
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
callq 0xb940
movl %r14d, %eax
movl %ebx, %ecx
imulq $0x6c, %rax, %rax
leaq 0xcd8f3(%rip), %rdx     # 0xd9f20
addq %rax, %rdx
leaq (%rdx,%rcx,4), %rax
addq $0x8, %rax
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0xc648
decl 0xcea98(%rip)           # 0xdb0e0
movl $0x0, (%rax)
movq 0xcea9b(%rip), %rax     # 0xdb0f0
movq 0xcea8c(%rip), %rcx     # 0xdb0e8
subq %rcx, %rax
je 0xc6f0
cvtsi2ss %r14d, %xmm0
cvtsi2ss %ebx, %xmm1
sarq $0x3, %rax
movl $0x1, %edx
xorl %r14d, %r14d
movq (%rcx,%r14,8), %rbx
movss 0x10(%rbx), %xmm2
ucomiss %xmm0, %xmm2
jne 0xc696
jp 0xc696
movss 0x18(%rbx), %xmm2
ucomiss %xmm1, %xmm2
jne 0xc696
jnp 0xc6a2
movl %edx, %r14d
incl %edx
cmpq %r14, %rax
ja 0xc67a
jmp 0xc6f0
movq %rbx, %rdi
callq 0xe5de
movl $0x2b8, %esi            # imm = 0x2B8
movq %rbx, %rdi
callq 0x8880
movq 0xcea2a(%rip), %rax     # 0xdb0e8
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
movq 0xcea23(%rip), %rdx     # 0xdb0f0
cmpq %rdx, %rsi
je 0xc6e5
leaq (%rax,%r14,8), %rdi
subq %rsi, %rdx
callq 0x8d90
movq 0xcea0b(%rip), %rdx     # 0xdb0f0
addq $-0x8, %rdx
movq %rdx, 0xcea00(%rip)     # 0xdb0f0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::GetEnemySpawn(unsigned int, Vector2&)
bool Mapa::GetEnemySpawn(unsigned id, Vector2& pos){
	auto it = GetMapaGlobal()._enemySpawn.find(id);
	if(it != GetMapaGlobal()._enemySpawn.end()){
		pos = it->second;
		return true;
	}else{
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
callq 0xb940
movq 0xce9f2(%rip), %rax     # 0xdb118
testq %rax, %rax
je 0xc75b
leaq 0xce9de(%rip), %r15     # 0xdb110
xorl %ecx, %ecx
cmpl %r14d, 0x20(%rax)
setb %cl
cmovaeq %rax, %r15
movq 0x10(%rax,%rcx,8), %rax
testq %rax, %rax
jne 0xc732
leaq 0xce9c0(%rip), %rax     # 0xdb110
cmpq %rax, %r15
je 0xc75b
cmpl %r14d, 0x20(%r15)
jbe 0xc76d
callq 0xb940
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0xb940
movq 0x24(%r15), %rax
movq %rax, (%rbx)
movb $0x1, %al
jmp 0xc762
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::OnMenuUpdate()
void Mapa::OnMenuUpdate(){
	tempoInterp += GetFrameTime()*0.0125;
	for(unsigned int i=0; i<_objetosMapa.size(); i++){
		Object3D* objMapa = _objetosMapa.at(i);
		Color col = {(unsigned char)((1+sin(objMapa->position.x/8 + GetTime()*1))*127), 
				  	 (unsigned char)((1+sin(objMapa->position.z/8 + GetTime()*2))*127), 
					 (unsigned char)((1+cos(objMapa->position.x/8 + objMapa->position.z/8 +GetTime()*3))*127)};
		
		objMapa->SetColor(Lerp(objMapa->GetColor(), col, tempoInterp));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
callq 0x2f43a
cvtss2sd %xmm0, %xmm0
mulsd 0x8c96d(%rip), %xmm0    # 0x99448
addsd 0xcad45(%rip), %xmm0    # 0xd7828
movsd %xmm0, 0xcad3d(%rip)    # 0xd7828
movq 0x11c8(%r12), %rax
cmpq %rax, 0x11d0(%r12)
je 0xcc54
movl $0x1, %esi
xorl %ecx, %ecx
movl %esi, -0x34(%rbp)
movq (%rax,%rcx,8), %r14
movss 0x10(%r14), %xmm0
movss 0x8c953(%rip), %xmm1    # 0x99470
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2f460
addsd -0x30(%rbp), %xmm0
callq 0x8150
movsd 0x8c917(%rip), %xmm1    # 0x99458
addsd %xmm1, %xmm0
movsd 0x8c91b(%rip), %xmm1    # 0x99468
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r15d
movss 0x18(%r14), %xmm0
mulss 0x8c90c(%rip), %xmm0    # 0x99470
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2f460
addsd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
callq 0x8150
addsd 0x8c8d0(%rip), %xmm0    # 0x99458
mulsd 0x8c8d8(%rip), %xmm0    # 0x99468
cvttsd2si %xmm0, %r13d
movss 0x10(%r14), %xmm0
movss 0x8c8cd(%rip), %xmm2    # 0x99470
mulss %xmm2, %xmm0
movss 0x18(%r14), %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2f460
mulsd 0x8c77a(%rip), %xmm0    # 0x99348
addsd -0x30(%rbp), %xmm0
callq 0x8f40
addsd 0x8c878(%rip), %xmm0    # 0x99458
mulsd 0x8c880(%rip), %xmm0    # 0x99468
cvttsd2si %xmm0, %ebx
movq %r14, %rdi
callq 0xe79e
movl $0xff, %ecx
andl %ecx, %ebx
shll $0x10, %ebx
andl %ecx, %r13d
shll $0x8, %r13d
orl %ebx, %r13d
andl %ecx, %r15d
orl %r13d, %r15d
xorps %xmm0, %xmm0
cvtsd2ss 0xcac0f(%rip), %xmm0    # 0xd7828
movl %eax, %edi
movl %r15d, %esi
callq 0x9dfb
movq %r14, %rdi
movl %eax, %esi
callq 0xe76e
movl -0x34(%rbp), %esi
movl %esi, %ecx
movq 0x11c8(%r12), %rax
movq 0x11d0(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
incl %esi
cmpq %rcx, %rdx
ja 0xcb08
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::Morrer()
void Pacman::Morrer(){
	_vivo = false;
	if(_vidas>0)
		_vidas--;
	
	_timerAnimacao = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x2c0(%rdi)
movl 0x2c4(%rdi), %eax
testl %eax, %eax
je 0xd737
decl %eax
movl %eax, 0x2c4(%rdi)
movl $0x0, 0x2e0(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::OnRestart()
void Pacman::OnRestart(){
	Vector2 spawn = Mapa::GetPlayerSpawn();
	_modelo.position = {spawn.x, 0, spawn.y};
	_x = spawn.x;
	_y = spawn.y;
	_direcaoY = 0;
	_direcaoX = 0;
	_vivo = true;
	_parado.SetTimer(0);
	_modelo.Load3DModel(_parado.GetCurrentFrame());
	Enemy::IsOver(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xc6f6
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
leaq 0x8(%rbx), %r14
movss %xmm0, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
movss %xmm1, 0x20(%rbx)
movss %xmm0, 0x2d4(%rbx)
movss %xmm1, 0x2d8(%rbx)
movq $0x0, 0x2cc(%rbx)
movb $0x1, 0x2c0(%rbx)
addq $0x320, %rbx            # imm = 0x320
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0xdfee
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe02c
movq %r14, %rdi
movq %r15, %rsi
callq 0xe604
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdcb8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8880
xorl %edi, %edi
callq 0xa678
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdce6
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::Preload()
void Animation::Preload(){
    for(unsigned i=0; i<_frameCount; i++){
        std::ostringstream stream;
        stream << _basePath << "_" << i << ".obj";
        Object3D::Cache3DModel(stream.str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
cmpl $0x0, 0x20(%rdi)
je 0xdf93
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x1c0(%rbp), %r13
leaq -0x48(%rbp), %rbx
movq %r13, %rdi
callq 0x8a90
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r13, %rdi
callq 0x8980
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x8b6b8(%rip), %rsi     # 0x995cc
callq 0x8980
movq %r15, %rdi
movq %r12, %rsi
callq 0x8570
movl $0x4, %edx
movq %rax, %rdi
leaq 0x8b61c(%rip), %rsi     # 0x9954f
callq 0x8980
movq %rbx, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x8d10
movq %rbx, %rdi
callq 0xe6f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xdf68
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8880
movq %r13, %rdi
movq 0xc9056(%rip), %rsi     # 0xd6fc8
callq 0x8440
leaq -0x150(%rbp), %rdi
callq 0x8280
incq %r12
movl 0x20(%r14), %eax
cmpq %rax, %r12
jb 0xdeeb
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xdfc6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8880
jmp 0xdfc6
movq %rax, %rbx
movq 0xc8ffb(%rip), %rsi     # 0xd6fc8
leaq -0x1c0(%rbp), %rdi
callq 0x8440
leaq -0x150(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8ea0
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::GetCurrentFrame[abi:cxx11]()
std::string Animation::GetCurrentFrame(){
    int frame = (int)_timer;
    std::ostringstream stream;
    stream << _basePath << "_" << frame << ".obj";
    return stream.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r15
movq %rdi, %rbx
cvttss2si 0x24(%rsi), %r14d
leaq -0x198(%rbp), %r12
movq %r12, %rdi
callq 0x8a90
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x8980
movq %rax, %r15
leaq 0x8b55a(%rip), %rsi     # 0x995cc
movl $0x1, %edx
movq %rax, %rdi
callq 0x8980
movq %r15, %rdi
movl %r14d, %esi
callq 0x8e50
leaq 0x8b4be(%rip), %rsi     # 0x9954f
movl $0x4, %edx
movq %rax, %rdi
callq 0x8980
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x8d10
movq 0xc8f14(%rip), %rsi     # 0xd6fc8
leaq -0x198(%rbp), %rdi
callq 0x8440
leaq -0x128(%rbp), %rdi
callq 0x8280
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xc8edf(%rip), %rsi     # 0xd6fc8
leaq -0x198(%rbp), %rdi
callq 0x8440
leaq -0x128(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8ea0
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/debugPrimitives.cpp
// Function: RenderManager::RenderDebugPrimitives(Camera3D&)
void RenderDebugPrimitives(Camera &camera){
        #ifndef NDEBUG
        BeginMode3D(camera);  
            for(DebugPrimitive* p : _debugPrimitivesToRender){
                p->Draw();
                delete p;
            }  
        EndMode3D();

        _debugPrimitivesToRender.clear();
        #endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups 0x1c(%rdi), %xmm2
movups %xmm2, -0x34(%rbp)
movaps %xmm1, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movups -0x34(%rbp), %xmm0
movups %xmm0, 0x1c(%rsp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2e160
movq 0x206d8a(%rip), %r14    # 0x2150a0
leaq 0x206d83(%rip), %r15    # 0x2150a0
cmpq %r15, %r14
je 0xe33c
movq 0x10(%r14), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r14), %r14
jmp 0xe31d
callq 0x2e45c
leaq 0x206d58(%rip), %rdi    # 0x2150a0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe384
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/object3D.cpp
// Function: Object3D::Object3D()
Object3D::Object3D(){
    _hasModel = false;
    _color = RAYWHITE;
    shouldRender = false;
    position = VECTOR3_ZERO;
    scale = (Vector3){1,1,1};
    rotationAxis = (Vector3){0,1,0};
    rotationAngle = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, (%rdi)
movl $0xf5f5f500, 0x8(%rdi)  # imm = 0xF5F5F500
movw $0xff, 0xc(%rdi)
movaps 0x8b1cf(%rip), %xmm0    # 0x99650
movups %xmm0, 0x10(%rdi)
movaps 0x8b1d4(%rip), %xmm0    # 0x99660
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/object3D.cpp
// Function: Object3D::Load3DModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Object3D::Load3DModel(const std::string modelPath){
    if(!_hasModel){
        _objectID = RenderManager::RegisterObjectToRender((Object3D*)this);
    }
    _hasModel = true;
    shouldRender = true;

    //Insert the loaded model inside the cache when loading it for the first time
    auto modelIt = _modelsCache.find(modelPath);
    if(modelIt == _modelsCache.end()){
        Cache3DModel(modelPath);
    }
    
    _modelsCache[modelPath].material.maps[MAP_DIFFUSE].color = _color;
    model = _modelsCache[modelPath];
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0xe62a
movq %rbx, %rdi
callq 0xf895
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0x8(%rbx)
movb %al, 0xd(%rbx)
leaq 0x206a87(%rip), %rdi    # 0x2150c0
movq %r14, %rsi
callq 0xe8c2
leaq 0x206a80(%rip), %rcx    # 0x2150c8
cmpq %rcx, %rax
jne 0xe689
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xcddc
movq %r15, %rdi
callq 0xe6f0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe689
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8880
leaq 0x206a30(%rip), %r15    # 0x2150c0
movq %r15, %rdi
movq %r14, %rsi
callq 0xe7b2
movl 0x9(%rbx), %ecx
movl %ecx, 0x138(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xe7b2
addq $0x38, %rbx
movl $0x280, %edx            # imm = 0x280
movq %rbx, %rdi
movq %rax, %rsi
callq 0x86a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe6e8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::Init(int, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Init(int screenWidth, int screenHeight, bool fullscreen, std::string windowTitle){
        if(fullscreen)
            ToggleFullscreen();

        #ifdef NDEBUG
        SetTraceLog(0);
        ShowLogo();
        #else
        SetTraceLog(LOG_DEBUG|LOG_ERROR|LOG_WARNING|LOG_INFO);
        #endif
        
        SetConfigFlags(FLAG_MSAA_4X_HINT);
        InitWindow(screenWidth, screenHeight, windowTitle.c_str());
        
        Image icon = LoadImage("assets/interface/pacman_icon.png");         
        SetWindowIcon(icon);
        UnloadImage(icon);

        #ifdef NDEBUG
        SetTargetFPS(60);
        #else
        SetTargetFPS(0);
        #endif
        
        LoadShaders();
        SetResolution(screenWidth, screenHeight);

        Image blackImg = GenImageColor(2,2,BLACK);
        _blackTexture = LoadTextureFromImage(blackImg);
        UnloadImage(blackImg);

        _maskTexture = LoadTexture(MASK_TEXTURE_PATH);

        _isInitialized = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movl %esi, %ebx
movl %edi, %r14d
testl %edx, %edx
je 0xecaa
callq 0x2d73c
movl $0xf, %edi
callq 0x7d267
movl $0x20, %edi
callq 0x2f8a1
movq (%r15), %rdx
movl %r14d, %edi
movl %ebx, %esi
callq 0x2d5d9
leaq 0x8a72e(%rip), %rsi     # 0x99400
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x6f4d0
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x2d7e2
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x6fd25
xorl %edi, %edi
callq 0x2f3a6
callq 0xedb9
movl %r14d, %edi
movl %ebx, %esi
callq 0xeecc
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
movl $0xff000000, %ecx       # imm = 0xFF000000
callq 0x76190
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
leaq -0x2c(%rbp), %r14
movq %r14, %rdi
callq 0x6fc50
movl 0x10(%r14), %eax
movl %eax, 0x2067bf(%rip)    # 0x215520
movups (%r14), %xmm0
movups %xmm0, 0x2067a4(%rip)   # 0x215510
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x6fd25
leaq 0x8a8e9(%rip), %rsi     # 0x99671
leaq -0x2c(%rbp), %rbx
movq %rbx, %rdi
callq 0x6fb91
movl 0x10(%rbx), %eax
movl %eax, 0x206797(%rip)    # 0x215534
movups (%rbx), %xmm0
movups %xmm0, 0x20677d(%rip)   # 0x215524
movb $0x1, 0x206356(%rip)    # 0x215104
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::LoadShaders()
void LoadShaders(){
        _outlineFilter = LoadShader("assets/shaders/fxBase.vs","assets/shaders/outlineFilter.fs");
        _blurPass = LoadShader("assets/shaders/fxBase.vs","assets/shaders/blurPass.fs");
        _screenShader = LoadShader("assets/shaders/fxBase.vs","assets/shaders/screen.fs");
        _copyRTShader = LoadShader("assets/shaders/fxBase.vs","assets/shaders/copyRT.fs");

        _maskShader = LoadShader("assets/shaders/modelVert.vs","assets/shaders/maskFrag.fs");
        _colorShader = LoadShader("assets/shaders/modelVert.vs","assets/shaders/colorFrag.fs");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x8a8c1(%rip), %rbx     # 0x9968f
leaq 0x8a8d3(%rip), %rdx     # 0x996a8
leaq -0x94(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f44
leaq 0x2064c2(%rip), %rdi    # 0x2152b0
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a8c6(%rip), %rdx     # 0x996c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f44
leaq 0x206304(%rip), %rdi    # 0x215118
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a8bb(%rip), %rdx     # 0x996e3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f44
leaq 0x2064fe(%rip), %rdi    # 0x215338
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a8ae(%rip), %rdx     # 0x996fc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f44
leaq 0x206560(%rip), %rdi    # 0x2153c0
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a8a1(%rip), %rbx     # 0x99715
leaq 0x8a8b6(%rip), %rdx     # 0x99731
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f44
leaq 0x206313(%rip), %rdi    # 0x2151a0
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a8ab(%rip), %rdx     # 0x9974c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f44
leaq 0x206375(%rip), %rdi    # 0x215228
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::Quit()
void Quit(){
        if(_isInitialized){
            UnloadShader(_outlineFilter);
            UnloadShader(_maskShader);
            UnloadShader(_colorShader);
            UnloadShader(_blurPass);
            UnloadShader(_screenShader);
            UnloadShader(_copyRTShader);

            UnloadTexture(_blackTexture);
        
            UnloadRenderTexture(_baseRT);
            UnloadRenderTexture(_tempRT);
            UnloadRenderTexture(_blurRT);
            UnloadRenderTexture(_vBlurRT);

            CloseWindow();
        }
        _isInitialized = false;
    }

// Assembly:
cmpb $0x1, 0x206043(%rip)    # 0x215104
jne 0xf271
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x2061d7(%rip), %rsi    # 0x2152b0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x206246(%rip), %eax    # 0x215330
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x2060a3(%rip), %rsi    # 0x2151a0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x206112(%rip), %eax    # 0x215220
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x206107(%rip), %rsi    # 0x215228
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x206176(%rip), %eax    # 0x2152a8
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x205fd3(%rip), %rsi    # 0x215118
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x206042(%rip), %eax    # 0x215198
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x2061cf(%rip), %rsi    # 0x215338
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x20623e(%rip), %eax    # 0x2153b8
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x206233(%rip), %rsi    # 0x2153c0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x2062a2(%rip), %eax    # 0x215440
movl %eax, 0x80(%rsp)
callq 0x22465
movl 0x206370(%rip), %eax    # 0x215520
movl %eax, 0x10(%rsp)
movups 0x206355(%rip), %xmm0   # 0x215510
movups %xmm0, (%rsp)
callq 0x6fd40
movups 0x2062a1(%rip), %xmm0   # 0x21546c
movups %xmm0, 0x1c(%rsp)
movups 0x206289(%rip), %xmm0   # 0x215460
movups %xmm0, 0x10(%rsp)
movups 0x20626d(%rip), %xmm0   # 0x215450
movups %xmm0, (%rsp)
callq 0x6fd72
movups 0x2062a9(%rip), %xmm0   # 0x21549c
movups %xmm0, 0x1c(%rsp)
movups 0x206291(%rip), %xmm0   # 0x215490
movups %xmm0, 0x10(%rsp)
movups 0x206275(%rip), %xmm0   # 0x215480
movups %xmm0, (%rsp)
callq 0x6fd72
movups 0x2062b1(%rip), %xmm0   # 0x2154cc
movups %xmm0, 0x1c(%rsp)
movups 0x206299(%rip), %xmm0   # 0x2154c0
movups %xmm0, 0x10(%rsp)
movups 0x20627d(%rip), %xmm0   # 0x2154b0
movups %xmm0, (%rsp)
callq 0x6fd72
movups 0x2062b9(%rip), %xmm0   # 0x2154fc
movups %xmm0, 0x1c(%rsp)
movups 0x2062a1(%rip), %xmm0   # 0x2154f0
movups %xmm0, 0x10(%rsp)
movups 0x206285(%rip), %xmm0   # 0x2154e0
movups %xmm0, (%rsp)
callq 0x6fd72
callq 0x2d695
addq $0x90, %rsp
popq %rbp
movb $0x0, 0x205e8c(%rip)    # 0x215104
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::SetBloomQuality(RenderManager::BlurQuality)
void SetBloomQuality(BlurQuality quality){
        switch(quality){
            case Low:
                _blurDownscale = 3;
                _blurQuality = 0;
            break;

            case Medium:
                _blurDownscale = 2;
                _blurQuality = 1;
            break;

            case High:
                _blurDownscale = 1;
                _blurQuality = 2;
            break;
        }
        

        if(_isInitialized){
            UnloadRenderTexture(_blurRT);
            UnloadRenderTexture(_vBlurRT);
        }
        _blurRT = LoadRenderTexture(_screenWidth/(_blurDownscale), _screenHeight/(_blurDownscale));
        _vBlurRT = LoadRenderTexture(_screenWidth/(_blurDownscale), _screenHeight/(_blurDownscale));
    }

// Assembly:
cmpl $0x2, %edi
ja 0xf291
movl $0x3, %eax
subl %edi, %eax
movl %eax, 0xc85d1(%rip)     # 0xd785c
movl %edi, 0x205e7f(%rip)    # 0x215110
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
cmpb $0x1, 0x205e63(%rip)    # 0x215104
jne 0xf2f3
movups 0x206222(%rip), %xmm0   # 0x2154cc
movups %xmm0, 0x1c(%rsp)
movups 0x20620a(%rip), %xmm0   # 0x2154c0
movups %xmm0, 0x10(%rsp)
movups 0x2061ee(%rip), %xmm0   # 0x2154b0
movups %xmm0, (%rsp)
callq 0x6fd72
movups 0x20622a(%rip), %xmm0   # 0x2154fc
movups %xmm0, 0x1c(%rsp)
movups 0x206212(%rip), %xmm0   # 0x2154f0
movups %xmm0, 0x10(%rsp)
movups 0x2061f6(%rip), %xmm0   # 0x2154e0
movups %xmm0, (%rsp)
callq 0x6fd72
movl 0x205e0f(%rip), %eax    # 0x215108
movl 0xc855d(%rip), %ecx     # 0xd785c
cltd
idivl %ecx
movl %eax, %esi
movl 0x205e02(%rip), %eax    # 0x21510c
cltd
idivl %ecx
leaq -0x34(%rbp), %rbx
movq %rbx, %rdi
movl %eax, %edx
callq 0x6fcc8
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x1c(%rbx), %xmm2
movups %xmm2, 0x20619f(%rip)   # 0x2154cc
movups %xmm1, 0x20618c(%rip)   # 0x2154c0
movups %xmm0, 0x206175(%rip)   # 0x2154b0
movl 0x205dc7(%rip), %eax    # 0x215108
movl 0xc8515(%rip), %ecx     # 0xd785c
cltd
idivl %ecx
movl %eax, %esi
movl 0x205dba(%rip), %eax    # 0x21510c
cltd
idivl %ecx
movq %rbx, %rdi
movl %eax, %edx
callq 0x6fcc8
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x1c(%rbx), %xmm2
movups %xmm2, 0x20618b(%rip)   # 0x2154fc
movups %xmm1, 0x206178(%rip)   # 0x2154f0
movups %xmm0, 0x206161(%rip)   # 0x2154e0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::ReloadShaders()
void ReloadShaders(){

        //Unload old shaders
        if(_isInitialized){
            UnloadShader(_outlineFilter);
            UnloadShader(_maskShader);
            UnloadShader(_colorShader);
            UnloadShader(_blurPass);
            UnloadShader(_screenShader);
            UnloadShader(_copyRTShader);
        }

        LoadShaders();
        SetShaderUniforms();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
cmpb $0x1, 0x20597b(%rip)    # 0x215104
jne 0xf867
leaq 0x205b1a(%rip), %rsi    # 0x2152b0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205b89(%rip), %eax    # 0x215330
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x2059e6(%rip), %rsi    # 0x2151a0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205a55(%rip), %eax    # 0x215220
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x205a4a(%rip), %rsi    # 0x215228
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205ab9(%rip), %eax    # 0x2152a8
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x205916(%rip), %rsi    # 0x215118
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205985(%rip), %eax    # 0x215198
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x205b12(%rip), %rsi    # 0x215338
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205b81(%rip), %eax    # 0x2153b8
movl %eax, 0x80(%rsp)
callq 0x22465
leaq 0x205b76(%rip), %rsi    # 0x2153c0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205be5(%rip), %eax    # 0x215440
movl %eax, 0x80(%rsp)
callq 0x22465
callq 0xedb9
addq $0x90, %rsp
popq %rbp
jmp 0xf386
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::CameraFollow(Vector3, float)
void CameraFollow(Vector3 position, float speed){
        Vector3 newPos =  (Vector3){position.x + _cameraOffset.x, 
                                    position.y + _cameraOffset.y,
                                    position.z + _cameraOffset.z};
        camera.position = Lerp(camera.position, newPos, GetFrameTime() * speed);
        camera.target = Lerp(camera.target, position, GetFrameTime() * speed);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movss %xmm2, -0x8(%rbp)
movss %xmm1, -0x10(%rbp)
movaps %xmm0, -0x40(%rbp)
movss 0x2057c3(%rip), %xmm3   # 0x2150f8
addss %xmm0, %xmm3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss 0x2057b4(%rip), %xmm2   # 0x2150fc
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movaps %xmm3, -0x20(%rbp)
movss 0x2057a9(%rip), %xmm0   # 0x215100
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd 0xc7ec8(%rip), %xmm0    # 0xd7830
movaps %xmm0, -0x30(%rbp)
movss 0xc7ec4(%rip), %xmm0    # 0xd7838
movss %xmm0, -0xc(%rbp)
callq 0x2f43a
movaps %xmm0, %xmm4
mulss -0x8(%rbp), %xmm4
movaps -0x30(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movaps -0x20(%rbp), %xmm2
movss -0x4(%rbp), %xmm3
callq 0x9db1
movlps %xmm0, 0xc7e8c(%rip)    # 0xd7830
movss %xmm1, 0xc7e8c(%rip)    # 0xd7838
movsd 0xc7e88(%rip), %xmm0    # 0xd783c
movaps %xmm0, -0x20(%rbp)
movss 0xc7e84(%rip), %xmm0    # 0xd7844
movss %xmm0, -0x4(%rbp)
callq 0x2f43a
movss -0x8(%rbp), %xmm4
mulss %xmm0, %xmm4
movaps -0x20(%rbp), %xmm0
movss -0x4(%rbp), %xmm1
movaps -0x40(%rbp), %xmm2
movss -0x10(%rbp), %xmm3
callq 0x9db1
movlps %xmm0, 0xc7e4b(%rip)    # 0xd783c
movss %xmm1, 0xc7e4b(%rip)    # 0xd7844
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::Render()
void Render(){
        UpdateCamera(&camera);
        if(!_isInitialized) return;
        
        BeginDrawing();
            ClearBackground(BLACK);

            glDisable(GL_BLEND);
            RenderBaseEffect();
            RenderBloom();
            RenderFinalComposition();

            glEnable(GL_BLEND);
            UI::Render();

            RenderDebugPrimitives(camera);

            #ifndef NDEBUG
            DrawFPS(0,0);
            #endif

        EndDrawing();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xc7e14(%rip), %rdi     # 0xd7830
callq 0x29a39
cmpb $0x1, 0x2056dc(%rip)    # 0x215104
jne 0xfa84
callq 0x2da5e
movl $0xff000000, %edi       # imm = 0xFF000000
callq 0x2da29
leaq 0x228a78(%rip), %rax    # 0x2384b8
movl $0xbe2, %edi            # imm = 0xBE2
callq *(%rax)
callq 0xfa86
callq 0xfe72
callq 0x10150
leaq 0x228cab(%rip), %rax    # 0x238708
movl $0xbe2, %edi            # imm = 0xBE2
callq *(%rax)
callq 0x106e0
leaq 0xc7dc0(%rip), %rdi     # 0xd7830
callq 0xe2cc
xorl %edi, %edi
xorl %esi, %esi
callq 0x5d919
popq %rbp
jmp 0x2db26
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/rendering.cpp
// Function: RenderManager::RenderFinalComposition()
void RenderFinalComposition(){
        BeginShaderMode(_screenShader);
            glActiveTexture(GL_TEXTURE1);
            glBindTexture(GL_TEXTURE_2D, _blurRT.texture.id);
            DrawTexturePro(_baseRT.texture, (Rectangle){ 0, 0, (float)_screenWidth, (float)-_screenHeight }, 
                                            (Rectangle){ 0, 0, (float)_screenWidth, (float)_screenHeight }, (Vector2){ 0, 0 }, 0,  WHITE);
        EndShaderMode();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x2051d6(%rip), %rsi    # 0x215338
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205245(%rip), %eax    # 0x2153b8
movl %eax, 0x80(%rsp)
callq 0x22497
leaq 0x227f0a(%rip), %rax    # 0x238090
movl $0x84c1, %edi           # imm = 0x84C1
callq *(%rax)
leaq 0x227aec(%rip), %rax    # 0x237c80
movl 0x20531a(%rip), %esi    # 0x2154b4
movl $0xde1, %edi            # imm = 0xDE1
callq *(%rax)
movl 0x2052bd(%rip), %eax    # 0x215464
movl %eax, -0x10(%rbp)
movups 0x2052a3(%rip), %xmm0   # 0x215454
movaps %xmm0, -0x20(%rbp)
cvtsi2ssl 0x204f4b(%rip), %xmm1 # 0x215108
movl 0x204f49(%rip), %eax    # 0x21510c
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
negl %eax
cvtsi2ss %eax, %xmm2
movl -0x10(%rbp), %eax
movl %eax, 0x10(%rsp)
movaps -0x20(%rbp), %xmm3
movups %xmm3, (%rsp)
movaps %xmm1, %xmm3
unpcklps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0],xmm3[1],xmm0[1]
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
xorps %xmm4, %xmm4
xorps %xmm5, %xmm5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x77577
addq $0xb0, %rsp
popq %rbp
jmp 0x224da
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UI::GetImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Texture2D& GetImage(std::string path){
        auto imageIt = _images.find(path);
        if(imageIt == _images.end()){
            Texture2D& imageTex = _images[path];

            imageTex = LoadTexture(path.c_str());
            SetTextureFilter(imageTex, FILTER_TRILINEAR);
            GenTextureMipmaps(&imageTex);
        }

        return _images[path];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x205351(%rip), %rdi    # 0x2155a0
movq %rbx, %rsi
callq 0x10ce6
leaq 0x20534a(%rip), %rcx    # 0x2155a8
cmpq %rcx, %rax
jne 0x102c4
leaq 0x205336(%rip), %rdi    # 0x2155a0
movq %rbx, %rsi
callq 0x10a90
movq %rax, %r14
movq (%rbx), %rsi
leaq -0x44(%rbp), %r15
movq %r15, %rdi
callq 0x6fb91
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
movups (%r15), %xmm0
movups %xmm0, (%r14)
movups (%r14), %xmm0
movaps %xmm0, -0x30(%rbp)
movl 0x10(%r14), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, 0x10(%rsp)
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, %edi
callq 0x770af
movq %r14, %rdi
callq 0x77095
leaq 0x2052d5(%rip), %rdi    # 0x2155a0
movq %rbx, %rsi
callq 0x10a90
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/graphics/ui.cpp
// Function: UI::SetFont(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SetFont(std::string fontPath){
        if(_loadedFont)
            UnloadFont(_font);
        
        _loadedFont = true;
        _font = LoadFont(fontPath.c_str());
        SetTextureFilter(_font.texture, FILTER_TRILINEAR);
        GenTextureMipmaps(&_font.texture);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x20528f(%rip)    # 0x215580
jne 0x1031b
movq 0x20527e(%rip), %rax    # 0x215578
movq %rax, 0x20(%rsp)
movups 0x205262(%rip), %xmm0   # 0x215568
movups %xmm0, 0x10(%rsp)
movups 0x205246(%rip), %xmm0   # 0x215558
movups %xmm0, (%rsp)
callq 0x5cef1
movb $0x1, 0x20525e(%rip)    # 0x215580
movq (%rbx), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x5bb89
movq 0x20(%rbx), %rax
movq %rax, 0x20523c(%rip)    # 0x215578
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x20521e(%rip)   # 0x215568
movups %xmm0, 0x205207(%rip)   # 0x215558
leaq 0x205200(%rip), %rbx    # 0x215558
movl 0x20520a(%rip), %eax    # 0x215568
movl %eax, 0x10(%rsp)
movups 0x2051ef(%rip), %xmm0   # 0x215558
movups %xmm0, (%rsp)
movl $0x2, %edi
callq 0x770af
movq %rbx, %rdi
callq 0x77095
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/enemies/blinky.cpp
// Function: Blinky::SetGoal(int&, int&, int, int, int, int)
void Blinky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
            //Depois de um tempo o fantasma vai para o seu canto
            if(_scatter){
                goalX = 1;
                goalY = 1;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }else{
                //segue o pacman
                goalX = pacX;
                goalY = pacY;
            }
        }else{
            //Quando ele esta com medo ele tambem vai para o seu canto
            goalX = 1;
            goalY = 1;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x113c6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc8a73(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x113d0
movl $0x1, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
jmp 0x11419
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x11414
movl $0x1, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x11419
callq 0x2f43a
mulss 0x883be(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x11419
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/enemies/clyde.cpp
// Function: Clyde::SetGoal(int&, int&, int, int, int, int)
void Clyde::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
            if(_scatter){
                goalX = LARGURA - 2;
                goalY = ALTURA - 2;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }//Se a distancia entre o Clyde e o pacman for menor que 8 ele volta pro cantinho dele
            else if(abs(pacX - _x) + abs(pacY - _y) >= 8){
                goalX = pacX;
                goalY = pacY;
            }
            else{
                goalX = LARGURA - 2;
                goalY = ALTURA - 2;    
            }
        }else{
            goalX = LARGURA - 2;
            goalY = ALTURA - 2;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x114ae
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc8993(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x114b8
movl $0x13, (%rsi)
movl $0x19, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x114ff
movl $0x13, (%rsi)
movl $0x19, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x114a7
callq 0x2f43a
mulss 0x882d3(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x114a7
movl %ecx, %eax
subl 0x2c8(%rbx), %eax
movl %eax, %edi
negl %edi
cmovsl %eax, %edi
movl %r8d, %eax
subl 0x2cc(%rbx), %eax
movl %eax, %r9d
negl %r9d
cmovsl %eax, %r9d
addl %edi, %r9d
cmpl $0x8, %r9d
jb 0x1149b
movl %ecx, (%rsi)
movl %r8d, (%rdx)
jmp 0x114a7
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/enemies/inky.cpp
// Function: Inky::SetGoal(int&, int&, int, int, int, int)
void Inky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
           if(_scatter){
                goalX = 1;
                goalY = ALTURA - 2;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                }
            }
            else{
                //O goal esta uma posicao na frente do pacman
                //direita
                if(dirX == 1 && dirY == 0){
                    goalX = pacX + 3;
                    goalY = pacY;
                }
                //esquerda
                else if(dirX == -1 && dirY == 0){
                    goalX = pacX - 3;
                    goalY = pacY;
                }
                //cima
                else if(dirX == 0 && dirY == -1){
                    goalX = pacX;
                    goalY = pacY - 3;
                }
                //baixo
                else if(dirX == 0 && dirY == 1){
                    goalX = pacX;
                    goalY = pacY + 3;
                }
                
            }
        }else{
            goalX = 1;
            goalY = ALTURA - 2;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
    
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x115c1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc887b(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x115cb
movl $0x1, (%rsi)
movl $0x19, (%rdx)
jmp 0x11635
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x11612
movl $0x1, (%rsi)
movl $0x19, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x11635
callq 0x2f43a
mulss 0x881c0(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x11635
movl 0x10(%rbp), %eax
movl %r9d, %edi
xorl $0x1, %edi
orl %eax, %edi
jne 0x11624
addl $0x3, %ecx
jmp 0x11630
movl %r9d, %edi
notl %edi
orl %eax, %edi
jne 0x1163c
addl $-0x3, %ecx
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
notl %edi
orl %r9d, %edi
jne 0x1164d
movl %ecx, (%rsi)
addl $-0x3, %r8d
jmp 0x11632
xorl $0x1, %eax
orl %eax, %r9d
jne 0x11635
movl %ecx, (%rsi)
addl $0x3, %r8d
jmp 0x11632
nop
// File: /workspace/github_cpp_makefile_star2_O3/KellerMartins[P]PDS2-Pacman/source/game/enemies/pinky.cpp
// Function: Pinky::SetGoal(int&, int&, int, int, int, int)
void Pinky::SetGoal(int &goalX, int &goalY, int pacX, int pacY,int dirX, int dirY){
    if(_alive){
        if(!_scared){
           if(_scatter){
                goalX = LARGURA -2;
                goalY = 1;
                if(_timerScatter > 0){
                    _timerScatter -= 5*GetFrameTime();
                    
                }
            }
            else{
                //O goal esta duas posicoes na frente do pacman
                //direita
                if(dirX == 1 && dirY == 0){
                    goalX = pacX + 2;
                    goalY = pacY;
                }
                //esquerda
                else if(dirX == -1 && dirY == 0){
                    goalX = pacX - 2;
                    goalY = pacY;
                }
                //cima
                else if(dirX == 0 && dirY == -1){
                    goalX = pacX;
                    goalY = pacY - 2;
                }
                //baixo
                else if(dirX == 0 && dirY == 1){
                    goalX = pacX;
                    goalY = pacY + 2;
                }
            }
        }else{
            goalX = LARGURA - 2;
            goalY = 1;
        }
    }else{
        goalX = 10;
        goalY = 10;
    }
}

// Assembly:
cmpb $0x1, 0x2d9(%rdi)
jne 0x116e9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc8753(%rip), %rax     # 0xd9e29
cmpb $0x0, (%rax)
je 0x116f3
movl $0x13, (%rsi)
movl $0x1, (%rdx)
jmp 0x1175d
movl $0xa, %eax
movl %eax, (%rsi)
movl %eax, (%rdx)
retq
movq %rdi, %rbx
cmpb $0x1, 0x2d8(%rdi)
jne 0x1173a
movl $0x13, (%rsi)
movl $0x1, (%rdx)
movss 0x2e8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1175d
callq 0x2f43a
mulss 0x88098(%rip), %xmm0    # 0x997c0
addss 0x2e8(%rbx), %xmm0
movss %xmm0, 0x2e8(%rbx)
jmp 0x1175d
movl 0x10(%rbp), %eax
movl %r9d, %edi
xorl $0x1, %edi
orl %eax, %edi
jne 0x1174c
addl $0x2, %ecx
jmp 0x11758
movl %r9d, %edi
notl %edi
orl %eax, %edi
jne 0x11764
addl $-0x2, %ecx
movl %ecx, (%rsi)
movl %r8d, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
notl %edi
orl %r9d, %edi
jne 0x11775
movl %ecx, (%rsi)
addl $-0x2, %r8d
jmp 0x1175a
xorl $0x1, %eax
orl %eax, %r9d
jne 0x1175d
movl %ecx, (%rsi)
addl $0x2, %r8d
jmp 0x1175a
nop