LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: SetItemNames
void SetItemNames (void)
{
	int		i;
	gitem_t	*it;

	for (i=0 ; i<game.num_items ; i++)
	{
		it = &itemlist[i];
		gi.configstring (CS_ITEMS+i, it->pickup_name);
	}

	jacket_armor_index = ITEM_INDEX(FindItem("Jacket Armor"));
	combat_armor_index = ITEM_INDEX(FindItem("Combat Armor"));
	body_armor_index   = ITEM_INDEX(FindItem("Body Armor"));
	power_screen_index = ITEM_INDEX(FindItem("Power Screen"));
	power_shield_index = ITEM_INDEX(FindItem("Power Shield"));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x378e8(%rip), %rbx     # 0x69d40
cmpl $0x0, 0x61c(%rbx)
jle 0x3249b
movq 0x379d8(%rip), %r14     # 0x69e40
addq $0x50, %r14
xorl %r15d, %r15d
movq 0x3718a(%rip), %r12     # 0x69600
movq (%r14), %rsi
leal 0x420(%r15), %edi
callq *0x30(%r12)
incq %r15
movslq 0x61c(%rbx), %rax
addq $0x88, %r14
cmpq %rax, %r15
jl 0x32476
leaq 0x21f5b(%rip), %rdi     # 0x543fd
callq 0x189e0
movq 0x37992(%rip), %rbx     # 0x69e40
subq %rbx, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
movl %eax, 0x41683(%rip)     # 0x73b44
leaq 0x231c6(%rip), %rdi     # 0x5568e
callq 0x189e0
subq %rbx, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
movl %eax, 0x41668(%rip)     # 0x73b48
leaq 0x231b4(%rip), %rdi     # 0x5569b
callq 0x189e0
subq %rbx, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
movl %eax, 0x4164d(%rip)     # 0x73b4c
leaq 0x24c54(%rip), %rdi     # 0x5715a
callq 0x189e0
subq %rbx, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
movl %eax, 0x41636(%rip)     # 0x73b54
leaq 0x23181(%rip), %rdi     # 0x556a6
callq 0x189e0
subq %rbx, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
movl %eax, 0x41613(%rip)     # 0x73b50
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: ShutdownGame
void ShutdownGame (void)
{
	gi.dprintf ("==== ShutdownGame ====\n");

	sl_GameEnd( &gi, level );	// StdLog - Mark Davies

	gi.FreeTags (TAG_LEVEL);
	gi.FreeTags (TAG_GAME);

#ifdef _WIN32
	OutputDebugString("ShutdownGame() was called.\n");
	OutputDebugString("Dump objects since startup.\n");
	_CrtMemDumpAllObjectsSince(&startup1);
	OutputDebugString("Memory stats since startup.\n");
	_CrtMemDumpStatistics(&startup1);
	_CrtDumpMemoryLeaks();
#endif

}

// Assembly:
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq 0x370a5(%rip), %rbx     # 0x69600
leaq 0x25bdd(%rip), %rdi     # 0x5813f
xorl %eax, %eax
callq *0x8(%rbx)
movq 0x37832(%rip), %rsi     # 0x69da0
movl $0x2b, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x19a10
movl $0x2fe, %edi            # imm = 0x2FE
callq *0x118(%rbx)
movl $0x2fd, %edi            # imm = 0x2FD
movq %rbx, %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
jmpq *0x118(%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: GetGameAPI
q_exported game_export_t *GetGameAPI (game_import_t *import)
{
	gi = *import;

	globals.apiversion = GAME_API_VERSION;
	globals.Init = InitGame;
	globals.Shutdown = ShutdownGame;
	globals.SpawnEntities = SpawnEntities;

	globals.WriteGame = WriteGame;
	globals.ReadGame = ReadGame;
	globals.WriteLevel = WriteLevel;
	globals.ReadLevel = ReadLevel;

	globals.ClientThink = ClientThink;
	globals.ClientConnect = ClientConnect;
	globals.ClientUserinfoChanged = ClientUserinfoChanged;
	globals.ClientDisconnect = ClientDisconnect;
	globals.ClientBegin = ClientBegin;
	globals.ClientCommand = ClientCommand;

	globals.RunFrame = G_RunFrame;

	globals.ServerCommand = ServerCommand;

	globals.edict_size = sizeof(edict_t);

	return &globals;
}

// Assembly:
pushq %rax
movq %rdi, %rsi
movq 0x37053(%rip), %rdi     # 0x69600
movl $0x160, %edx            # imm = 0x160
callq 0x18c80
movq 0x3754a(%rip), %rax     # 0x69b08
movl $0x3, (%rax)
movq 0x370bd(%rip), %rcx     # 0x69688
movq %rcx, 0x8(%rax)
movq 0x377f2(%rip), %rcx     # 0x69dc8
movq %rcx, 0x10(%rax)
movq 0x36ecf(%rip), %rcx     # 0x694b0
movq %rcx, 0x18(%rax)
movq 0x37564(%rip), %rcx     # 0x69b50
movq %rcx, 0x20(%rax)
movq 0x36f99(%rip), %rcx     # 0x69590
movq %rcx, 0x28(%rax)
movq 0x37126(%rip), %rcx     # 0x69728
movq %rcx, 0x30(%rax)
movq 0x378ab(%rip), %rcx     # 0x69eb8
movq %rcx, 0x38(%rax)
movq 0x371b8(%rip), %rcx     # 0x697d0
movq %rcx, 0x68(%rax)
movq 0x37775(%rip), %rcx     # 0x69d98
movq %rcx, 0x40(%rax)
movq 0x37142(%rip), %rcx     # 0x69770
movq %rcx, 0x50(%rax)
movq 0x36e5f(%rip), %rcx     # 0x69498
movq %rcx, 0x58(%rax)
movq 0x3738c(%rip), %rcx     # 0x699d0
movq %rcx, 0x48(%rax)
movq 0x372d9(%rip), %rcx     # 0x69928
movq %rcx, 0x60(%rax)
movq 0x3705e(%rip), %rcx     # 0x696b8
movq %rcx, 0x70(%rax)
movq 0x3742b(%rip), %rcx     # 0x69a90
movq %rcx, 0x78(%rax)
movl $0x4a8, 0x88(%rax)      # imm = 0x4A8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: ClientEndServerFrames
void ClientEndServerFrames (void)
{
	int		i;
	edict_t	*ent;

	// calc the player views now that all pushing
	// and damage has been added
	for (i=0 ; i<maxclients->value ; i++)
	{
		ent = g_edicts + 1 + i;
		if (!ent->inuse || !ent->client)
			continue;
		ClientEndServerFrame (ent);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x36b6a(%rip), %rbx     # 0x69530
movq (%rbx), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x32a20
movl $0x4a8, %r14d           # imm = 0x4A8
movl $0x1, %ebp
movq 0x36b70(%rip), %r15     # 0x69558
movq (%r15), %rdi
cmpl $0x0, 0x60(%rdi,%r14)
je 0x32a03
cmpq $0x0, 0x58(%rdi,%r14)
je 0x32a03
addq %r14, %rdi
callq 0x18b00
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movq (%rbx), %rax
movss 0x20(%rax), %xmm1
addq $0x4a8, %r14            # imm = 0x4A8
incl %ebp
ucomiss %xmm0, %xmm1
ja 0x329e8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: CreateTargetChangeLevel
edict_t *CreateTargetChangeLevel(char *map)
{
	edict_t *ent;

	ent = G_Spawn ();
	ent->classname = "target_changelevel";
	Com_sprintf(level.nextmap, sizeof(level.nextmap), "%s", map);
	ent->map = level.nextmap;
	return ent;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x19710
movq %rax, %r14
leaq 0x21b10(%rip), %rax     # 0x54552
movq %rax, 0x138(%r14)
movl $0x88, %r15d
addq 0x3734a(%rip), %r15     # 0x69da0
leaq 0x20f50(%rip), %rdx     # 0x539ad
movq %r15, %rdi
movl $0x40, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x18e10
movq %r15, 0x270(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: Randomize_Map_List
void Randomize_Map_List(int Num_Of_Maps)
{
	int i;
	int Rand_Num;

	if (Num_Of_Maps > MAX_MAPS)
		Num_Of_Maps = MAX_MAPS;

	for (i = 0; i < MAX_MAPS; i++)
		Maps_Picked[i] = 0;

	for (i = 1; i < Num_Of_Maps; i++)
	{
		Rand_Num = rand() % (Num_Of_Maps - 2);
		while (Maps_Picked[Rand_Num])
		{
			Rand_Num++;
			if (Rand_Num == Num_Of_Maps)
				Rand_Num = 0;
		}

		Maps_Picked[Rand_Num] = i;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
movq 0x373a8(%rip), %rbx     # 0x69e38
xorl %r14d, %r14d
movl $0x258, %edx            # imm = 0x258
movq %rbx, %rdi
xorl %esi, %esi
callq 0x18880
movl $0x12c, %r15d           # imm = 0x12C
cmpl %r15d, %ebp
cmovll %ebp, %r15d
cmpl $0x2, %ebp
jl 0x32aeb
leal -0x2(%r15), %ebp
movl $0x1, %r12d
callq 0x19a20
cltd
idivl %ebp
movslq %edx, %rax
cmpw $0x0, (%rbx,%rax,2)
je 0x32adb
incl %edx
cmpl %r15d, %edx
cmovel %r14d, %edx
jmp 0x32ac6
leaq (%rbx,%rax,2), %rax
movw %r12w, (%rax)
incl %r12d
cmpl %r15d, %r12d
jne 0x32abe
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: getRandomMapByPlayerCount
MapInfo *getRandomMapByPlayerCount(int count) {
	MapInfo *criteriaList = NULL;
	MapInfo *clPtr = NULL;
	int mapCounter = 0;
	int randNum;

	for(int i = 0; maplist[i].mapname; i++) {
		if (maplist[i].minplayers > count || maplist[i].maxplayers < count) {
			gi.dprintf("Excluding %s due to min/max playercount\n", maplist[i].mapname);
			continue;
		}
		if (!criteriaList) {
			criteriaList = clPtr = &maplist[i];			
		} else {
			clPtr->next = &maplist[i];
			clPtr = clPtr->next;
			clPtr->next = NULL;
		}
		mapCounter++;
	}

	//QW// Added. This should never happen.
	if (!clPtr || !criteriaList) {
		gi.error("%s line %i: NULL pointer error.", __func__, __LINE__);
		abort(); // Shut up compiler.
	}

	clPtr->next = criteriaList;
	srand(time(0));
	randNum = rand() % (mapCounter - 2);
	for(int i = 0; i < randNum; i++) 
		clPtr = clPtr->next;	
	return clPtr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x36cc2(%rip), %r13     # 0x697c8
movq (%r13), %rsi
testq %rsi, %rsi
je 0x32b70
movl %edi, %ebp
leaq 0x2563f(%rip), %r14     # 0x58157
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ebx, %ebx
cmpl %ebp, 0x8(%r13)
jg 0x32b2c
cmpl %ebp, 0xc(%r13)
jge 0x32b3d
movq %r14, %rdi
xorl %eax, %eax
movq 0x36ac8(%rip), %rcx     # 0x69600
callq *0x8(%rcx)
jmp 0x32b5d
movq %r13, %rax
testq %r12, %r12
je 0x32b54
movq %r13, 0x10(%rbx)
movq $0x0, 0x10(%r13)
movq %r12, %rax
incl %r15d
movq %r13, %rbx
movq %rax, %r12
movq 0x18(%r13), %rsi
addq $0x18, %r13
testq %rsi, %rsi
jne 0x32b20
addl $-0x2, %r15d
jmp 0x32b7b
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
xorl %ebx, %ebx
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x32bbe
testq %r12, %r12
je 0x32bbe
movq %r12, 0x10(%rbx)
xorl %edi, %edi
callq 0x18df0
movl %eax, %edi
callq 0x189f0
callq 0x19a20
cltd
idivl %r15d
testl %edx, %edx
jle 0x32bac
movq 0x10(%rbx), %rbx
decl %edx
jne 0x32ba4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x36a3b(%rip), %rcx     # 0x69600
leaq 0x255b4(%rip), %rdi     # 0x58180
leaq 0x255cd(%rip), %rsi     # 0x581a0
movl $0x138, %edx            # imm = 0x138
xorl %eax, %eax
callq *0x38(%rcx)
callq 0x18190
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: playerCount
int playerCount() {
        edict_t * player = NULL;
        unsigned int num_players = 0;

        player = ctf_findplayer(NULL, NULL, CTF_TEAM_IGNORETEAM);
        while (player)
        {
                num_players++;
                player = ctf_findplayer(player, NULL, CTF_TEAM_IGNORETEAM);
        }
        return (num_players);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
testq %rax, %rax
je 0x32c10
xorl %ebx, %ebx
incl %ebx
movq %rax, %rdi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
testq %rax, %rax
jne 0x32bfa
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: Check_Made_Table
void Check_Made_Table(edict_t *cl_ent)
{
long score;
int index = 0;
int i;

   	score = stats_get(cl_ent, STATS_SCORE);

	if(score <= Highscore_Table[MAX_HIGHSCORE_ENTRIES - 1].Score)
		return;


	for(i = 0; i < MAX_HIGHSCORE_ENTRIES; i++)
	{
		if(score > Highscore_Table[i].Score)
		{
			index = i;
			break;
		}
	}

	for(i = MAX_HIGHSCORE_ENTRIES - 1; i > index; i--)
	{
		Highscore_Table[i].Score = Highscore_Table[i - 1].Score;
		strcpy(Highscore_Table[i].Player, Highscore_Table[i-1].Player);
	}


	Highscore_Table[index].Score = score;
	strcpy(Highscore_Table[i].Player, cl_ent->client->pers.netname);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3, %esi
callq 0x18030
movq 0x36e5d(%rip), %r12     # 0x69aa8
cmpq 0x110(%r12), %rax
jle 0x32cec
movq %rax, %r14
leaq 0x20(%r12), %rcx
xorl %eax, %eax
cmpq (%rcx), %r14
jg 0x32c77
incq %rax
addq $0x28, %rcx
cmpq $0x7, %rax
jne 0x32c63
xorl %eax, %eax
movl $0x6, %ebp
movl %eax, %r13d
cmpl $0x5, %eax
ja 0x32cb1
movl $0xc8, %r15d
addq 0x36e17(%rip), %r15     # 0x69aa8
decq %rbp
movq 0x20(%r15), %rax
leaq 0x28(%r15), %rdi
movq %rax, 0x48(%r15)
movq %r15, %rsi
callq 0x182a0
addq $-0x28, %r15
cmpq %r13, %rbp
ja 0x32c91
leaq (,%r13,4), %rax
addq %r13, %rax
movq %r14, 0x20(%r12,%rax,8)
leaq (,%rbp,4), %rax
addq %rbp, %rax
leaq (%r12,%rax,8), %rdi
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x182a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: Write_Highscore_Table
void Write_Highscore_Table(void)
{
edict_t     *cl_ent;
char Buf[512];
FILE *fp;
int i;
size_t Obj_Read;

	if(maplistindex < 0)
		return;

	sprintf(Buf, "%s/%s.scr", gamedir->string, level.mapname);


	fp = fopen(Buf, "rb");

	if(fp == 0)
		Create_New_File();
	else
	{
		Obj_Read = fread(Highscore_Table, sizeof(HIGHSCORE_STATS_TYPE), MAX_HIGHSCORE_ENTRIES, fp);
		if(Obj_Read < MAX_HIGHSCORE_ENTRIES)
		{
			fclose(fp);
			Create_New_File();
		}
	}

	fp = fopen(Buf, "wb");
	if(fp == 0)
		return;


    for(i = 0; i < game.maxclients; i++)
    {
        cl_ent = g_edicts + 1 + i;
		Check_Made_Table(cl_ent);
    }

	
	fwrite(Highscore_Table, sizeof(HIGHSCORE_STATS_TYPE), MAX_HIGHSCORE_ENTRIES, fp);
	fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq 0x370c6(%rip), %rax     # 0x69dd8
cmpl $0x0, (%rax)
js 0x32e29
movq 0x3718e(%rip), %rax     # 0x69eb0
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq 0x37070(%rip), %rcx     # 0x69da0
addq $0x48, %rcx
leaq 0x2547f(%rip), %rsi     # 0x581ba
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19700
leaq 0x25475(%rip), %rsi     # 0x581c4
movq %rbx, %rdi
callq 0x19470
testq %rax, %rax
je 0x32d86
movq %rax, %rbx
movq 0x36d42(%rip), %rdi     # 0x69aa8
movl $0x28, %esi
movl $0x7, %edx
movq %rax, %rcx
callq 0x183f0
cmpq $0x6, %rax
ja 0x32d9e
movq %rbx, %rdi
callq 0x185a0
movq 0x36d1b(%rip), %rdi     # 0x69aa8
movq 0x369bc(%rip), %rsi     # 0x69750
movl $0x118, %edx            # imm = 0x118
callq 0x18c80
leaq 0x25422(%rip), %rsi     # 0x581c7
movq %rsp, %rdi
callq 0x19470
testq %rax, %rax
je 0x32e29
movq %rax, %rbx
movq 0x36f84(%rip), %r14     # 0x69d40
cmpl $0x0, 0x610(%r14)
jle 0x32df8
movl $0x4a8, %r15d           # imm = 0x4A8
xorl %r12d, %r12d
movq 0x36782(%rip), %r13     # 0x69558
movq (%r13), %rdi
addq %r15, %rdi
callq 0x185d0
incq %r12
movslq 0x610(%r14), %rax
addq $0x4a8, %r15            # imm = 0x4A8
cmpq %rax, %r12
jl 0x32dd6
movq 0x36ca9(%rip), %rdi     # 0x69aa8
movl $0x28, %esi
movl $0x7, %edx
movq %rbx, %rcx
callq 0x19720
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x185a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: One_Man_Left
int One_Man_Left(void)
{
edict_t *cl_ent;
int i;
int Living_People = 0;

	for(i = 0; i < game.maxclients; i++)
    {
        cl_ent = g_edicts + 1 + i;

		if(cl_ent->health > 0)
			Living_People++;

		if(Living_People > 1)
			return(false);
	}

	return(true);

}

// Assembly:
movq 0x36eeb(%rip), %rax     # 0x69d40
movslq 0x610(%rax), %rdx
movl $0x1, %eax
testq %rdx, %rdx
jle 0x32ea0
movq 0x366eb(%rip), %rcx     # 0x69558
movq (%rcx), %rcx
imulq $0x4a8, %rdx, %rdx      # imm = 0x4A8
xorl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
xorl %edi, %edi
cmpl $0x0, 0x6fc(%rcx,%rsi)
setg %dil
addl %r8d, %edi
cmpl $0x2, %edi
jae 0x32ea1
addq $0x4a8, %rsi            # imm = 0x4A8
cmpq %rsi, %rdx
jne 0x32e7b
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: Declare_Railgun_Victor
edict_t *Declare_Railgun_Victor(void)
{
int Highscore = -9999;
edict_t *Winner;
edict_t *cl_ent;
int i;
int score;
    
	Winner = g_edicts + 1;

	for(i = 0; i < game.maxclients; i++)
    {
        cl_ent = g_edicts + 1 + i;

		if(cl_ent->health <= 0)
			continue;

		score = stats_get(cl_ent, STATS_SCORE);

    	if(score > Highscore)
		{
			Winner = cl_ent;
			Highscore = score;
		}
    }

	return(Winner);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x366a2(%rip), %rax     # 0x69558
movl $0x4a8, %r12d           # imm = 0x4A8
movq (%rax), %rbx
addq %r12, %rbx
movq 0x36e77(%rip), %r13     # 0x69d40
cmpl $0x0, 0x610(%r13)
jle 0x32f24
movl $0xffffd8f1, %r15d      # imm = 0xFFFFD8F1
xorl %ebp, %ebp
movq 0x36676(%rip), %rax     # 0x69558
movq (%rax), %r14
cmpl $0x0, 0x254(%r14,%r12)
jle 0x32f0e
addq %r12, %r14
movq %r14, %rdi
movl $0x3, %esi
callq 0x18030
cmpl %eax, %r15d
cmovlq %r14, %rbx
cmovgl %r15d, %eax
movl %eax, %r15d
incq %rbp
movslq 0x610(%r13), %rax
addq $0x4a8, %r12            # imm = 0x4A8
cmpq %rax, %rbp
jl 0x32edb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: CheckNeedPass
void CheckNeedPass (void)
{
	int need;

	// if password or spectator_password has changed, update needpass
	// as needed
	if (password->modified || spectator_password->modified) 
	{
		password->modified = spectator_password->modified = false;

		need = 0;

		if (*password->string && Q_stricmp(password->string, "none"))
			need |= 1;
		if (*spectator_password->string && Q_stricmp(spectator_password->string, "none"))
			need |= 2;

		gi.cvar_set("needpass", va("%d", need));
	}
}

// Assembly:
movq 0x36710(%rip), %rax     # 0x69858
movq (%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x33165
movq 0x36ad0(%rip), %rcx     # 0x69c28
movq (%rcx), %rcx
cmpl $0x0, 0x1c(%rcx)
je 0x331ed
pushq %r14
pushq %rbx
pushq %rax
movq 0x36ab8(%rip), %r14     # 0x69c28
movq (%r14), %rcx
xorl %ebx, %ebx
movl %ebx, 0x1c(%rcx)
movl %ebx, 0x1c(%rax)
movq 0x8(%rax), %rdi
cmpb $0x0, (%rdi)
je 0x33197
leaq 0x2504d(%rip), %rsi     # 0x581d8
callq 0x18690
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movq (%r14), %rax
movq 0x8(%rax), %rdi
cmpb $0x0, (%rdi)
je 0x331b9
leaq 0x2502e(%rip), %rsi     # 0x581d8
callq 0x18690
leal 0x2(%rbx), %ecx
testl %eax, %eax
cmovel %ebx, %ecx
movl %ecx, %ebx
movq 0x36440(%rip), %rax     # 0x69600
movq 0x128(%rax), %r14
leaq 0x206b8(%rip), %rdi     # 0x53886
movl %ebx, %esi
xorl %eax, %eax
callq 0x19340
leaq 0x24fff(%rip), %rdi     # 0x581dd
movq %rax, %rsi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: ExitLevel
void ExitLevel (void)
{
	int		i;
	edict_t	*ent;
	char	command [MAX_INFO_STRING];

	Com_sprintf (command, sizeof(command), "gamemap \"%s\"\n", level.changemap);

	gi.AddCommandString (command);
	level.changemap = NULL;
	level.exitintermission = 0;
	level.intermissiontime = 0;
	ClientEndServerFrames ();

	// clear some things before going to next level
	for (i = 0; i < maxclients->value; i++)
	{
		ent = g_edicts + 1 + i;
		if (ent && ent->inuse)
		{
			if (ent->health > ent->client->pers.max_health)
				ent->health = ent->client->pers.max_health;
		}
	}

	// clean up stats before start of next level
	stats_cleanup(); // STATS - LM_Hati
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq 0x36896(%rip), %r14     # 0x69da0
movq 0xd0(%r14), %rcx
leaq 0x213ab(%rip), %rdx     # 0x548c3
xorl %ebp, %ebp
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x18e10
movq 0x360cd(%rip), %rax     # 0x69600
movq %rbx, %rdi
callq *0x150(%rax)
movq $0x0, 0xd0(%r14)
movl %ebp, 0xd8(%r14)
movl %ebp, 0xc8(%r14)
callq 0x18f90
movq 0x35fcf(%rip), %rax     # 0x69530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x335b5
movq 0x35fe0(%rip), %rcx     # 0x69558
movl $0x6fc, %eax            # imm = 0x6FC
addq (%rcx), %rax
movl $0x1, %ecx
cmpl $0x0, -0x1f4(%rax)
je 0x335a1
movq -0x1fc(%rax), %rdx
movl 0x30c(%rdx), %edx
cmpl %edx, (%rax)
jle 0x335a1
movl %edx, (%rax)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
addq $0x4a8, %rax            # imm = 0x4A8
incl %ecx
ucomiss %xmm1, %xmm0
ja 0x33585
xorl %eax, %eax
callq 0x18f70
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: VelocityForDamage
void VelocityForDamage (int damage, vec3_t v)
{
	v[0] = 100.0 * crandom();
	v[1] = 100.0 * crandom();
	v[2] = 200.0 + 100.0 * random();

	if (damage < 50)
		VectorScale (v, 0.7f, v);
	else 
		VectorScale (v, 1.2f, v);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
cmpl $0x32, %edi
setl %r14b
callq 0x19a20
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x20c57(%rip), %xmm0    # 0x54288
cvtss2sd %xmm0, %xmm0
addsd 0x23573(%rip), %xmm0    # 0x56bb0
addsd %xmm0, %xmm0
mulsd 0x24bff(%rip), %xmm0    # 0x58248
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx)
callq 0x19a20
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x20c21(%rip), %xmm0    # 0x54288
cvtss2sd %xmm0, %xmm0
addsd 0x2353d(%rip), %xmm0    # 0x56bb0
addsd %xmm0, %xmm0
mulsd 0x24bc9(%rip), %xmm0    # 0x58248
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rbx)
callq 0x19a20
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x20bea(%rip), %xmm0    # 0x54288
cvtss2sd %xmm0, %xmm0
mulsd 0x24b9e(%rip), %xmm0    # 0x58248
addsd 0x24b9e(%rip), %xmm0    # 0x58250
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rbx)
leaq 0x24b96(%rip), %rax     # 0x58258
movss (%rax,%r14,4), %xmm0
movq %rbx, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x189d0
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ClipGibVelocity
void ClipGibVelocity (edict_t *ent)
{
	if (ent->velocity[0] < -300)
		ent->velocity[0] = -300;
	else if (ent->velocity[0] > 300)
		ent->velocity[0] = 300;
	if (ent->velocity[1] < -300)
		ent->velocity[1] = -300;
	else if (ent->velocity[1] > 300)
		ent->velocity[1] = 300;
	if (ent->velocity[2] < 200)
		ent->velocity[2] = 200;	// always some upwards
	else if (ent->velocity[2] > 500)
		ent->velocity[2] = 500;
}

// Assembly:
movss 0x1c0(%rdi), %xmm1
movss 0x24b4d(%rip), %xmm0    # 0x58234
ucomiss %xmm1, %xmm0
ja 0x336f9
movss 0x237d4(%rip), %xmm0    # 0x56ec8
ucomiss %xmm0, %xmm1
jbe 0x33701
movss %xmm0, 0x1c0(%rdi)
movss 0x1c4(%rdi), %xmm1
movss 0x24b23(%rip), %xmm0    # 0x58234
ucomiss %xmm1, %xmm0
ja 0x33723
movss 0x237aa(%rip), %xmm0    # 0x56ec8
ucomiss %xmm0, %xmm1
jbe 0x3372b
movss %xmm0, 0x1c4(%rdi)
movss 0x1c8(%rdi), %xmm1
movss 0x20b69(%rip), %xmm0    # 0x542a4
ucomiss %xmm1, %xmm0
ja 0x3374d
movss 0x24af0(%rip), %xmm0    # 0x58238
ucomiss %xmm0, %xmm1
jbe 0x33755
movss %xmm0, 0x1c8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: gib_think
void gib_think (edict_t *self)
{
	self->s.frame++;
	self->nextthink = level.time + FRAMETIME;

	if (self->s.frame == 10)
	{
		self->think = G_FreeEdict;
		self->nextthink = level.time + 8 + random()*10;
	}
}

// Assembly:
movl 0x38(%rdi), %eax
incl %eax
movl %eax, 0x38(%rdi)
movq 0x3663b(%rip), %rcx     # 0x69da0
movss 0x4(%rcx), %xmm1
movss 0x20b1e(%rip), %xmm0    # 0x54290
addss %xmm1, %xmm0
movss %xmm0, 0x200(%rdi)
cmpl $0xa, %eax
jne 0x337db
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x35c9e(%rip), %rax     # 0x69430
movq %rax, 0x210(%rdi)
addss 0x20757(%rip), %xmm1    # 0x53ef8
movss %xmm1, 0xc(%rsp)
callq 0x19a20
andl $0x7fff, %eax           # imm = 0x7FFF
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x20ac8(%rip), %xmm0    # 0x54288
mulss 0x2074c(%rip), %xmm0    # 0x53f14
addss 0xc(%rsp), %xmm0
movss %xmm0, 0x200(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: gib_touch
void gib_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	vec3_t	normal_angles, right;

	if (!self->groundentity)
		return;

	self->touch = NULL;

	if (plane)
	{
		gi.sound (self, CHAN_VOICE, gi.soundindex ("misc/fhit3.wav"), 1, ATTN_NORM, 0);

		vectoangles (plane->normal, normal_angles);
		AngleVectors (normal_angles, NULL, right, NULL);
		vectoangles (right, self->s.angles);

		if (self->s.modelindex == sm_meat_index)
		{
			self->s.frame++;
			self->think = gib_think;
			self->nextthink = level.time + FRAMETIME;
		}
	}
}

// Assembly:
cmpq $0x0, 0x2b8(%rdi)
je 0x338b1
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq $0x0, 0x220(%rdi)
testq %rdx, %rdx
je 0x338a8
movq 0x35dec(%rip), %rax     # 0x69600
movq 0x20(%rax), %r15
leaq 0x24b01(%rip), %rdi     # 0x58320
callq *0x48(%rax)
movss 0x206fe(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x2, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
leaq 0x14(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x190d0
leaq 0x8(%rsp), %r14
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x183a0
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x190d0
movl 0x28(%rbx), %eax
movq 0x36779(%rip), %rcx     # 0x69ff0
cmpl (%rcx), %eax
jne 0x338a8
incl 0x38(%rbx)
movq 0x36393(%rip), %rax     # 0x69c18
movq %rax, 0x210(%rbx)
movq 0x3650d(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x209f0(%rip), %xmm0    # 0x54290
movss %xmm0, 0x200(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ThrowHead
void ThrowHead (edict_t *self, char *gibname, int damage, int type)
{
	vec3_t	vd;
	float	vscale;

	self->s.skinnum = 0;
	self->s.frame = 0;
	VectorClear (self->mins);
	VectorClear (self->maxs);

	self->s.modelindex2 = 0;
	gi.setmodel (self, gibname);
	self->solid = SOLID_NOT;
	self->s.effects |= EF_GIB;
	self->s.effects &= ~EF_FLIES;
	self->s.sound = 0;
	self->flags |= FL_NO_KNOCKBACK;
	self->svflags &= ~SVF_MONSTER;
	self->takedamage = DAMAGE_YES;
	self->die = gib_die;

	if (type == GIB_ORGANIC)
	{
		self->movetype = MOVETYPE_TOSS;
		self->touch = gib_touch;
		vscale = 0.5;
	}
	else
	{
		self->movetype = MOVETYPE_BOUNCE;
		vscale = 1.0;
	}

	VelocityForDamage (damage, vd);
	VectorMA (self->velocity, vscale, vd, self->velocity);
	ClipGibVelocity (self);

	self->avelocity[YAW] = crandom()*600;

	self->think = G_FreeEdict;
	self->nextthink = level.time + 10 + random()*10;

	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0x38(%rdi)
movl %r12d, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xcc(%rdi)
movq %r12, 0xdc(%rdi)
movq 0x35a03(%rip), %r15     # 0x69600
callq *0x58(%r15)
movl %r12d, 0x108(%rbx)
movl $0xffffbffd, %eax       # imm = 0xFFFFBFFD
andl 0x40(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x40(%rbx)
movl %r12d, 0x4c(%rbx)
orb $0x8, 0x11d(%rbx)
andb $-0x5, 0xc8(%rbx)
movl $0x1, 0x27c(%rbx)
movq 0x35fff(%rip), %rax     # 0x69c38
movq %rax, 0x238(%rbx)
testl %r14d, %r14d
je 0x33c59
movl $0x9, 0x118(%rbx)
movss 0x202d1(%rip), %xmm0    # 0x53f28
jmp 0x33c79
movl $0x7, 0x118(%rbx)
movq 0x359be(%rip), %rax     # 0x69628
movq %rax, 0x220(%rbx)
movss 0x2178b(%rip), %xmm0    # 0x55404
movss %xmm0, (%rsp)
leaq 0x4(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x19600
leaq 0x1c0(%rbx), %rdi
movss (%rsp), %xmm0
movq %r14, %rsi
movq %rdi, %rdx
callq 0x19770
movq %rbx, %rdi
callq 0x19030
callq 0x19a20
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x205c1(%rip), %xmm0    # 0x54288
cvtss2sd %xmm0, %xmm0
addsd 0x22edd(%rip), %xmm0    # 0x56bb0
addsd %xmm0, %xmm0
mulsd 0x24581(%rip), %xmm0    # 0x58260
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1d0(%rbx)
movq 0x3573e(%rip), %rax     # 0x69430
movq %rax, 0x210(%rbx)
movq 0x360a0(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x20207(%rip), %xmm0    # 0x53f14
movss %xmm0, (%rsp)
callq 0x19a20
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x20560(%rip), %xmm0    # 0x54288
mulss 0x201e4(%rip), %xmm0    # 0x53f14
addss (%rsp), %xmm0
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
callq *0x90(%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ThrowClientHead
void ThrowClientHead (edict_t *self, int damage)
{
	vec3_t	vd;
	char	*gibname;

	if (rand()&1)
	{
		gibname = "models/objects/gibs/head2/tris.md2";
		self->s.skinnum = 1;		// second skin is player
	}
	else
	{
		gibname = "models/objects/gibs/skull/tris.md2";
		self->s.skinnum = 0;
	}

	self->s.origin[2] += 32;
	self->s.frame = 0;
	gi.setmodel (self, gibname);
	VectorSet (self->mins, -16, -16, 0);
	VectorSet (self->maxs, 16, 16, 16);

	self->takedamage = DAMAGE_NO;
	self->solid = SOLID_NOT;
	self->s.effects = EF_GIB;
	self->s.sound = 0;
	self->flags |= FL_NO_KNOCKBACK;

	self->movetype = MOVETYPE_BOUNCE;
	VelocityForDamage (damage, vd);
	VectorAdd (self->velocity, vd, self->velocity);

	if (self->client)	// bodies in the queue don't have a client anymore
	{
		self->client->anim_priority = ANIM_DEATH;
		self->client->anim_end = self->s.frame;
	}
	else
	{
		self->think = NULL;
		self->nextthink = 0;
	}

	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x19a20
andl $0x1, %eax
leaq 0x245e0(%rip), %rcx     # 0x58352
leaq 0x245b6(%rip), %rsi     # 0x5832f
cmoveq %rcx, %rsi
movl %eax, 0x3c(%rbx)
movss 0xc(%rbx), %xmm0
addss 0x206af(%rip), %xmm0    # 0x5443c
movss %xmm0, 0xc(%rbx)
xorl %r14d, %r14d
movl %r14d, 0x38(%rbx)
movq 0x35860(%rip), %r15     # 0x69600
movq %rbx, %rdi
callq *0x58(%r15)
movaps 0x244d2(%rip), %xmm0    # 0x58280
movups %xmm0, 0xcc(%rbx)
movabsq $0x4180000041800000, %rax # imm = 0x4180000041800000
movq %rax, 0xdc(%rbx)
movl %r14d, 0x27c(%rbx)
movl %r14d, 0x108(%rbx)
movl $0x2, 0x40(%rbx)
movl %r14d, 0x4c(%rbx)
orb $0x8, 0x11d(%rbx)
movl $0x9, 0x118(%rbx)
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x19600
movss 0x1c0(%rbx), %xmm0
addss (%r14), %xmm0
movss %xmm0, 0x1c0(%rbx)
movss 0x1c4(%rbx), %xmm0
addss 0x4(%r14), %xmm0
movss %xmm0, 0x1c4(%rbx)
movss 0x1c8(%rbx), %xmm0
addss 0x8(%r14), %xmm0
movss %xmm0, 0x1c8(%rbx)
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x33e5e
movl $0x5, 0xef8(%rax)
movl 0x38(%rbx), %ecx
movl %ecx, 0xef4(%rax)
jmp 0x33e73
movq $0x0, 0x210(%rbx)
movl $0x0, 0x200(%rbx)
movq %rbx, %rdi
callq *0x90(%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: BecomeExplosion1
void BecomeExplosion1 (edict_t *self)
{
	if (!self->dontfree)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_EXPLOSION1);
		gi.WritePosition (self->s.origin);
		gi.multicast (self->s.origin, MULTICAST_PVS);
		
		G_FreeEdict (self);
	}
}

// Assembly:
cmpl $0x0, 0x49c(%rdi)
je 0x340e6
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3550b(%rip), %r15     # 0x69600
movl $0x3, %edi
callq *0xc8(%r15)
movl $0x5, %edi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
movq %r14, %rdi
movl $0x2, %esi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: BecomeExplosion2
void BecomeExplosion2 (edict_t *self)
{
	if (!self->dontfree)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_EXPLOSION2);
		gi.WritePosition (self->s.origin);
		gi.multicast (self->s.origin, MULTICAST_PVS);

		G_FreeEdict (self);
	}
}

// Assembly:
cmpl $0x0, 0x49c(%rdi)
je 0x34141
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x354b0(%rip), %r15     # 0x69600
movl $0x3, %edi
callq *0xc8(%r15)
movl $0x6, %edi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
movq %r14, %rdi
movl $0x2, %esi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: path_corner_touch
void path_corner_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	vec3_t		v;
	edict_t		*next;

	if (other->movetarget != self)
		return;
	
	if (other->enemy)
		return;

	if (self->pathtarget)
	{
		char *savetarget;

		savetarget = self->target;
		self->target = self->pathtarget;
		G_UseTargets (self, other);
		self->target = savetarget;
	}

	if (self->target)
		next = G_PickTarget(self->target);
	else
		next = NULL;

	if ((next) && (next->spawnflags & 1))
	{
		VectorCopy (next->s.origin, v);
		v[2] += next->mins[2];
		v[2] -= other->mins[2];
		VectorCopy (v, other->s.origin);
		next = G_PickTarget(next->target);
		other->s.event = EV_OTHER_TELEPORT;
	}

	other->goalentity = other->movetarget = next;

	if (self->wait)
	{
		other->monsterinfo.pausetime = level.time + self->wait;
		other->monsterinfo.stand (other);
		return;
	}

	if (!other->movetarget)
	{
		other->monsterinfo.pausetime = level.time + 100000000;
		other->monsterinfo.stand (other);
	}
	else
	{
		VectorSubtract (other->goalentity->s.origin, other->s.origin, v);
		other->ideal_yaw = vectoyaw (v);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq %rdi, 0x1f0(%rsi)
jne 0x341ae
cmpq $0x0, 0x2a0(%rsi)
je 0x341b8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq 0x170(%rdi), %rax
testq %rax, %rax
je 0x341ea
movq 0x150(%rbx), %r14
movq %rax, 0x150(%rbx)
movq %rbx, %rdi
movq %rsi, %r15
callq 0x198f0
movq %r15, %rsi
movq %r14, 0x150(%rbx)
movq 0x150(%rbx), %rdi
testq %rdi, %rdi
je 0x34203
movq %rsi, %r14
callq 0x18350
movq %r14, %rsi
jmp 0x34205
xorl %eax, %eax
testq %rax, %rax
je 0x3427b
testb $0x1, 0x140(%rax)
je 0x3427d
movss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x8(%rax), %xmm1
movss %xmm1, 0x8(%rsp)
movss 0xc(%rax), %xmm2
movss %xmm2, 0xc(%rsp)
addss 0xd4(%rax), %xmm2
movss %xmm2, 0xc(%rsp)
subss 0xd4(%rsi), %xmm2
movss %xmm2, 0xc(%rsp)
movss %xmm0, 0x4(%rsi)
movss %xmm1, 0x8(%rsi)
movss %xmm2, 0xc(%rsi)
movq 0x150(%rax), %rdi
movq %rsi, %r14
callq 0x18350
movq %r14, %rsi
movl $0x7, 0x50(%r14)
jmp 0x3427d
xorl %eax, %eax
movq %rax, 0x1f0(%rsi)
movq %rax, 0x1e8(%rsi)
movss 0x2f8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3429d
jnp 0x342c3
movq 0x35afc(%rip), %rax     # 0x69da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x420(%rsi)
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x3d0(%rsi)
testq %rax, %rax
je 0x3430e
movss 0x4(%rax), %xmm0
subss 0x4(%rsi), %xmm0
leaq 0x4(%rsp), %rdi
movss %xmm0, (%rdi)
movss 0x8(%rax), %xmm0
subss 0x8(%rsi), %xmm0
movss %xmm0, 0x4(%rdi)
movss 0xc(%rax), %xmm0
subss 0xc(%rsi), %xmm0
movss %xmm0, 0x8(%rdi)
movq %rsi, %rbx
callq 0x18070
movss %xmm0, 0x1fc(%rbx)
jmp 0x341ae
movq 0x35a8b(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x23f1e(%rip), %xmm0    # 0x58240
jmp 0x342a9
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_path_corner
void SP_path_corner (edict_t *self)
{
	if (!self->targetname)
	{
		gi.dprintf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

	self->solid = SOLID_TRIGGER;
	self->touch = path_corner_touch;
	VectorSet (self->mins, -8, -8, -8);
	VectorSet (self->maxs, 8, 8, 8);
	self->svflags |= SVF_NOCLIENT;
	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x158(%rdi)
je 0x3438a
movl $0x1, 0x108(%rbx)
movq 0x35aaa(%rip), %rax     # 0x69df0
movq %rax, 0x220(%rbx)
movaps 0x23f3c(%rip), %xmm0    # 0x58290
movups %xmm0, 0xcc(%rbx)
movabsq $0x4100000041000000, %rax # imm = 0x4100000041000000
movq %rax, 0xdc(%rbx)
orb $0x1, 0xc8(%rbx)
movq 0x35286(%rip), %rax     # 0x69600
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
movq 0x3526f(%rip), %rax     # 0x69600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x23fd7(%rip), %rdi     # 0x5837c
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: point_combat_touch
void point_combat_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	edict_t	*activator;

	if (other->movetarget != self)
		return;

	if (self->target)
	{
		other->target = self->target;
		other->goalentity = other->movetarget = G_PickTarget(other->target);
		if (!other->goalentity)
		{
			gi.dprintf("%s at %s target %s does not exist\n", self->classname, vtos(self->s.origin), self->target);
			other->movetarget = self;
		}
		self->target = NULL;
	}
	else if ((self->spawnflags & 1) && !(other->flags & (FL_SWIM|FL_FLY)))
	{
		other->monsterinfo.pausetime = level.time + 100000000;
		other->monsterinfo.aiflags |= AI_STAND_GROUND;
		other->monsterinfo.stand (other);
	}

	if (other->movetarget == self)
	{
		other->target = NULL;
		other->movetarget = NULL;
		other->goalentity = other->enemy;
		other->monsterinfo.aiflags &= ~AI_COMBAT_POINT;
	}

	if (self->pathtarget)
	{
		char *savetarget;

		savetarget = self->target;
		self->target = self->pathtarget;
		if (other->enemy && other->enemy->client)
			activator = other->enemy;
		else if (other->oldenemy && other->oldenemy->client)
			activator = other->oldenemy;
		else if (other->activator && other->activator->client)
			activator = other->activator;
		else
			activator = other;
		G_UseTargets (self, activator);
		self->target = savetarget;
	}
}

// Assembly:
cmpq %rdi, 0x1f0(%rsi)
je 0x343c6
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x34447
movq %rdi, 0x150(%r14)
callq 0x18350
movq %rax, 0x1f0(%r14)
movq %rax, 0x1e8(%r14)
testq %rax, %rax
jne 0x3443a
movq 0x351fa(%rip), %rax     # 0x69600
movq 0x8(%rax), %r12
movq 0x138(%rbx), %r15
leaq 0x4(%rbx), %rdi
callq 0x190a0
movq 0x150(%rbx), %rcx
leaq 0x23f7a(%rip), %rdi     # 0x583a2
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r12
movq %rbx, 0x1f0(%r14)
movq $0x0, 0x150(%rbx)
jmp 0x34489
testb $0x1, 0x140(%rbx)
je 0x34489
testb $0x3, 0x11c(%r14)
jne 0x34489
movq 0x3593f(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x23dd2(%rip), %xmm0    # 0x58240
movss %xmm0, 0x420(%r14)
orb $0x1, 0x3c0(%r14)
movq %r14, %rdi
callq *0x3d0(%r14)
cmpq %rbx, 0x1f0(%r14)
jne 0x344b8
xorl %eax, %eax
movq %rax, 0x150(%r14)
movq %rax, 0x1f0(%r14)
movq 0x2a0(%r14), %rax
movq %rax, 0x1e8(%r14)
andb $-0x11, 0x3c1(%r14)
movq 0x170(%rbx), %rax
testq %rax, %rax
je 0x3451d
movq 0x150(%rbx), %r15
movq %rax, 0x150(%rbx)
movq 0x2a0(%r14), %rsi
testq %rsi, %rsi
je 0x344e5
cmpq $0x0, 0x58(%rsi)
jne 0x3450e
movq 0x2a8(%r14), %rsi
testq %rsi, %rsi
je 0x344f8
cmpq $0x0, 0x58(%rsi)
jne 0x3450e
movq 0x2b0(%r14), %rsi
testq %rsi, %rsi
je 0x3450b
cmpq $0x0, 0x58(%rsi)
jne 0x3450e
movq %r14, %rsi
movq %rbx, %rdi
callq 0x198f0
movq %r15, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_point_combat
void SP_point_combat (edict_t *self)
{
	if (deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}
	self->solid = SOLID_TRIGGER;
	self->touch = point_combat_touch;
	VectorSet (self->mins, -8, -8, -16);
	VectorSet (self->maxs, 8, 8, 16);
	self->svflags = SVF_NOCLIENT;
	gi.linkentity (self);
}

// Assembly:
movq 0x35990(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x34542
jnp 0x34547
jmp 0x19a60
movl $0x1, %eax
movl %eax, 0x108(%rdi)
movq 0x3592f(%rip), %rcx     # 0x69e88
movq %rcx, 0x220(%rdi)
movaps 0x23d39(%rip), %xmm0    # 0x582a0
movups %xmm0, 0xcc(%rdi)
movabsq $0x4180000041000000, %rcx # imm = 0x4180000041000000
movq %rcx, 0xdc(%rdi)
movl %eax, 0xc8(%rdi)
movq 0x35074(%rip), %rax     # 0x69600
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_viewthing
void SP_viewthing(edict_t *ent)
{
	gi.dprintf ("viewthing spawned\n");

	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	ent->s.renderfx = RF_FRAMELERP;
	VectorSet (ent->mins, -16, -16, -24);
	VectorSet (ent->maxs, 16, 16, 32);
	ent->s.modelindex = gi.modelindex ("models/objects/banner/tris.md2");
	gi.linkentity (ent);
	ent->nextthink = level.time + 0.5;
	ent->think = TH_viewthing;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x35010(%rip), %r14     # 0x69600
leaq 0x23dce(%rip), %rdi     # 0x583c5
xorl %eax, %eax
callq *0x8(%r14)
movl $0x0, 0x118(%rbx)
movl $0x2, 0x108(%rbx)
movl $0x40, 0x44(%rbx)
movaps 0x23c91(%rip), %xmm0    # 0x582b0
movups %xmm0, 0xcc(%rbx)
movabsq $0x4200000041800000, %rax # imm = 0x4200000041800000
movq %rax, 0xdc(%rbx)
leaq 0x23d9a(%rip), %rdi     # 0x583d8
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x3574a(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x20da1(%rip), %xmm0    # 0x55404
movss %xmm0, 0x200(%rbx)
movq 0x34dd6(%rip), %rax     # 0x69448
movq %rax, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_light
void SP_light (edict_t *self)
{
	// no targeted lights in deathmatch, because they cause global messages
	if (!self->targetname || deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}

	if (self->style >= 32)
	{
		self->use = light_use;
		if (self->spawnflags & START_OFF)
			gi.configstring (CS_LIGHTS+self->style, "a");
		else
			gi.configstring (CS_LIGHTS+self->style, "m");
	}
}

// Assembly:
cmpq $0x0, 0x158(%rdi)
je 0x19a60
movq 0x357e5(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x346ed
jnp 0x346f2
jmp 0x19a60
movl 0x32c(%rdi), %eax
cmpl $0x20, %eax
jl 0x3472d
leaq 0x35(%rip), %rcx        # 0x34739
movq %rcx, 0x228(%rdi)
addl $0x320, %eax            # imm = 0x320
testb $0x1, 0x140(%rdi)
movq 0x34ee2(%rip), %rcx     # 0x69600
movq 0x30(%rcx), %rcx
jne 0x3472e
leaq 0x1eb34(%rip), %rsi     # 0x5325f
jmp 0x34735
retq
leaq 0x1ef93(%rip), %rsi     # 0x536c8
movl %eax, %edi
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: light_use
static void light_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->spawnflags & START_OFF)
	{
		gi.configstring (CS_LIGHTS+self->style, "m");
		self->spawnflags &= ~START_OFF;
	}
	else
	{
		gi.configstring (CS_LIGHTS+self->style, "a");
		self->spawnflags |= START_OFF;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x320, %edi            # imm = 0x320
movq 0x34eb7(%rip), %rax     # 0x69600
movq 0x30(%rax), %rax
addl 0x32c(%rbx), %edi
testb $0x1, 0x140(%rbx)
jne 0x34770
leaq 0x1ef65(%rip), %rsi     # 0x536c8
callq *%rax
movl 0x140(%rbx), %eax
orl $0x1, %eax
jmp 0x34782
leaq 0x1eae8(%rip), %rsi     # 0x5325f
callq *%rax
movl 0x140(%rbx), %eax
andl $-0x2, %eax
movl %eax, 0x140(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_wall_use
void func_wall_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->solid == SOLID_NOT)
	{
		self->solid = SOLID_BSP;
		self->svflags &= ~SVF_NOCLIENT;
		KillBox (self);
	}
	else
	{
		self->solid = SOLID_NOT;
		self->svflags |= SVF_NOCLIENT;
	}
	gi.linkentity (self);

	if (!(self->spawnflags & 2))
		self->use = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x108(%rdi)
je 0x347aa
movl $0x0, 0x108(%rbx)
orb $0x1, 0xc8(%rbx)
jmp 0x347c3
movl $0x3, 0x108(%rbx)
andb $-0x2, 0xc8(%rbx)
movq %rbx, %rdi
callq 0x18a90
movq 0x34e36(%rip), %rax     # 0x69600
movq %rbx, %rdi
callq *0x90(%rax)
testb $0x2, 0x140(%rbx)
jne 0x347e7
movq $0x0, 0x228(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_object_touch
void func_object_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	// only squash thing we fall on top of
	if (!plane)
		return;
	if (plane->normal[2] < 1.0)
		return;
	if (other->takedamage == DAMAGE_NO)
		return;
	T_Damage (other, self, self, vec3_origin, self->s.origin, vec3_origin, self->dmg, 1, 0, MOD_CRUSH);
}

// Assembly:
testq %rdx, %rdx
je 0x348ee
movss 0x1f67d(%rip), %xmm0    # 0x53f28
ucomiss 0x8(%rdx), %xmm0
ja 0x348ee
cmpl $0x0, 0x27c(%rsi)
je 0x348ee
pushq %rax
movq %rdi, %rax
leaq 0x4(%rdi), %r8
movl 0x280(%rdi), %r10d
movq 0x34e98(%rip), %rcx     # 0x69768
movq %rsi, %rdi
movq %rax, %rsi
movq %rax, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq %r10
callq 0x190f0
addq $0x20, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_object_use
void func_object_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->use = NULL;
	KillBox (self);
	func_object_release (self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3, 0x108(%rdi)
andb $-0x2, 0xc8(%rdi)
movq $0x0, 0x228(%rdi)
callq 0x18a90
movl $0x7, 0x118(%rbx)
movq 0x355f2(%rip), %rax     # 0x69f30
movq %rax, 0x220(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_object
void SP_func_object (edict_t *self)
{
	gi.setmodel (self, self->model);

	self->mins[0] += 1;
	self->mins[1] += 1;
	self->mins[2] += 1;
	self->maxs[0] -= 1;
	self->maxs[1] -= 1;
	self->maxs[2] -= 1;

	if (!self->dmg)
		self->dmg = 100;

	if (self->spawnflags == 0)
	{
		self->solid = SOLID_BSP;
		self->movetype = MOVETYPE_PUSH;
		self->think = func_object_release;
		self->nextthink = level.time + 2 * FRAMETIME;
	}
	else
	{
		self->solid = SOLID_NOT;
		self->movetype = MOVETYPE_PUSH;
		self->use = func_object_use;
		self->svflags |= SVF_NOCLIENT;
	}

	if (self->spawnflags & 2)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 4)
		self->s.effects |= EF_ANIM_ALLFAST;

	self->clipmask = MASK_MONSTERSOLID;

	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x34cab(%rip), %rax     # 0x69600
movq 0x120(%rdi), %rsi
movq %rax, %r14
callq *0x58(%rax)
movss 0x1f5be(%rip), %xmm0    # 0x53f28
movss 0xcc(%rbx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xcc(%rbx)
movss 0xd0(%rbx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xd0(%rbx)
addss 0xd4(%rbx), %xmm0
movss %xmm0, 0xd4(%rbx)
movss 0x22256(%rip), %xmm0    # 0x56c00
movss 0xd8(%rbx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xd8(%rbx)
movss 0xdc(%rbx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xdc(%rbx)
addss 0xe0(%rbx), %xmm0
movss %xmm0, 0xe0(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x349f5
movl $0x64, 0x280(%rbx)
movl 0x140(%rbx), %eax
testl %eax, %eax
je 0x34a2a
movl $0x0, 0x108(%rbx)
movl $0x2, 0x118(%rbx)
movq 0x3533e(%rip), %rcx     # 0x69d58
movq %rcx, 0x228(%rbx)
orb $0x1, 0xc8(%rbx)
jmp 0x34a68
movl $0x3, 0x108(%rbx)
movl $0x2, 0x118(%rbx)
movq 0x34ba3(%rip), %rcx     # 0x695e8
movq %rcx, 0x210(%rbx)
movq 0x3534d(%rip), %rcx     # 0x69da0
movss 0x4(%rcx), %xmm0
addss 0x22474(%rip), %xmm0    # 0x56ed4
movss %xmm0, 0x200(%rbx)
testb $0x2, %al
je 0x34a70
orb $0x10, 0x41(%rbx)
testb $0x4, %al
je 0x34a78
orb $0x20, 0x41(%rbx)
movl $0x2020003, 0x10c(%rbx) # imm = 0x2020003
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_explosive_respawn
void func_explosive_respawn (edict_t *self)
{
	gi.sound (self, CHAN_AUTO, gi.soundindex ("tank/thud.wav"), 1, ATTN_NORM, 0);
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->takedamage = DAMAGE_YES;
	self->think = 0;
	KillBox (self);
	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x34b5c(%rip), %rax     # 0x69600
movq 0x20(%rax), %r14
movq %rax, %r15
leaq 0x23968(%rip), %rdi     # 0x5841a
callq *0x48(%rax)
movss 0x1f46b(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r14
movl $0x3, 0x108(%rbx)
andb $-0x2, 0xc8(%rbx)
movl $0x1, 0x27c(%rbx)
movq $0x0, 0x210(%rbx)
movq %rbx, %rdi
callq 0x18a90
movq %rbx, %rdi
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)