LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/enemy.cpp
// Function: Enemy::OnRestart()
void Enemy::OnRestart(){
	_model.position = {(float)_spawnX, 0, (float)_spawnY};
	_model.SetColor(_color);
	_direcaoX = 0;
	_direcaoY = 0;
	_x = _spawnX;
	_y = _spawnY;
	_scatter = false;
	_scared = false;
	_alive = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2ssl 0x2c0(%rdi), %xmm0
cvtsi2ssl 0x2c4(%rdi), %xmm1
addq $0x8, %rdi
movss %xmm0, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
movss %xmm1, 0x20(%rbx)
movl 0x2e0(%rbx), %esi
callq 0xe6be
movq $0x0, 0x2d0(%rbx)
movq 0x2c0(%rbx), %rax
movq %rax, 0x2c8(%rbx)
xorl %eax, %eax
movb %al, 0x2d8(%rbx)
movb %al, 0xcf793(%rip)      # 0xd9e29
movb $0x1, 0x2d9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::MenuStateUpdate()
void MenuStateUpdate(){
        GameEvents::TriggerMenuUpdate();
        UI::DrawImage("assets/interface/title.png",0.5,0.4,0.75,0.75);
        UI::DrawTextCentered("Press space", 0.5, 0.8, 7, 0.0, { 246, 196, 2, 255 });

        #if defined(NDEBUG) && !defined(EMSCRIPTEN)
        if(1.0-introFadeTimer > 0){
            UI::DrawRect(0,0,1,1,Lerp(RAYWHITE, {0, 0, 0, 0}, introFadeTimer));
            introFadeTimer+=2*Clamp(GetFrameTime(),0,0.016);
        }
        #endif

        if(IsKeyDown(KEY_SPACE)){
            pacman->Resetar();
            GameEvents::TriggerRestart();
            SetState(Game::GameStart);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
callq 0xb6b4
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x8e699(%rip), %rsi     # 0x993a5
leaq 0x8e6ac(%rip), %rdx     # 0x993bf
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0xa78c
movss 0x8e5cd(%rip), %xmm0    # 0x992f4
movss 0x8e5c9(%rip), %xmm1    # 0x992f8
movss 0x8e5c5(%rip), %xmm2    # 0x992fc
movq %rbx, %rdi
movaps %xmm2, %xmm3
callq 0x102de
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xad57
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x8e65a(%rip), %rsi     # 0x993c0
leaq 0x8e65e(%rip), %rdx     # 0x993cb
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xa78c
movss 0x8e573(%rip), %xmm0    # 0x992f4
movss 0x8e577(%rip), %xmm1    # 0x99300
movss 0x8e573(%rip), %xmm2    # 0x99304
xorps %xmm3, %xmm3
movq %rbx, %rdi
movl $0xff02c4f6, %esi       # imm = 0xFF02C4F6
callq 0x104b2
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xadb6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8880
movl $0x20, %edi
callq 0x2fec0
testb %al, %al
je 0xadf3
movq 0xcf06d(%rip), %rdi     # 0xd9e38
callq 0xd8a4
callq 0xb710
movq $0x0, 0xcf060(%rip) # 0xd9e40
callq 0xae24
leaq 0xab(%rip), %rax        # 0xae97
movq %rax, 0xcf065(%rip)     # 0xd9e58
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0xae0c
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0xae1c
movq (%r14), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::GameStartStateUpdate()
void GameStartStateUpdate(){
        if(stateTimer < 2){
            UI::DrawTextCentered("START!", 0.5, 0.4, 7, 0.0, WHITE);
            GameEvents::TriggerMenuUpdate();

            Vector2 pacSpawn = Mapa::GetPlayerSpawn();
            RenderManager::CameraFollow({pacSpawn.x, 0, pacSpawn.y}, 3);
        }else{
            SetState(GameInProgress);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd 0x8e496(%rip), %xmm0    # 0x99340
ucomisd 0xcef8e(%rip), %xmm0    # 0xd9e40
jbe 0xaf3d
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x8e52b(%rip), %rsi     # 0x993f2
leaq 0x8e52a(%rip), %rdx     # 0x993f8
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xa78c
movss 0x8e412(%rip), %xmm0    # 0x992f4
movss 0x8e40e(%rip), %xmm1    # 0x992f8
movss 0x8e412(%rip), %xmm2    # 0x99304
xorps %xmm3, %xmm3
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x104b2
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xaf17
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8880
callq 0xb6b4
callq 0xc62a
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm2, %xmm2
unpcklps %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movss 0x8e2ce(%rip), %xmm2    # 0x99204
callq 0xf86f
jmp 0xaf67
movq $0x0, 0xceef8(%rip) # 0xd9e40
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0xcef07(%rip)     # 0xd9e60
leaq 0x47(%rip), %rax        # 0xafa7
movq %rax, 0xceef1(%rip)     # 0xd9e58
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xaf88
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/game.cpp
// Function: Game::LevelClearedStateUpdate()
void LevelClearedStateUpdate(){
        if(stateTimer < 4){
            std::ostringstream scoreString;
            scoreString << "Score:" << pacman->GetPontuacao();
            UI::DrawTextCentered(scoreString.str(), 0.5, 0.05, 5, 0.5, RAYWHITE);
            UI::DrawTextCentered("Level Cleared!", 0.5, 0.5, 15, 0.0, WHITE);
            GameEvents::TriggerMenuUpdate();
        }else{
            Mapa::Recarrega();
            GameEvents::TriggerRestart();
            SetState(GameStart);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movsd 0x8e123(%rip), %xmm0    # 0x99358
ucomisd 0xcec03(%rip), %xmm0    # 0xd9e40
jbe 0xb353
leaq -0x1c8(%rbp), %rbx
movq %rbx, %rdi
callq 0x8a90
leaq 0x8e1a0(%rip), %rsi     # 0x993f9
movl $0x6, %edx
movq %rbx, %rdi
callq 0x8980
movq 0xcebcb(%rip), %rdi     # 0xd9e38
callq 0xdc7e
movl %eax, %esi
leaq -0x1c8(%rbp), %rdi
callq 0x8570
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8d10
leaq -0x50(%rbp), %rdi
movss 0x8e06c(%rip), %xmm1    # 0x99308
movss 0x8df90(%rip), %xmm2    # 0x99234
movss 0x8e048(%rip), %xmm0    # 0x992f4
movapd %xmm0, %xmm3
movl $0xfff5f5f5, %esi       # imm = 0xFFF5F5F5
callq 0x104b2
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb2d3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x8e13f(%rip), %rsi     # 0x99421
leaq 0x8e146(%rip), %rdx     # 0x9942f
leaq -0x30(%rbp), %rdi
callq 0xa78c
leaq -0x30(%rbp), %rdi
movss 0x8dff6(%rip), %xmm0    # 0x992f4
movss 0x8e00e(%rip), %xmm2    # 0x99314
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm1
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x104b2
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xb32d
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x8880
callq 0xb6b4
movq 0xcbc8f(%rip), %rsi     # 0xd6fc8
leaq -0x1c8(%rbp), %rdi
callq 0x8440
leaq -0x158(%rbp), %rdi
callq 0x8280
jmp 0xb37b
callq 0xc252
callq 0xb710
movq $0x0, 0xcead8(%rip) # 0xd9e40
callq 0xae24
leaq -0x4dd(%rip), %rax      # 0xae97
movq %rax, 0xceadd(%rip)     # 0xd9e58
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0xb3bc
movq -0x20(%rbp), %rsi
jmp 0xb3af
jmp 0xb3b9
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3bc
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
jmp 0xb3bc
movq %rax, %rbx
movq 0xcbc05(%rip), %rsi     # 0xd6fc8
leaq -0x1c8(%rbp), %rdi
callq 0x8440
leaq -0x158(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/gameEvents.cpp
// Function: GameEvents::~GameEvents()
GameEvents::~GameEvents(){
    for(unsigned i=0; i<_events.size(); i++){
        //Remove "this" from the vector, doesn't maintain order
        if(_events[i] == this){
            _events[i] = _events[_events.size()-1];
            _events.pop_back();
            break;
        }
    }
}

// Assembly:
leaq 0xcb301(%rip), %rax     # 0xd6a90
movq %rax, (%rdi)
movq 0xce6df(%rip), %rcx     # 0xd9e78
movq 0xce6d0(%rip), %rax     # 0xd9e70
movq %rcx, %rdx
subq %rax, %rdx
subq %rax, %rcx
je 0xb7df
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rdx
movl $0x1, %esi
xorl %r8d, %r8d
cmpq %rdi, (%rax,%r8,8)
je 0xb7cd
movl %esi, %r8d
incl %esi
cmpq %r8, %rdx
ja 0xb7bb
jmp 0xb7de
movq -0x8(%rax,%rcx), %rcx
movq %rcx, (%rax,%r8,8)
addq $-0x8, 0xce69a(%rip)    # 0xd9e78
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/mapa.cpp
// Function: Mapa::RegistraMapaRenderizavel()
void Mapa::RegistraMapaRenderizavel(){
	for(int y = 0; y < ALTURA; y++){
		for(int x = 0; x < LARGURA; x++){
			int indiceElem = (int)(this->_mapa[x][y]);
			if(indiceElem < (int)(sizeof(modeloElemento)/sizeof(modeloElemento[0])) && modeloElemento[indiceElem] != ""){
				Object3D* parede = new Object3D(modeloElemento[indiceElem], BLUE);
				parede->position.x = x;
				parede->position.z = y;
				_objetosMapa.push_back(parede);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x11c8(%rdi), %rax
movq %rax, -0x68(%rbp)
xorl %eax, %eax
movq %rax, -0x58(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
movq %r15, -0x60(%rbp)
xorl %r12d, %r12d
movslq (%r15), %r14
cmpq $0x3, %r14
jg 0xbed5
shlq $0x5, %r14
leaq 0xce080(%rip), %rax     # 0xd9ea0
addq %rax, %r14
movq %r14, %rdi
leaq 0x8d6a1(%rip), %rsi     # 0x994ce
callq 0x81e0
testl %eax, %eax
je 0xbed5
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x8850
movq %rax, %r13
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0xcd26
movq %r13, %rdi
movq %r14, %rsi
movl $0xfff17900, %edx       # imm = 0xFFF17900
callq 0xe3e6
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xbe8e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
movq %r13, -0x70(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
movss %xmm0, 0x10(%r13)
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x18(%r13)
movq 0x11d0(%rbx), %rsi
cmpq 0x11d8(%rbx), %rsi
je 0xbec8
movq %r13, (%rsi)
addq $0x8, 0x11d0(%rbx)
jmp 0xbed5
movq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0xcfd6
incq %r12
addq $0x6c, %r15
cmpq $0x15, %r12
jne 0xbe08
movq -0x58(%rbp), %rax
incq %rax
movq -0x60(%rbp), %r15
addq $0x4, %r15
cmpq $0x1b, %rax
jne 0xbdf1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xbf2f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8880
jmp 0xbf2f
movq %rax, %rbx
movl $0x2b8, %esi            # imm = 0x2B8
movq %r13, %rdi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb96c
leaq 0xcdcb9(%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 0xc354
incl 0xcee35(%rip)           # 0xdb0e0
movl $0x2b8, %edi            # imm = 0x2B8
callq 0x8850
movq %rax, %r12
shlq $0x5, %r14
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0xcdbd5(%rip), %rax     # 0xd9ea0
movq (%r14,%rax), %rsi
movq 0x8(%r14,%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xcd26
movq %r12, %rdi
movq %rbx, %rsi
movl $0xfff17900, %edx       # imm = 0xFFF17900
callq 0xe3e6
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xc308
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 0xcedc2(%rip), %rsi     # 0xdb0f0
cmpq 0xcedc3(%rip), %rsi     # 0xdb0f8
je 0xc344
movq %r12, (%rsi)
addq $0x8, 0xcedae(%rip)     # 0xdb0f0
jmp 0xc354
leaq 0xced9d(%rip), %rdi     # 0xdb0e8
leaq -0x68(%rbp), %rdx
callq 0xcfd6
incq %r13
addq $0x6c, %r15
cmpq $0x15, %r13
jne 0xc28c
movq -0x58(%rbp), %rax
incq %rax
movq -0x60(%rbp), %r15
addq $0x4, %r15
cmpq $0x1b, %rax
jne 0xc275
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xc3ae
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xc3ae
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_O1/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 0xc407
movl $0x0, (%r8)
xorl %eax, %eax
jmp 0xc4cd
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 0xb96c
movl -0x2c(%rbp), %edi
imulq $0x8dc, %r12, %rax      # imm = 0x8DC
leaq 0xcdadb(%rip), %rcx     # 0xd9f20
addq %rax, %rcx
movl 0x1218(%rcx,%r14,4), %eax
testl %eax, %eax
js 0xc45e
xorl %edi, %ebx
xorl %r15d, %r13d
orl %ebx, %r13d
jne 0xc470
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
xorl %eax, %eax
movq -0x40(%rbp), %r9
jmp 0xc4cd
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_O1/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 0xc629
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
callq 0xb96c
movl %r14d, %eax
movl %ebx, %ecx
imulq $0x6c, %rax, %rax
leaq 0xcd9b9(%rip), %rdx     # 0xd9f20
addq %rax, %rdx
leaq (%rdx,%rcx,4), %rax
addq $0x8, %rax
movl (%rax), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0xc582
decl 0xceb5e(%rip)           # 0xdb0e0
movl $0x0, (%rax)
movq 0xceb61(%rip), %rax     # 0xdb0f0
movq 0xceb52(%rip), %rcx     # 0xdb0e8
subq %rcx, %rax
je 0xc625
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 0xc5d0
jp 0xc5d0
movss 0x18(%rbx), %xmm2
ucomiss %xmm1, %xmm2
jne 0xc5d0
jnp 0xc5dc
movl %edx, %r14d
incl %edx
cmpq %r14, %rax
ja 0xc5b4
jmp 0xc625
testq %rbx, %rbx
je 0xc5f6
movq %rbx, %rdi
callq 0xe52e
movl $0x2b8, %esi            # imm = 0x2B8
movq %rbx, %rdi
callq 0x8880
movq 0xceaeb(%rip), %rax     # 0xdb0e8
leaq (%rax,%r14,8), %rsi
addq $0x8, %rsi
movq 0xceae4(%rip), %rdx     # 0xdb0f0
cmpq %rdx, %rsi
je 0xc61d
leaq (%rax,%r14,8), %rdi
subq %rsi, %rdx
callq 0x8d90
addq $-0x8, 0xceacb(%rip)    # 0xdb0f0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
callq 0xb96c
movq 0xceabd(%rip), %rcx     # 0xdb118
leaq 0xceaae(%rip), %r15     # 0xdb110
movq %r15, %rax
testq %rcx, %rcx
je 0xc688
leaq 0xcea9f(%rip), %rax     # 0xdb110
xorl %edx, %edx
cmpl %r14d, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xc671
movq %r15, %r12
cmpq %r15, %rax
je 0xc69f
cmpl %r14d, 0x20(%rax)
leaq 0xcea75(%rip), %r12     # 0xdb110
cmovbeq %rax, %r12
callq 0xb96c
cmpq %r15, %r12
je 0xc6b1
movq 0x24(%r12), %rax
movq %rax, (%rbx)
leaq 0xcea58(%rip), %rax     # 0xdb110
cmpq %rax, %r12
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f3b6
cvtss2sd %xmm0, %xmm0
mulsd 0x8ca23(%rip), %xmm0    # 0x99448
addsd 0xcadfb(%rip), %xmm0    # 0xd7828
movsd %xmm0, 0xcadf3(%rip)    # 0xd7828
movq 0x11c8(%r12), %rax
cmpq %rax, 0x11d0(%r12)
je 0xcb9e
movl $0x1, %esi
xorl %ecx, %ecx
movl %esi, -0x34(%rbp)
movq (%rax,%rcx,8), %r14
movss 0x10(%r14), %xmm0
movss 0x8ca09(%rip), %xmm1    # 0x99470
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2f3dc
addsd -0x30(%rbp), %xmm0
callq 0x8150
movsd 0x8c9cd(%rip), %xmm1    # 0x99458
addsd %xmm1, %xmm0
movsd 0x8c9d1(%rip), %xmm1    # 0x99468
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %r15d
movss 0x18(%r14), %xmm0
mulss 0x8c9c2(%rip), %xmm0    # 0x99470
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x2f3dc
addsd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
callq 0x8150
addsd 0x8c986(%rip), %xmm0    # 0x99458
mulsd 0x8c98e(%rip), %xmm0    # 0x99468
cvttsd2si %xmm0, %r13d
movss 0x10(%r14), %xmm0
movss 0x8c983(%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 0x2f3dc
mulsd 0x8c830(%rip), %xmm0    # 0x99348
addsd -0x30(%rbp), %xmm0
callq 0x8f40
addsd 0x8c92e(%rip), %xmm0    # 0x99458
mulsd 0x8c936(%rip), %xmm0    # 0x99468
cvttsd2si %xmm0, %ebx
movq %r14, %rdi
callq 0xe6ee
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 0xcacc5(%rip), %xmm0    # 0xd7828
movl %eax, %edi
movl %r15d, %esi
callq 0x9dff
movq %r14, %rdi
movl %eax, %esi
callq 0xe6be
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 0xca52
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd68b
decl %eax
movl %eax, 0x2c4(%rdi)
movl $0x0, 0x2e0(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/game/pacman.cpp
// Function: Pacman::Resetar()
void Pacman::Resetar(){
	_pontuacao = 0;
	_vivo = true;
	_vidas = 3;
	_velocidade = PACMAN_SPEED_DEFAULT;
	_timerAnimacao = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0x2c0(%rdi)
movq $0x3, 0x2c4(%rdi)
movq $0x40600000, 0x2dc(%rdi) # imm = 0x40600000
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc62a
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 0xdf40
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xdf7e
movq %r14, %rdi
movq %r15, %rsi
callq 0xe554
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdc0c
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8880
xorl %edi, %edi
callq 0xa6a4
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 0xdc3a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/KellerMartins[P]PDS2-Pacman/source/graphics/animation.cpp
// Function: Animation::Animation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, bool)
Animation::Animation(std::string basePath, unsigned frameCount, bool loop){
    _basePath = basePath;
    _frameCount = frameCount;
    _timer = 0;
    _loop = loop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x8470
movl %r15d, 0x20(%rbx)
movl $0x0, 0x24(%rbx)
movb %r14b, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xde07
movq (%r12), %rsi
incq %rsi
callq 0x8880
movq %r14, %rdi
callq 0x8ea0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xdee6
movq %rdi, %rbx
xorl %r12d, %r12d
leaq -0x1c0(%rbp), %r13
leaq -0x48(%rbp), %r14
movq %r13, %rdi
callq 0x8a90
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r13, %rdi
callq 0x8980
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
leaq 0x8b764(%rip), %rsi     # 0x995cc
callq 0x8980
movq %r15, %rdi
movq %r12, %rsi
callq 0x8570
movl $0x4, %edx
movq %rax, %rdi
leaq 0x8b6c8(%rip), %rsi     # 0x9954f
callq 0x8980
movq %r14, %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x8d10
movq %r14, %rdi
callq 0xe640
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0xdebc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8880
movq %r13, %rdi
movq 0xc9102(%rip), %rsi     # 0xd6fc8
callq 0x8440
leaq -0x150(%rbp), %rdi
callq 0x8280
incq %r12
movl 0x20(%rbx), %eax
cmpq %rax, %r12
jb 0xde3f
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 0xdf19
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x8880
jmp 0xdf19
movq %rax, %rbx
movq 0xc90a8(%rip), %rsi     # 0xd6fc8
leaq -0x1c0(%rbp), %rdi
callq 0x8440
leaq -0x150(%rbp), %rdi
callq 0x8280
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8b608(%rip), %rsi     # 0x995cc
movl $0x1, %edx
movq %rax, %rdi
callq 0x8980
movq %r15, %rdi
movl %r14d, %esi
callq 0x8e50
leaq 0x8b56c(%rip), %rsi     # 0x9954f
movl $0x4, %edx
movq %rax, %rdi
callq 0x8980
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x8d10
movq 0xc8fc2(%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 0xc8f8d(%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_O1/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 0x2e0dc
movq 0x206e3a(%rip), %r14    # 0x2150a0
leaq 0x206e33(%rip), %r15    # 0x2150a0
cmpq %r15, %r14
je 0xe28c
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 0xe26d
callq 0x2e3d8
leaq 0x206e08(%rip), %rdi    # 0x2150a0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe2d4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8b27f(%rip), %xmm0    # 0x99650
movups %xmm0, 0x10(%rdi)
movaps 0x8b284(%rip), %xmm0    # 0x99660
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe57a
movq %rbx, %rdi
callq 0xf7ed
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0x8(%rbx)
movb %al, 0xd(%rbx)
leaq 0x206b37(%rip), %rdi    # 0x2150c0
movq %r14, %rsi
callq 0xe812
leaq 0x206b30(%rip), %rcx    # 0x2150c8
cmpq %rcx, %rax
jne 0xe5d9
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 0xcd26
movq %r15, %rdi
callq 0xe640
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xe5d9
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8880
leaq 0x206ae0(%rip), %r15    # 0x2150c0
movq %r15, %rdi
movq %r14, %rsi
callq 0xe702
movl 0x9(%rbx), %ecx
movl %ecx, 0x138(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0xe702
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 0xe638
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x8880
movq %rbx, %rdi
callq 0x8ea0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xec02
callq 0x2d6b8
movl $0xf, %edi
callq 0x7d1e3
movl $0x20, %edi
callq 0x2f81d
movq (%r15), %rdx
movl %r14d, %edi
movl %ebx, %esi
callq 0x2d555
leaq 0x8a7d6(%rip), %rsi     # 0x99400
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x6f44c
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x2d75e
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x6fca1
xorl %edi, %edi
callq 0x2f322
callq 0xed11
movl %r14d, %edi
movl %ebx, %esi
callq 0xee24
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
movl $0xff000000, %ecx       # imm = 0xFF000000
callq 0x7610c
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
leaq -0x2c(%rbp), %r14
movq %r14, %rdi
callq 0x6fbcc
movl 0x10(%r14), %eax
movl %eax, 0x206867(%rip)    # 0x215520
movups (%r14), %xmm0
movups %xmm0, 0x20684c(%rip)   # 0x215510
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x6fca1
leaq 0x8a991(%rip), %rsi     # 0x99671
leaq -0x2c(%rbp), %rbx
movq %rbx, %rdi
callq 0x6fb0d
movl 0x10(%rbx), %eax
movl %eax, 0x20683f(%rip)    # 0x215534
movups (%rbx), %xmm0
movups %xmm0, 0x206825(%rip)   # 0x215524
movb $0x1, 0x2063fe(%rip)    # 0x215104
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8a969(%rip), %rbx     # 0x9968f
leaq 0x8a97b(%rip), %rdx     # 0x996a8
leaq -0x94(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21ec0
leaq 0x20656a(%rip), %rdi    # 0x2152b0
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a96e(%rip), %rdx     # 0x996c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21ec0
leaq 0x2063ac(%rip), %rdi    # 0x215118
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a963(%rip), %rdx     # 0x996e3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21ec0
leaq 0x2065a6(%rip), %rdi    # 0x215338
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a956(%rip), %rdx     # 0x996fc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21ec0
leaq 0x206608(%rip), %rdi    # 0x2153c0
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a949(%rip), %rbx     # 0x99715
leaq 0x8a95e(%rip), %rdx     # 0x99731
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21ec0
leaq 0x2063bb(%rip), %rdi    # 0x2151a0
movl $0x84, %edx
movq %r14, %rsi
callq 0x86a0
leaq 0x8a953(%rip), %rdx     # 0x9974c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21ec0
leaq 0x20641d(%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_O1/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, 0x2060eb(%rip)    # 0x215104
jne 0xf1c9
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x20627f(%rip), %rsi    # 0x2152b0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x2062ee(%rip), %eax    # 0x215330
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x20614b(%rip), %rsi    # 0x2151a0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x2061ba(%rip), %eax    # 0x215220
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x2061af(%rip), %rsi    # 0x215228
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x20621e(%rip), %eax    # 0x2152a8
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x20607b(%rip), %rsi    # 0x215118
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x2060ea(%rip), %eax    # 0x215198
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x206277(%rip), %rsi    # 0x215338
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x2062e6(%rip), %eax    # 0x2153b8
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x2062db(%rip), %rsi    # 0x2153c0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x20634a(%rip), %eax    # 0x215440
movl %eax, 0x80(%rsp)
callq 0x223e1
movl 0x206418(%rip), %eax    # 0x215520
movl %eax, 0x10(%rsp)
movups 0x2063fd(%rip), %xmm0   # 0x215510
movups %xmm0, (%rsp)
callq 0x6fcbc
movups 0x206349(%rip), %xmm0   # 0x21546c
movups %xmm0, 0x1c(%rsp)
movups 0x206331(%rip), %xmm0   # 0x215460
movups %xmm0, 0x10(%rsp)
movups 0x206315(%rip), %xmm0   # 0x215450
movups %xmm0, (%rsp)
callq 0x6fcee
movups 0x206351(%rip), %xmm0   # 0x21549c
movups %xmm0, 0x1c(%rsp)
movups 0x206339(%rip), %xmm0   # 0x215490
movups %xmm0, 0x10(%rsp)
movups 0x20631d(%rip), %xmm0   # 0x215480
movups %xmm0, (%rsp)
callq 0x6fcee
movups 0x206359(%rip), %xmm0   # 0x2154cc
movups %xmm0, 0x1c(%rsp)
movups 0x206341(%rip), %xmm0   # 0x2154c0
movups %xmm0, 0x10(%rsp)
movups 0x206325(%rip), %xmm0   # 0x2154b0
movups %xmm0, (%rsp)
callq 0x6fcee
movups 0x206361(%rip), %xmm0   # 0x2154fc
movups %xmm0, 0x1c(%rsp)
movups 0x206349(%rip), %xmm0   # 0x2154f0
movups %xmm0, 0x10(%rsp)
movups 0x20632d(%rip), %xmm0   # 0x2154e0
movups %xmm0, (%rsp)
callq 0x6fcee
callq 0x2d611
addq $0x90, %rsp
popq %rbp
movb $0x0, 0x205f34(%rip)    # 0x215104
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf1e9
movl $0x3, %eax
subl %edi, %eax
movl %eax, 0xc8679(%rip)     # 0xd785c
movl %edi, 0x205f27(%rip)    # 0x215110
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
cmpb $0x1, 0x205f0b(%rip)    # 0x215104
jne 0xf24b
movups 0x2062ca(%rip), %xmm0   # 0x2154cc
movups %xmm0, 0x1c(%rsp)
movups 0x2062b2(%rip), %xmm0   # 0x2154c0
movups %xmm0, 0x10(%rsp)
movups 0x206296(%rip), %xmm0   # 0x2154b0
movups %xmm0, (%rsp)
callq 0x6fcee
movups 0x2062d2(%rip), %xmm0   # 0x2154fc
movups %xmm0, 0x1c(%rsp)
movups 0x2062ba(%rip), %xmm0   # 0x2154f0
movups %xmm0, 0x10(%rsp)
movups 0x20629e(%rip), %xmm0   # 0x2154e0
movups %xmm0, (%rsp)
callq 0x6fcee
movl 0x205eb7(%rip), %eax    # 0x215108
movl 0xc8605(%rip), %ecx     # 0xd785c
cltd
idivl %ecx
movl %eax, %esi
movl 0x205eaa(%rip), %eax    # 0x21510c
cltd
idivl %ecx
leaq -0x34(%rbp), %rbx
movq %rbx, %rdi
movl %eax, %edx
callq 0x6fc44
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x1c(%rbx), %xmm2
movups %xmm2, 0x206247(%rip)   # 0x2154cc
movups %xmm1, 0x206234(%rip)   # 0x2154c0
movups %xmm0, 0x20621d(%rip)   # 0x2154b0
movl 0x205e6f(%rip), %eax    # 0x215108
movl 0xc85bd(%rip), %ecx     # 0xd785c
cltd
idivl %ecx
movl %eax, %esi
movl 0x205e62(%rip), %eax    # 0x21510c
cltd
idivl %ecx
movq %rbx, %rdi
movl %eax, %edx
callq 0x6fc44
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x1c(%rbx), %xmm2
movups %xmm2, 0x206233(%rip)   # 0x2154fc
movups %xmm1, 0x206220(%rip)   # 0x2154f0
movups %xmm0, 0x206209(%rip)   # 0x2154e0
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x205a23(%rip)    # 0x215104
jne 0xf7bf
leaq 0x205bc2(%rip), %rsi    # 0x2152b0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205c31(%rip), %eax    # 0x215330
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x205a8e(%rip), %rsi    # 0x2151a0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205afd(%rip), %eax    # 0x215220
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x205af2(%rip), %rsi    # 0x215228
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205b61(%rip), %eax    # 0x2152a8
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x2059be(%rip), %rsi    # 0x215118
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205a2d(%rip), %eax    # 0x215198
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x205bba(%rip), %rsi    # 0x215338
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205c29(%rip), %eax    # 0x2153b8
movl %eax, 0x80(%rsp)
callq 0x223e1
leaq 0x205c1e(%rip), %rsi    # 0x2153c0
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x205c8d(%rip), %eax    # 0x215440
movl %eax, 0x80(%rsp)
callq 0x223e1
callq 0xed11
addq $0x90, %rsp
popq %rbp
jmp 0xf2de
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20586b(%rip), %xmm3   # 0x2150f8
addss %xmm0, %xmm3
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
addss 0x20585c(%rip), %xmm2   # 0x2150fc
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movaps %xmm3, -0x20(%rbp)
movss 0x205851(%rip), %xmm0   # 0x215100
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movsd 0xc7f70(%rip), %xmm0    # 0xd7830
movaps %xmm0, -0x30(%rbp)
movss 0xc7f6c(%rip), %xmm0    # 0xd7838
movss %xmm0, -0xc(%rbp)
callq 0x2f3b6
movaps %xmm0, %xmm4
mulss -0x8(%rbp), %xmm4
movaps -0x30(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movaps -0x20(%rbp), %xmm2
movss -0x4(%rbp), %xmm3
callq 0x9db5
movlps %xmm0, 0xc7f34(%rip)    # 0xd7830
movss %xmm1, 0xc7f34(%rip)    # 0xd7838
movsd 0xc7f30(%rip), %xmm0    # 0xd783c
movaps %xmm0, -0x20(%rbp)
movss 0xc7f2c(%rip), %xmm0    # 0xd7844
movss %xmm0, -0x4(%rbp)
callq 0x2f3b6
movss -0x8(%rbp), %xmm4
mulss %xmm0, %xmm4
movaps -0x20(%rbp), %xmm0
movss -0x4(%rbp), %xmm1
movaps -0x40(%rbp), %xmm2
movss -0x10(%rbp), %xmm3
callq 0x9db5
movlps %xmm0, 0xc7ef3(%rip)    # 0xd783c
movss %xmm1, 0xc7ef3(%rip)    # 0xd7844
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc7ebc(%rip), %rdi     # 0xd7830
callq 0x299b5
cmpb $0x1, 0x205784(%rip)    # 0x215104
jne 0xf9dc
callq 0x2d9da
movl $0xff000000, %edi       # imm = 0xFF000000
callq 0x2d9a5
leaq 0x228b20(%rip), %rax    # 0x2384b8
movl $0xbe2, %edi            # imm = 0xBE2
callq *(%rax)
callq 0xf9de
callq 0xfdca
callq 0x100a8
leaq 0x228d53(%rip), %rax    # 0x238708
movl $0xbe2, %edi            # imm = 0xBE2
callq *(%rax)
callq 0x10638
leaq 0xc7e68(%rip), %rdi     # 0xd7830
callq 0xe21c
xorl %edi, %edi
xorl %esi, %esi
callq 0x5d895
popq %rbp
jmp 0x2daa2
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20527e(%rip), %rsi    # 0x215338
movl $0x10, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl 0x2052ed(%rip), %eax    # 0x2153b8
movl %eax, 0x80(%rsp)
callq 0x22413
leaq 0x227fb2(%rip), %rax    # 0x238090
movl $0x84c1, %edi           # imm = 0x84C1
callq *(%rax)
leaq 0x227b94(%rip), %rax    # 0x237c80
movl 0x2053c2(%rip), %esi    # 0x2154b4
movl $0xde1, %edi            # imm = 0xDE1
callq *(%rax)
movl 0x205365(%rip), %eax    # 0x215464
movl %eax, -0x10(%rbp)
movups 0x20534b(%rip), %xmm0   # 0x215454
movaps %xmm0, -0x20(%rbp)
cvtsi2ssl 0x204ff3(%rip), %xmm1 # 0x215108
movl 0x204ff1(%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 0x774f3
addq $0xb0, %rsp
popq %rbp
jmp 0x22456
nop