LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/gslog.c
// Function: sl_WriteStdLogPlayerEntered
void sl_WriteStdLogPlayerEntered( game_import_t     *gi,
                                  level_locals_t     level,
                                  edict_t           *ent )
{
    if( sl_Logging( gi, pPatch ) )
    {
        sl_LogPlayerConnect( gi,
                             ent->client->pers.netname,
                             NULL,
                             level.time);        
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4c6e8(%rip), %rsi     # 0x728a8
callq 0x19580
testl %eax, %eax
je 0x261ed
leaq 0x20(%rsp), %rax
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%r14), %rsi
movss 0x4(%rax), %xmm0
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/gslog.c
// Function: sl_LogPlayerDisconnect
void sl_LogPlayerDisconnect( game_import_t      *gi,
                             level_locals_t      level,
                             edict_t            *ent )
{
    // GSLogMod Start: Player disconnected
    if( sl_Logging( gi, pPatch ) )
    {
        sl_LogPlayerLeft( gi,
                          ent->client->pers.netname,
                          level.time );
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4c6a2(%rip), %rsi     # 0x728a8
callq 0x19580
testl %eax, %eax
je 0x26231
leaq 0x20(%rsp), %rax
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%r14), %rsi
movss 0x4(%rax), %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18d90
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_vote.c
// Function: Clear_All_Ballots
int Clear_All_Ballots (edict_t *ent)
{
	edict_t * player = NULL;
	unsigned int num_players = 0;

	//Reset the flags to neither yes or no (ie abstain) to prepare for next vote
	player = ctf_findplayer(NULL, NULL, CTF_TEAM_IGNORETEAM);
	while (player)
	{
		num_players++;
		//gi.bprintf(PRINT_HIGH, "processing: %s --", player->client->pers.netname); //for debugging
		player->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_VOTE_NO; //reset all players so they are all in
		player->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_VOTE_YES;  //'abstain' mode.
		//gi.bprintf(PRINT_HIGH," reset\n"); //for debugging
		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 0x26278
xorl %ebx, %ebx
incl %ebx
movq 0x58(%rax), %rcx
andl $0xffffff3f, 0x1108(%rcx) # imm = 0xFFFFFF3F
movq %rax, %rdi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
testq %rax, %rax
jne 0x26254
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_vote.c
// Function: Vote_Skip_Level
void Vote_Skip_Level (edict_t *ent)
{
	unsigned int num_players = 0;

	num_players = Clear_All_Ballots (ent);
	if (num_players < 4 )
		gi.cprintf(ent, PRINT_HIGH,"You need at least four players on the server to initiate a vote\n");
	else if (VoteStarted)
		gi.cprintf(ent, PRINT_HIGH,"Vote has already been started\n");
	else
	{
		VoteStarted = true;
		VoteTime = level.time;  //start the 30 second timer
		VoteType |= CTF_VOTETYPE_SKIP;

		gi.bprintf(PRINT_HIGH,"%s started vote to skip level.\n", ent->client->pers.netname);
		gi.sound(ent, CHAN_ITEM, gi.soundindex("misc/secret.wav"), 1, ATTN_NONE, 0);
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_VOTE_YES; //client who initiates vote must vote yes by default
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_VOTE_NO;
	}
	Vote_Menu(ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x18040
cmpl $0x3, %eax
ja 0x2629e
movq 0x4236b(%rip), %rcx     # 0x68600
leaq 0x2de4f(%rip), %rdx     # 0x540eb
jmp 0x262b8
movq 0x42403(%rip), %rax     # 0x686a8
cmpl $0x0, (%rax)
je 0x262d2
movq 0x4234f(%rip), %rcx     # 0x68600
leaq 0x2de74(%rip), %rdx     # 0x5412c
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19b28
movl $0x1, (%rax)
movq 0x42ac1(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
movq 0x423ed(%rip), %rax     # 0x686d8
movss %xmm0, (%rax)
movq 0x42cda(%rip), %rax     # 0x68fd0
orb $0x1, (%rax)
movq 0x42300(%rip), %r14     # 0x68600
movl $0x2c0, %edx            # imm = 0x2C0
addq 0x58(%rbx), %rdx
leaq 0x2de3b(%rip), %rsi     # 0x5414b
movl $0x2, %edi
xorl %eax, %eax
callq *(%r14)
movq 0x20(%r14), %r15
leaq 0x2de46(%rip), %rdi     # 0x5416b
callq *0x48(%r14)
movss 0x2cbf7(%rip), %xmm0    # 0x52f28
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x3, %esi
movl %eax, %edx
callq *%r15
movq 0x58(%rbx), %rax
movl $0xffffff3f, %ecx       # imm = 0xFFFFFF3F
andl 0x1108(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x1108(%rax)
jmp 0x262c5
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_vote.c
// Function: Vote_Ref_Player
void Vote_Ref_Player (edict_t *ent)
{
	unsigned int num_players = 0;

	num_players = Clear_All_Ballots (ent);
	if (num_players < 4 )
		gi.cprintf(ent, PRINT_HIGH,"You need at least four players on the server to initiate a vote\n");
	else if (VoteStarted)
		gi.cprintf(ent, PRINT_HIGH,"Vote has already been started\n");
	else
	{
		VoteStarted = true;
		VoteTime = level.time;  //start the 30 second timer
		VoteType |= CTF_VOTETYPE_REFPLAYER;

		gi.bprintf(PRINT_HIGH,"%s started vote to referee a player.\n", ent->client->pers.netname);
		gi.sound(ent, CHAN_ITEM, gi.soundindex("misc/secret.wav"), 1, ATTN_NONE, 0);
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_VOTE_YES; //client who initiates vote must vote yes by default
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_VOTE_NO;
	}	
	Vote_Menu(ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x18040
cmpl $0x3, %eax
ja 0x2661b
movq 0x41fee(%rip), %rcx     # 0x68600
leaq 0x2dad2(%rip), %rdx     # 0x540eb
jmp 0x26635
movq 0x42086(%rip), %rax     # 0x686a8
cmpl $0x0, (%rax)
je 0x2664f
movq 0x41fd2(%rip), %rcx     # 0x68600
leaq 0x2daf7(%rip), %rdx     # 0x5412c
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19b28
movl $0x1, (%rax)
movq 0x42744(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
movq 0x42070(%rip), %rax     # 0x686d8
movss %xmm0, (%rax)
movq 0x4295d(%rip), %rax     # 0x68fd0
orb $0x4, (%rax)
movq 0x41f83(%rip), %r14     # 0x68600
movl $0x2c0, %edx            # imm = 0x2C0
addq 0x58(%rbx), %rdx
leaq 0x2db1a(%rip), %rsi     # 0x541a7
movl $0x2, %edi
xorl %eax, %eax
callq *(%r14)
movq 0x20(%r14), %r15
leaq 0x2dac9(%rip), %rdi     # 0x5416b
callq *0x48(%r14)
movss 0x2c87a(%rip), %xmm0    # 0x52f28
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x3, %esi
movl %eax, %edx
callq *%r15
movq 0x58(%rbx), %rax
movl $0xffffff3f, %ecx       # imm = 0xFFFFFF3F
andl 0x1108(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x1108(%rax)
jmp 0x26642
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_vote.c
// Function: Vote_YES
void Vote_YES (edict_t *ent)
{
	gi.cprintf(ent, PRINT_HIGH,"You have voted YES\n");
	ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_VOTE_YES;
	ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_VOTE_NO;
	Vote_Menu(ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x41d9e(%rip), %rcx     # 0x68600
leaq 0x2dabf(%rip), %rdx     # 0x54328
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%rcx)
movq 0x58(%rbx), %rax
movl $0xffffff3f, %ecx       # imm = 0xFFFFFF3F
andl 0x1108(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x1108(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x19b28
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_vote.c
// Function: Vote_NO
void Vote_NO (edict_t *ent)
{
	gi.cprintf(ent, PRINT_HIGH,"You have voted NO\n");
	ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_VOTE_YES;
	ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_VOTE_NO;
	Vote_Menu(ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x41d61(%rip), %rcx     # 0x68600
leaq 0x2da96(%rip), %rdx     # 0x5433c
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%rcx)
movq 0x58(%rbx), %rax
movl $0xffffff3f, %ecx       # imm = 0xFFFFFF3F
andl 0x1108(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x1108(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x19b28
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_LockTeams_f
void Cmd_LockTeams_f(edict_t *ent)
{
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Only referees can (un)lock teams.\n");
		return;
	}

	game.teamslocked = !game.teamslocked;
	gi.bprintf(PRINT_HIGH, "Teams are now %slocked\n", game.teamslocked ? "" : "un");
}

// Assembly:
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x268fc
movq 0x41d18(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2dbcd(%rip), %rdx     # 0x544c0
movl $0x2, %esi
xorl %eax, %eax
jmpq *%rcx
movq 0x4243d(%rip), %rax     # 0x68d40
xorl %ecx, %ecx
cmpl $0x0, 0x624(%rax)
sete %cl
movl %ecx, 0x624(%rax)
movq 0x41ce4(%rip), %rax     # 0x68600
movq (%rax), %rcx
leaq 0x2d61f(%rip), %rax     # 0x53f45
leaq 0x336e2(%rip), %rdx     # 0x5a00f
cmoveq %rax, %rdx
leaq 0x2dbab(%rip), %rsi     # 0x544e3
movl $0x2, %edi
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_StartMatch_f
void Cmd_StartMatch_f(edict_t *ent) {
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command denied.\n");
		return;
	}

	if (matchstate > MATCH_NONE) {
		gi.cprintf(ent, PRINT_HIGH, "Match already running, stop it first\n");
		return;
	}

	// start countdown
	SpawnTourneyClock();
}

// Assembly:
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x26962
movq 0x41cab(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2db9b(%rip), %rdx     # 0x544fb
jmp 0x26980
movq 0x41e6f(%rip), %rax     # 0x687d8
cmpl $0x0, (%rax)
jle 0x26989
movq 0x41c8b(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2db99(%rip), %rdx     # 0x54519
movl $0x2, %esi
xorl %eax, %eax
jmpq *%rcx
xorl %eax, %eax
jmp 0x18970
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_StopMatch_f
void Cmd_StopMatch_f(edict_t *ent) {
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command denied.\n");
		return;
	}

	if (matchstate == MATCH_NONE) {
		gi.cprintf(ent, PRINT_HIGH, "No match running\n");
		return;
	}

	KillMatch();
	gi.bprintf(PRINT_HIGH, "Match stopped by %s\n", ent->client->pers.netname);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x269b5
movq 0x41c58(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2db48(%rip), %rdx     # 0x544fb
jmp 0x269fe
movq 0x41e1c(%rip), %rax     # 0x687d8
cmpl $0x0, (%rax)
je 0x269ec
xorl %eax, %eax
callq 0x180d0
movq 0x41c31(%rip), %rax     # 0x68600
movq (%rax), %rcx
movl $0x2c0, %edx            # imm = 0x2C0
addq 0x58(%rbx), %rdx
leaq 0x2db6f(%rip), %rsi     # 0x54551
movl $0x2, %edi
xorl %eax, %eax
popq %rbx
jmpq *%rcx
movq 0x41c0d(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2db41(%rip), %rdx     # 0x5453f
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
popq %rbx
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: ForceCommand
void ForceCommand(edict_t *ent, char *command)
{
	if (!command || strlen(command) > MAX_INFO_STRING)
		return;
	if (strcmp(level.level_name, "") == 0)
		return;

   	gi.WriteByte (11);
	gi.WriteString (command);
    gi.unicast (ent, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x26a70
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x18680
cmpq $0x200, %rax            # imm = 0x200
ja 0x26a70
movq 0x42369(%rip), %rax     # 0x68da0
cmpb $0x0, 0x8(%rax)
je 0x26a70
movq 0x41bbc(%rip), %r15     # 0x68600
movl $0xb, %edi
callq *0xc8(%r15)
movq %r14, %rdi
callq *0xe8(%r15)
movq 0xb8(%r15), %rax
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_SetPassword_f
void Cmd_SetPassword_f(edict_t *ent)
{
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
		return;
	}

	// no password supplied, clear current password
	if (gi.argc() < 2) {
		gi.cvar_set("password", "");
		gi.cprintf(ent, PRINT_HIGH, "Server password has been cleared\n");
		return;
	}

	char *pw = gi.argv(1);
	gi.cvar_set("password", pw);
	gi.cprintf(ent, PRINT_HIGH, "Server password set to \"%s\"\n", pw);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x26a9f
movq 0x41b6e(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2dac9(%rip), %rdx     # 0x54566
jmp 0x26ad2
movq 0x41b5a(%rip), %r15     # 0x68600
callq *0x138(%r15)
cmpl $0x1, %eax
jg 0x26ae3
leaq 0x31460(%rip), %rdi     # 0x57f19
leaq 0x2d485(%rip), %rsi     # 0x53f45
callq *0x128(%r15)
movq 0x10(%r15), %rcx
leaq 0x2daaa(%rip), %rdx     # 0x5457c
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
movl $0x1, %edi
callq *0x140(%r15)
movq %rax, %r14
leaq 0x31420(%rip), %rdi     # 0x57f19
movq %rax, %rsi
callq *0x128(%r15)
movq 0x10(%r15), %r8
leaq 0x2da90(%rip), %rdx     # 0x5459e
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: OnSameTeam
qboolean OnSameTeam (edict_t *ent1, edict_t *ent2)
{
	if ((int)ctfflags->value & CTF_TEAM_NOTEAMS)
		return false; //surt there are no teams allowed

	if (ent1->client && ent2->client &&
		(ent1->client->ctf.teamnum == ent2->client->ctf.teamnum) &&
		ent1->inuse && ent2->inuse)
		return true;
	return false;
}

// Assembly:
movq 0x41dfa(%rip), %rax     # 0x68b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %ecx
xorl %eax, %eax
testb %cl, %cl
js 0x26d9f
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x26d9d
movq 0x58(%rsi), %rcx
testq %rcx, %rcx
je 0x26d9d
movl 0x1100(%rax), %eax
cmpl 0x1100(%rcx), %eax
jne 0x26d9d
cmpl $0x0, 0x60(%rdi)
je 0x26d9d
movl $0x1, %eax
cmpl $0x0, 0x60(%rsi)
jne 0x26d9f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: PlayVoiceSound
void PlayVoiceSound(edict_t *ent, char *sound)
{
	char	command [MAX_INFO_STRING];
	char	*s, *gender;

	//bat
	//if (ent->client->ctf.teamnum == CTF_TEAM_OBSERVER)
	if (ent->client->ctf.teamnum <= CTF_TEAM_OBSERVER)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Observers can't use voice.\n");
		return;
	}

#ifdef NOVOICE_OK
	if ((int)ctfflags->value & CTF_NOVOICE)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "It's quiet time, no talking.\n");
		return;
	}
#endif

	if (!ctf_SpamCheck(ent))
		return;

	s = Info_ValueForKey (ent->client->pers.userinfo, "skin");

	// decide gender


	if (sound[0] == '_' || !strncmp(sound, "male_", 5)	|| !strncmp(sound, "fem_", 4))
	{
		Com_sprintf (command, sizeof(command), "voice/%s.wav", sound);
	}
	else // Append gender
	{
		if (s[0] == 'f' || s[0] == 'F') // Female
		{
			gender = "fem";
		}
		else
		{
			gender = "male";
		}

		Com_sprintf (command, sizeof(command), "voice/%s_%s.wav", gender, sound);
	}

	gi.sound(ent, CHAN_AUTO, gi.soundindex(command), 1, ATTN_IDLE, 0);

	gi.dprintf("%s (voicetext): %s\n",
			ent->client->pers.netname, command);

	ent->client->spam_band_count -= CTF_SPAM_BAND_VOICE; //75 units of spam control for the voice
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cmpl $0x0, 0x1100(%rax)
js 0x26e5b
movq %rsi, %r14
movq %rbx, %rdi
callq 0x195b0
testl %eax, %eax
je 0x26eed
movl $0xc0, %edi
addq 0x58(%rbx), %rdi
leaq 0x2b55b(%rip), %rsi     # 0x52340
callq 0x18bb0
cmpb $0x5f, (%r14)
je 0x26e7d
movq %rax, %r15
leaq 0x2d7eb(%rip), %rsi     # 0x545e9
movl $0x5, %edx
movq %r14, %rdi
callq 0x181e0
testl %eax, %eax
je 0x26e7d
leaq 0x2d7d9(%rip), %rsi     # 0x545ef
movl $0x4, %edx
movq %r14, %rdi
callq 0x181e0
testl %eax, %eax
je 0x26e7d
movb (%r15), %al
addb $-0x46, %al
testb $-0x21, %al
leaq 0x2d7ce(%rip), %rax     # 0x54603
leaq 0x2b244(%rip), %rcx     # 0x52080
cmoveq %rax, %rcx
leaq 0x2d80f(%rip), %rdx     # 0x54656
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %r8
xorl %eax, %eax
callq 0x18e10
jmp 0x26e96
leaq 0x2d7cb(%rip), %rdx     # 0x5462d
movl $0x2, %esi
movq %rbx, %rdi
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18da0
leaq 0x2d7c5(%rip), %rdx     # 0x54649
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rcx
xorl %eax, %eax
callq 0x18e10
movq 0x41763(%rip), %r15     # 0x68600
movq 0x20(%r15), %r12
movq %rsp, %r14
movq %r14, %rdi
callq *0x48(%r15)
movss 0x2c075(%rip), %xmm0    # 0x52f28
movss 0x2c5b1(%rip), %xmm1    # 0x5346c
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
callq *%r12
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%rbx), %rsi
leaq 0x2d78e(%rip), %rdi     # 0x54666
movq %r14, %rdx
xorl %eax, %eax
callq *0x8(%r15)
movq 0x58(%rbx), %rax
addq $-0x4b, 0x10e0(%rax)
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: SelectNextItem
void SelectNextItem (edict_t *ent, int itflags)
{
	gclient_t	*cl;
	int			i, index;
	gitem_t		*it;
	it = 0;

	cl = ent->client;

	if (cl->showmenu)
	{
		Menu_Next(ent);
//		return; //surt, this causes a bug with dropping items ... this can
		//be called from validate selected item in which case it must _not_
		//return early!!!!
	}

	if (cl->chase_target) {
		ChaseNext(ent);
		return;
	}

	// scan  for the next valid one
	for (i=1 ; i<=MAX_ITEMS ; i++)
	{
		index = (cl->pers.selected_item + i)%MAX_ITEMS;
		if (!cl->pers.inventory[index])
			continue;
		it = &itemlist[index];
		if (!it->use)
			continue;
		if (!(it->flags & itflags))
			continue;

		cl->pers.selected_item = index;
		return;
	}

	cl->pers.selected_item = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x58(%rdi), %r15
cmpl $0x0, 0xf80(%r15)
je 0x2703a
movq %r14, %rdi
callq 0x18bd0
cmpq $0x0, 0xf30(%r15)
je 0x27051
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19570
movl 0x314(%r15), %eax
incl %eax
xorl %ecx, %ecx
movq 0x41ddd(%rip), %rdx     # 0x68e40
movl %eax, %esi
addl %ecx, %esi
leal 0xff(%rax,%rcx), %edi
cmovnsl %esi, %edi
andl $0xffffff00, %edi       # imm = 0xFFFFFF00
subl %edi, %esi
movslq %esi, %rdi
cmpl $0x0, 0x318(%r15,%rdi,4)
je 0x270a2
movq %rdi, %r8
shlq $0x7, %r8
leaq (%r8,%rdi,8), %rdi
cmpq $0x0, 0x10(%rdx,%rdi)
je 0x270a2
addq %rdx, %rdi
testl %ebx, 0x68(%rdi)
jne 0x270b9
incl %ecx
cmpl $0x100, %ecx            # imm = 0x100
jne 0x27063
movl $0xffffffff, 0x314(%r15) # imm = 0xFFFFFFFF
jmp 0x270c0
movl %esi, 0x314(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: SelectPrevItem
void SelectPrevItem (edict_t *ent, int itflags)
{
	gclient_t	*cl;
	int			i;
	int			index;
	gitem_t		*it;

	it = 0;

	cl = ent->client;

	if (cl->showmenu)
	{
		Menu_Prev(ent);
//		return; //surt, see above ... this should not fail!!
	}

	if (cl->chase_target) {
		ChasePrev(ent);
		return;
	}

	// scan  for the next valid one
	for (i=1 ; i<=MAX_ITEMS ; i++)
	{
		index = (cl->pers.selected_item + MAX_ITEMS - i)%MAX_ITEMS;
		if (!cl->pers.inventory[index])
			continue;
		it = &itemlist[index];
		if (!it->use)
			continue;
		if (!(it->flags & itflags))
			continue;

		cl->pers.selected_item = index;
		return;
	}

	cl->pers.selected_item = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x58(%rdi), %r15
cmpl $0x0, 0xf80(%r15)
je 0x270e6
movq %r14, %rdi
callq 0x19970
cmpq $0x0, 0xf30(%r15)
je 0x270fd
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x188d0
movl 0x314(%r15), %eax
movl $0xff, %ecx
movq 0x41d30(%rip), %rdx     # 0x68e40
movl %eax, %esi
addl %ecx, %esi
leal 0xff(%rax,%rcx), %edi
cmovnsl %esi, %edi
andl $0xffffff00, %edi       # imm = 0xFFFFFF00
subl %edi, %esi
movslq %esi, %rdi
cmpl $0x0, 0x318(%r15,%rdi,4)
je 0x2714f
movq %rdi, %r8
shlq $0x7, %r8
leaq (%r8,%rdi,8), %rdi
cmpq $0x0, 0x10(%rdx,%rdi)
je 0x2714f
addq %rdx, %rdi
testl %ebx, 0x68(%rdi)
jne 0x27161
addl $-0x1, %ecx
jb 0x27110
movl $0xffffffff, 0x314(%r15) # imm = 0xFFFFFFFF
jmp 0x27168
movl %esi, 0x314(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Use_f
void Cmd_Use_f (edict_t *ent)
{
	int			index;
	gitem_t		*it;
	char		*s;
	char message[MAX_INFO_STRING];

	s = gi.args();

	// CTF CODE -- LM_JORM
	if (Q_stricmp(s, "hook") == 0)
		s = "grappling hook";
	else if (Q_stricmp(s, "grapple") == 0)
		s = "grappling hook";
	if (Q_stricmp(s, "flag") == 0)
		s = "Enemy Flag";
	// END CTF CODE -- LM_JORM

	it = FindItem (s);
	if (!it)
	{
		sprintf(message, "unknown item: %s\n", s);
		ctf_SafePrint(ent, PRINT_HIGH, message);
		return;
	}
	if (!it->use)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Item is not usable.\n");
		return;
	}
	index = ITEM_INDEX(it);
	if (!ent->client->pers.inventory[index])
	{
		sprintf(message, "Out of item: %s\n", s);
		ctf_SafePrint(ent, PRINT_HIGH, message);
		return;
	}

		it->use (ent, it);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movq 0x40eda(%rip), %rax     # 0x68600
callq *0x148(%rax)
movq %rax, %r14
leaq 0x32b3f(%rip), %rsi     # 0x5a275
movq %rax, %rdi
callq 0x18690
testl %eax, %eax
je 0x27760
leaq 0x2cff4(%rip), %rsi     # 0x5473d
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
leaq 0x32b11(%rip), %r15     # 0x5a26b
cmovneq %r14, %r15
jmp 0x27767
leaq 0x32b04(%rip), %r15     # 0x5a26b
leaq 0x337cd(%rip), %rsi     # 0x5af3b
movq %r15, %rdi
callq 0x18690
testl %eax, %eax
leaq 0x2cfc6(%rip), %r14     # 0x54745
cmovneq %r15, %r14
movq %r14, %rdi
callq 0x189e0
testq %rax, %rax
je 0x277d2
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x277db
movq %rax, %rdx
subq 0x4169d(%rip), %rdx     # 0x68e40
shrq $0x3, %rdx
imull $0xf0f0f0f1, %edx, %edx # imm = 0xF0F0F0F1
movq 0x58(%rbx), %rsi
movslq %edx, %rdx
cmpl $0x0, 0x318(%rsi,%rdx,4)
je 0x277fb
movq %rbx, %rdi
movq %rax, %rsi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
leaq 0x2cf77(%rip), %rsi     # 0x54750
jmp 0x27802
leaq 0x2cf80(%rip), %rdx     # 0x54762
movl $0x2, %esi
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x18da0
leaq 0x2cf75(%rip), %rsi     # 0x54777
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x196f0
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18da0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Inven_f
void Cmd_Inven_f (edict_t *ent)
{
	int			i;
	gclient_t	*cl;

	cl = ent->client;

	ent->client->showscores = false;
	ent->client->showhelp = false;
	ent->client->showctfhud = false;
	ent->client->showmod = false;
	ent->client->showmenu = false;
	cl->showsquadboard = false; // ADC

	if (cl->showinventory)
	{
		cl->showinventory = false;
		return;
	}

	cl->showinventory = true;

	gi.WriteByte (svc_inventory);
	for (i=0 ; i<MAX_ITEMS ; i++)
	{
		gi.WriteShort (cl->pers.inventory[i]);
	}
	gi.unicast (ent, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x58(%rdi), %r14
xorl %eax, %eax
movl %eax, 0xe24(%r14)
movl %eax, 0xe2c(%r14)
movq $0x0, 0xf74(%r14)
movl %eax, 0xf80(%r14)
movl %eax, 0xe34(%r14)
cmpl %eax, 0xe28(%r14)
je 0x27a69
movl $0x0, 0xe28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdi, %rbx
movl $0x1, 0xe28(%r14)
movq 0x40b82(%rip), %r15     # 0x68600
movl $0x5, %edi
callq *0xc8(%r15)
xorl %r12d, %r12d
movl 0x318(%r14,%r12,4), %edi
callq *0xd0(%r15)
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x27a8d
movq 0xb8(%r15), %rax
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_InvUse_f
void Cmd_InvUse_f (edict_t *ent)
{
	gitem_t		*it;

	if (ent->client->showmenu)
	{
		Menu_Use(ent);
		return;
	}

	ValidateSelectedItem (ent);

	if (ent->client->pers.selected_item == -1)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "No item to use.\n");
		return;
	}

	it = &itemlist[ent->client->pers.selected_item];
	if (!it->use)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Item is not usable.\n");
		return;
	}
	it->use (ent, it);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
cmpl $0x0, 0xf80(%rcx)
je 0x27ade
movq %rbx, %rdi
popq %rbx
jmp 0x194e0
movslq 0x314(%rcx), %rax
cmpl $0x0, 0x318(%rcx,%rax,4)
jne 0x27b06
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x18940
movq 0x58(%rbx), %rax
movl 0x314(%rax), %eax
cmpl $-0x1, %eax
je 0x27b32
cltq
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rcx
movq 0x41321(%rip), %rsi     # 0x68e40
movq 0x10(%rsi,%rcx), %rax
testq %rax, %rax
je 0x27b3b
addq %rcx, %rsi
movq %rbx, %rdi
popq %rbx
jmpq *%rax
leaq 0x2cc86(%rip), %rdx     # 0x547bf
jmp 0x27b42
leaq 0x2cc20(%rip), %rdx     # 0x54762
movl $0x2, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x18da0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_WeapPrev_f
void Cmd_WeapPrev_f (edict_t *ent)
{
	gclient_t	*cl;
	int			i, index;
	gitem_t		*it;
	int			selected_weapon;


	if(matchstate == MATCH_RAILGUN_INPLAY)
		return;


	cl = ent->client;

	if (!cl->pers.weapon)
		return;

	selected_weapon = ITEM_INDEX(cl->pers.weapon);

	// scan  for the next valid one
	for (i=1 ; i<=MAX_ITEMS ; i++)
	{
		index = (selected_weapon + i)%MAX_ITEMS;
		if (!cl->pers.inventory[index])
			continue;
		it = &itemlist[index];
		if (!it->use)
			continue;
		if (! (it->flags & IT_WEAPON) )
			continue;

		// LM_JORM -- Remove grapple from list if offhand is on
		if ((int)ctfflags->value & CTF_OFFHAND_HOOK &&
			it == FindItem("Grappling Hook"))
			continue;
		// END LM_JORM

		it->use (ent, it);
		if (cl->pers.weapon == it)
			return;	// successful
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x40c76(%rip), %rax     # 0x687d8
cmpl $0x6, (%rax)
je 0x27c34
movq %rdi, %rbx
movq 0x58(%rdi), %r12
movq 0x730(%r12), %rax
testq %rax, %rax
je 0x27c34
subq 0x412b6(%rip), %rax     # 0x68e40
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %r13d # imm = 0xF0F0F0F1
movl $0x1, %ebp
movq 0x4129f(%rip), %r14     # 0x68e40
movl %r13d, %eax
addl %ebp, %eax
leal 0xff(%r13,%rbp), %ecx
cmovnsl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
subl %ecx, %eax
cltq
cmpl $0x0, 0x318(%r12,%rax,4)
je 0x27be5
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %r15
movq 0x10(%r14,%r15), %rax
testq %rax, %rax
je 0x27be5
addq %r14, %r15
testb $0x1, 0x68(%r15)
jne 0x27bf1
cmpl $0xff, %ebp
ja 0x27c34
incl %ebp
jmp 0x27ba1
movq 0x40f60(%rip), %rcx     # 0x68b58
movq (%rcx), %rcx
cvttss2si 0x20(%rcx), %ecx
testb $0x10, %cl
je 0x27c1a
leaq 0x2bbeb(%rip), %rdi     # 0x537f7
callq 0x189e0
cmpq %rax, %r15
je 0x27be5
movq 0x10(%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *%rax
cmpq %r15, 0x730(%r12)
je 0x27c34
cmpl $0x100, %ebp            # imm = 0x100
jb 0x27bed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_WeapLast_f
void Cmd_WeapLast_f (edict_t *ent)
{
	gclient_t	*cl;
	int			index;
	gitem_t		*it;


	if(matchstate == MATCH_RAILGUN_INPLAY)
		return;


	cl = ent->client;

	if (!cl->pers.weapon || !cl->pers.lastweapon)
		return;

	index = ITEM_INDEX(cl->pers.lastweapon);
	if (!cl->pers.inventory[index])
		return;
	it = &itemlist[index];
	if (!it->use)
		return;
	if (! (it->flags & IT_WEAPON) )
		return;
	it->use (ent, it);
}

// Assembly:
movq 0x40a90(%rip), %rax     # 0x687d8
cmpl $0x6, (%rax)
je 0x27daa
movq 0x58(%rdi), %rax
cmpq $0x0, 0x730(%rax)
je 0x27daa
movq 0x738(%rax), %rcx
testq %rcx, %rcx
je 0x27daa
subq 0x410d2(%rip), %rcx     # 0x68e40
shrq $0x3, %rcx
imull $0xf0f0f0f1, %ecx, %ecx # imm = 0xF0F0F0F1
movslq %ecx, %rcx
cmpl $0x0, 0x318(%rax,%rcx,4)
je 0x27daa
movq %rcx, %rax
shlq $0x7, %rax
leaq (%rax,%rcx,8), %rcx
movq 0x410a9(%rip), %rsi     # 0x68e40
movq 0x10(%rsi,%rcx), %rax
testq %rax, %rax
je 0x27daa
addq %rcx, %rsi
testb $0x1, 0x68(%rsi)
jne 0x27dab
retq
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_InvDrop_f
void Cmd_InvDrop_f (edict_t *ent)
{
	gitem_t		*it;

	ValidateSelectedItem (ent);

	if (ent->client->pers.selected_item == -1)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "No item to drop.\n");
		return;
	}

	it = &itemlist[ent->client->pers.selected_item];
	if (!it->drop)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Item is not dropable.\n");
		return;
	}
	it->drop (ent, it);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movslq 0x314(%rcx), %rax
cmpl $0x0, 0x318(%rcx,%rax,4)
jne 0x27ddd
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x18940
movq 0x58(%rbx), %rax
movl 0x314(%rax), %eax
cmpl $-0x1, %eax
je 0x27e09
cltq
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rcx
movq 0x4104a(%rip), %rsi     # 0x68e40
movq 0x18(%rsi,%rcx), %rax
testq %rax, %rax
je 0x27e12
addq %rcx, %rsi
movq %rbx, %rdi
popq %rbx
jmpq *%rax
leaq 0x2c9c0(%rip), %rdx     # 0x547d0
jmp 0x27e19
leaq 0x2c98f(%rip), %rdx     # 0x547a8
movl $0x2, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x18da0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Kill_f
void Cmd_Kill_f (edict_t *ent)
{
	if((level.time - ent->client->respawn_time) < 5)
		return;
	ent->flags &= ~FL_GODMODE;
	ent->health = 0;
	meansOfDeath = MOD_SUICIDE;
	player_die (ent, ent, ent, 100000, vec3_origin);
#ifdef OLDOBSERVERCODE
	if (ent->client->ctf.teamnum == CTF_TEAM_OBSERVER) // An observer
		Observer_Start(ent);
#endif
}

// Assembly:
movq 0x40f72(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
movq 0x58(%rdi), %rax
subss 0xf28(%rax), %xmm0
movss 0x2b0c1(%rip), %xmm1    # 0x52f08
ucomiss %xmm0, %xmm1
jbe 0x27e4d
retq
andb $-0x11, 0x11c(%rdi)
movl $0x0, 0x254(%rdi)
movq 0x40cc3(%rip), %rax     # 0x68b28
movl $0x17, (%rax)
movq 0x408f6(%rip), %r8      # 0x68768
movq %rdi, %rsi
movq %rdi, %rdx
movl $0x186a0, %ecx          # imm = 0x186A0
jmp 0x19aa0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_PutAway_f
void Cmd_PutAway_f (edict_t *ent)
{
	ent->client->showscores = false;
	ent->client->showhelp = false;
	ent->client->showinventory = false;
	ent->client->showctfhud = false;
	ent->client->showmod = false;
	ent->client->showmenu = false;
	ent->client->showsquadboard = false; // ADC
	//ent->client->awayframe = level.framenum;
	gi.WriteByte (svc_layout);
	gi.WriteString ("");
	gi.unicast (ent, false);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
xorl %ecx, %ecx
movq %rcx, 0xe24(%rax)
movl %ecx, 0xe2c(%rax)
movq %rcx, 0xf74(%rax)
movl %ecx, 0xf80(%rax)
movl %ecx, 0xe34(%rax)
movq 0x4074a(%rip), %r14     # 0x68600
movl $0x4, %edi
callq *0xc8(%r14)
leaq 0x2c07c(%rip), %rdi     # 0x53f45
callq *0xe8(%r14)
movq 0xb8(%r14), %rax
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Team_Change
void Team_Change (edict_t *ent, int newnum)
{
	if (!newnum) {
		return;
	}

	if (game.teamslocked) {
		gi.cprintf(ent, PRINT_HIGH, "Teams are locked\n");
		return;
	}

	ent->health = 0;
	player_die (ent, ent, ent, 100000, vec3_origin);
	ent->client->resp.score++;
	stats_add(ent, STATS_SCORE, 1);
	stats_add(ent, STATS_DEATHS, -1);

	// don't even bother waiting for death frames
	ctf_SetEntTeam(ent, newnum); //switch teams after they die

	respawn (ent); //force them to respawn on the new team
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x27f23
movq %rdi, %rbx
movq 0x40e4a(%rip), %rax     # 0x68d40
cmpl $0x0, 0x624(%rax)
je 0x27f2a
movq 0x406fa(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2c8d1(%rip), %rdx     # 0x547e2
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %esi, %ebp
movl $0x0, 0x254(%rbx)
movq 0x4082b(%rip), %r8      # 0x68768
movq %rbx, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movl $0x186a0, %ecx          # imm = 0x186A0
callq 0x19aa0
movq 0x58(%rbx), %rax
incl 0xdf4(%rax)
movl $0x1, %edx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x19330
movq %rbx, %rdi
movl $0x6, %esi
movq $-0x1, %rdx
callq 0x19330
movq %rbx, %rdi
movl %ebp, %esi
callq 0x18220
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x19610
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Drop_All
void Drop_All (edict_t *ent)
{
	edict_t *flag;
	flag = ClientHasFlag(ent);
	if (flag)
	{
		ctf_playerdropflag(ent, flag->item);
	}

	if (ent->client->hook)
	{
		G_FreeEdict (ent->client->hook);
		ent->client->hook = NULL;
	}

	if (ent->client->rune && ent->client->rune->item)
	{
		Drop_Rune(ent, ent->client->rune->item);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x18150
testq %rax, %rax
je 0x27fb5
movq 0x330(%rax), %rsi
movq %rbx, %rdi
callq 0x19820
movq 0x58(%rbx), %rax
movq 0xf60(%rax), %rdi
testq %rdi, %rdi
je 0x27fd9
callq 0x19a50
movq 0x58(%rbx), %rax
movq $0x0, 0xf60(%rax)
movq 0xf68(%rax), %rax
testq %rax, %rax
je 0x27ffa
movq 0x330(%rax), %rsi
testq %rsi, %rsi
je 0x27ffa
movq %rbx, %rdi
popq %rbx
jmp 0x19940
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Id_f
void Cmd_Id_f (edict_t *ent)
{
	vec3_t	forward, right, start, offset, mins, maxs, end;
	trace_t	tr;
	float	*v;

	v = tv(-32,-32,-32);
	VectorCopy (v, mins);
	v = tv(32,32,32);
	VectorCopy (v, maxs);

	// Set out ending point to our starting point
	AngleVectors (ent->client->v_angle, forward, right, NULL);
	VectorSet(offset, 8, 0, ent->viewheight-8);
	G_ProjectSource (ent->s.origin, offset, forward, right, start);

	VectorSet(offset, 10000, 0, 0);
	G_ProjectSource (start, offset, forward, right, end);

	tr = gi.trace (start, mins, maxs, end, ent, MASK_SHOT);
	if (tr.ent)
	{
		if (tr.ent->client)
			gi.centerprintf (ent, tr.ent->client->pers.netname);
		else if (tr.ent->item)
			gi.centerprintf (ent, tr.ent->item->pickup_name);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movss 0x2c1b8(%rip), %xmm0    # 0x54404
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x19510
movsd (%rax), %xmm0
leaq 0x20(%rsp), %rcx
movsd %xmm0, (%rcx)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rcx)
movss 0x2b1d6(%rip), %xmm0    # 0x5344c
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x19510
movsd (%rax), %xmm0
leaq 0x10(%rsp), %rcx
movsd %xmm0, (%rcx)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rcx)
movl $0xebc, %edi            # imm = 0xEBC
addq 0x58(%rbx), %rdi
leaq 0x64(%rsp), %r12
leaq 0x58(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x183a0
movss 0x2ac3c(%rip), %xmm0    # 0x52efc
leaq 0x30(%rsp), %rbp
movlps %xmm0, (%rbp)
movl 0x278(%rbx), %eax
addl $-0x8, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x8(%rbp)
leaq 0x4(%rbx), %rdi
leaq 0x4c(%rsp), %r14
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x18fa0
movss 0x2c108(%rip), %xmm0    # 0x54408
movlps %xmm0, (%rbp)
movl $0x0, 0x8(%rbp)
leaq 0x40(%rsp), %r15
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x18fa0
movq 0x402d5(%rip), %r13     # 0x68600
movl $0x6000003, (%rsp)      # imm = 0x6000003
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %r8
movq %rbx, %r9
callq *0x60(%r13)
movq 0x40(%r12), %rax
testq %rax, %rax
je 0x28386
movq 0x58(%rax), %rsi
testq %rsi, %rsi
je 0x2836d
addq $0x2c0, %rsi            # imm = 0x2C0
jmp 0x2837d
movq 0x330(%rax), %rax
testq %rax, %rax
je 0x28386
movq 0x50(%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r13)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Position_f
void Cmd_Position_f(edict_t* ent)
{
	char temp[MAX_INFO_STRING];
	double f1, f2, f3, a1, a2, a3;
	char message[MAX_INFO_STRING];

	f1 = ent->s.origin[0];
	f2 = ent->s.origin[1];
	f3 = ent->s.origin[2];

	a1 = ent->s.angles[0];
	a2 = ent->s.angles[1];
	a3 = ent->s.angles[2];

	string_replace(ent, "%p", temp, sizeof temp);

	Com_sprintf(message, sizeof message, "LOC: { %.0f, %.0f, %.0f }\nANGLE: { %.0f, %.0f, %.0f }\n"
		"You are %s\n",
		f1, f2, f3, a1, a2, a3, temp);

	ctf_SafePrint(ent, PRINT_HIGH, message);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x430, %rsp            # imm = 0x430
movq %rdi, %rbx
cvtss2sd 0x4(%rdi), %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rdi), %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0xc(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x14(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x18(%rdi), %xmm0
movsd %xmm0, (%rsp)
leaq 0x2b7e6(%rip), %rsi     # 0x53be4
leaq 0x230(%rsp), %r14
movq %r14, %rdx
movl $0x200, %ecx            # imm = 0x200
callq 0x18050
leaq 0x2c4d5(%rip), %rdx     # 0x548ef
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
movsd (%rsp), %xmm5
movq %r14, %rcx
movb $0x6, %al
callq 0x18e10
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18da0
addq $0x430, %rsp            # imm = 0x430
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_AngleInfo_f
void Cmd_AngleInfo_f (edict_t *ent)
{
	double a1, a2, a3;
	double t1, t2, t3;
	vec3_t tempvec;
	char message[MAX_INFO_STRING];

	a1 = ent->client->v_angle[0];
	a2 = ent->client->v_angle[1];
	a3 = ent->client->v_angle[2];

	VectorCopy(ent->s.origin, tempvec);
	vectoangles(tempvec,tempvec);
	t1 = tempvec[0];
	t2 = tempvec[1];
	t3 = tempvec[2];

	sprintf (message, "VIEWANGLE: { %.0f, %.0f, %.0f }\tFACEANGLE: { %.0f, %.0f, %.0f }\n",
		a1,a2,a3,t1,t2,t3);
	ctf_SafePrint(ent, PRINT_HIGH, message);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cvtss2sd 0xebc(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0xec0(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0xec4(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x4(%rdi), %xmm0
leaq 0x20(%rsp), %r14
movsd %xmm0, (%r14)
movss 0xc(%rdi), %xmm0
movss %xmm0, 0x8(%r14)
movq %r14, %rdi
movq %r14, %rsi
callq 0x190d0
cvtss2sd (%r14), %xmm3
cvtss2sd 0x4(%r14), %xmm4
cvtss2sd 0x8(%r14), %xmm5
leaq 0x2c442(%rip), %rsi     # 0x54931
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movb $0x6, %al
callq 0x196f0
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x18da0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Hook_f
void Cmd_Hook_f (edict_t *ent)
{
	gitem_t		*it;

	// Observers can't hook
	if (ent->movetype == MOVETYPE_NOCLIP)
		return;

	if ((int)ctfflags->value & CTF_OFFHAND_HOOK)
	{
		if (!ent->client->hook)
		{

			it = FindItem("Grappling Hook");

			// Can't offhand your hook if it is your current weapon
			if (ent->client->pers.weapon == it)
			{
				ForceCommand(ent, "+attack\n");
				return;
			}

			if (it && (ent->client->pers.inventory[ITEM_INDEX(it)]))  // We are carrying a rune
			{
 				if (ent->client->quad_framenum > level.framenum)
 					gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);

 				Weapon_Hook_Fire(ent);
			}
			else
				ctf_SafePrint(ent, PRINT_HIGH, "You have no hook.\n");
		}
	}
	else // Use the hook
	{
		it = FindItem ("grappling hook");
		if (!ent->client->pers.inventory[ITEM_INDEX(it)])
		{
			ctf_SafePrint(ent, PRINT_HIGH, "Out of item: grappling hook\n");
			return;
		}
		if (it->use)
			it->use (ent, it);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, 0x118(%rdi)
je 0x28741
movq %rdi, %rbx
movq 0x4047f(%rip), %rax     # 0x68b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x10, %al
jne 0x28733
leaq 0x31b7f(%rip), %rdi     # 0x5a26b
callq 0x189e0
movq 0x58(%rbx), %rcx
movq %rax, %rdx
subq 0x40741(%rip), %rdx     # 0x68e40
sarq $0x3, %rdx
movabsq $-0x3c3c3c3c3c3c3c3c, %rsi # imm = 0xC3C3C3C3C3C3C3C4
imulq %rdx, %rsi
cmpl $0x0, 0x318(%rcx,%rsi)
je 0x28749
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x28741
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movq 0x58(%rbx), %rax
cmpq $0x0, 0xf60(%rax)
je 0x28755
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2c5f9(%rip), %rdx     # 0x54d49
jmp 0x287f8
leaq 0x2b09b(%rip), %rdi     # 0x537f7
callq 0x189e0
movq 0x58(%rbx), %rcx
cmpq %rax, 0x730(%rcx)
je 0x2880c
testq %rax, %rax
je 0x287f1
subq 0x406c2(%rip), %rax     # 0x68e40
sarq $0x3, %rax
movabsq $-0x3c3c3c3c3c3c3c3c, %rdx # imm = 0xC3C3C3C3C3C3C3C4
imulq %rax, %rdx
cmpl $0x0, 0x318(%rcx,%rdx)
je 0x287f1
movq 0x405ff(%rip), %rax     # 0x68da0
cvtsi2ssl (%rax), %xmm0
movss 0xf04(%rcx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x287e2
movq 0x3fe47(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
leaq 0x2e40d(%rip), %rdi     # 0x56bd1
callq *0x48(%rax)
movss 0x2a759(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x3, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19b00
leaq 0x2c53e(%rip), %rdx     # 0x54d36
movl $0x2, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18da0
leaq 0x2c51a(%rip), %rsi     # 0x54d2d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18c40
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Unhook_f
void Cmd_Unhook_f (edict_t *ent)
{
	gitem_t		*it;

	if ((int)ctfflags->value & CTF_OFFHAND_HOOK)
	{
		it = FindItem("Grappling Hook");

		// Can't offhand your hook if it is your current weapon
		if (ent->client->pers.weapon == it)
		{
			ForceCommand(ent, "-attack\n");
			return;
		}
		else
		{
			ctf_hook_abort(ent);
		}
	}
}

// Assembly:
pushq %rbx
movq 0x4032e(%rip), %rax     # 0x68b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x10, %al
jne 0x28838
popq %rbx
retq
movq %rdi, %rbx
leaq 0x2afb5(%rip), %rdi     # 0x537f7
callq 0x189e0
movq 0x58(%rbx), %rcx
cmpq %rax, 0x730(%rcx)
je 0x2885d
movq %rbx, %rdi
popq %rbx
jmp 0x18630
leaq 0x2c502(%rip), %rsi     # 0x54d66
movq %rbx, %rdi
popq %rbx
jmp 0x18c40
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Radio_f
void Cmd_Radio_f (edict_t *ent)
{
	char *p;

	p = gi.args();

	if (p[0]=='0' || !strcmp(p, "off"))
	{
		ent->client->ctf.extra_flags  &= ~(CTF_EXTRAFLAGS_RADIO_TEXT | CTF_EXTRAFLAGS_RADIO_SOUND);
		ctf_SafePrint(ent, PRINT_HIGH, "Your radio is now off.\n");
	}
	else if (p[0]=='1' || !strcmp(p, "on"))
	{
		ent->client->ctf.extra_flags  &= ~(CTF_EXTRAFLAGS_RADIO_TEXT | CTF_EXTRAFLAGS_RADIO_SOUND);
		ent->client->ctf.extra_flags  |= CTF_EXTRAFLAGS_RADIO_SOUND;
		ctf_SafePrint(ent, PRINT_HIGH, "Your radio is now on for sound.\n");
	}
	else if (p[0]=='2' || !strcmp(p, "text"))
	{
		ent->client->ctf.extra_flags  &= ~(CTF_EXTRAFLAGS_RADIO_TEXT | CTF_EXTRAFLAGS_RADIO_SOUND);
		ent->client->ctf.extra_flags  |= CTF_EXTRAFLAGS_RADIO_TEXT;
		ctf_SafePrint(ent, PRINT_HIGH, "Your radio is now text.\n");
	}
	else if (p[0]=='3' || !strcmp(p, "both"))
	{
		ent->client->ctf.extra_flags  &= ~(CTF_EXTRAFLAGS_RADIO_TEXT | CTF_EXTRAFLAGS_RADIO_SOUND);
		ent->client->ctf.extra_flags  |= CTF_EXTRAFLAGS_RADIO_TEXT | CTF_EXTRAFLAGS_RADIO_SOUND;
		ctf_SafePrint(ent, PRINT_HIGH, "Your radio is now on for text and sound.\n");
	}
	else
		ctf_SafePrint(ent, PRINT_HIGH, "Format: radio <off/text/on/both>\n");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3f468(%rip), %rax     # 0x68600
callq *0x148(%rax)
movzbl (%rax), %ebp
cmpl $0x30, %ebp
je 0x29211
movq %rax, %r14
leaq 0x2be75(%rip), %rsi     # 0x55025
movq %rax, %rdi
callq 0x18b20
testl %eax, %eax
je 0x29211
cmpl $0x31, %ebp
je 0x29253
cmpl $0x32, %ebp
je 0x29234
cmpl $0x6f, %ebp
jne 0x291dd
cmpb $0x6e, 0x1(%r14)
jne 0x291dd
cmpb $0x0, 0x2(%r14)
je 0x29253
leaq 0x2be7e(%rip), %rsi     # 0x55062
movq %r14, %rdi
callq 0x18b20
testl %eax, %eax
je 0x29234
cmpl $0x33, %ebp
je 0x29272
leaq 0x2be84(%rip), %rsi     # 0x55080
movq %r14, %rdi
callq 0x18b20
testl %eax, %eax
je 0x29272
leaq 0x2bea0(%rip), %rdx     # 0x550af
jmp 0x29223
movq 0x58(%rbx), %rax
andl $-0x31, 0x1108(%rax)
leaq 0x2be06(%rip), %rdx     # 0x55029
movl $0x2, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x18da0
movq 0x58(%rbx), %rax
movl 0x1108(%rax), %ecx
andl $-0x31, %ecx
orl $0x10, %ecx
movl %ecx, 0x1108(%rax)
leaq 0x2be16(%rip), %rdx     # 0x55067
jmp 0x29223
movq 0x58(%rbx), %rax
movl 0x1108(%rax), %ecx
andl $-0x31, %ecx
orl $0x20, %ecx
movl %ecx, 0x1108(%rax)
leaq 0x2bdd1(%rip), %rdx     # 0x55041
jmp 0x29223
movq 0x58(%rbx), %rax
orl $0x30, 0x1108(%rax)
leaq 0x2be01(%rip), %rdx     # 0x55085
jmp 0x29223
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Compass_f
void Cmd_Compass_f (edict_t *ent)
{
	char *p;

	p = gi.args();

	if (p[0]=='0' || !strcmp(p, "off"))
	{
		ent->client->ctf.compass = 0;
		ctf_SafePrint(ent, PRINT_HIGH, "Your compass is now off.\n");
	}
	else if (p[0]=='1' || !strcmp(p, "facing"))
	{
		ent->client->ctf.compass = 1;
		ctf_SafePrint(ent, PRINT_HIGH, "Your compass is now in facing mode.\n");
	}
	else if (p[0]=='2' || !strcmp(p, "on"))
	{
		ent->client->ctf.compass = 2;
		ctf_SafePrint(ent, PRINT_HIGH, "Your compass is now on.\n");
	}
	else if (p[0]=='3' || !strcmp(p, "flag"))
	{
		ent->client->ctf.compass = 3;
		ctf_SafePrint(ent, PRINT_HIGH, "Your compass is now pointing to the enemy flag.\n");
	}
	else
		ctf_SafePrint(ent, PRINT_HIGH, "Format: compass <on/off/facing/flag>\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x3f368(%rip), %rax     # 0x68600
callq *0x148(%rax)
movzbl (%rax), %r12d
xorl %ebp, %ebp
leaq 0x2be26(%rip), %r14     # 0x550d1
cmpl $0x30, %r12d
je 0x29344
movq %rax, %r15
leaq 0x2bd66(%rip), %rsi     # 0x55025
movq %rax, %rdi
callq 0x18b20
testl %eax, %eax
je 0x29344
leaq 0x2be20(%rip), %r14     # 0x550f2
movl $0x1, %ebp
cmpl $0x31, %r12d
je 0x29344
leaq 0x2be07(%rip), %rsi     # 0x550eb
movq %r15, %rdi
callq 0x18b20
testl %eax, %eax
je 0x29344
leaq 0x2be20(%rip), %r14     # 0x55117
movl $0x2, %ebp
cmpl $0x32, %r12d
je 0x29344
cmpl $0x33, %r12d
je 0x29338
cmpl $0x6f, %r12d
jne 0x2931c
cmpb $0x6e, 0x1(%r15)
jne 0x2931c
cmpb $0x0, 0x2(%r15)
je 0x29344
leaq 0x31c18(%rip), %rsi     # 0x5af3b
movq %r15, %rdi
callq 0x18b20
testl %eax, %eax
je 0x29338
leaq 0x2be2b(%rip), %r14     # 0x55161
jmp 0x2934e
leaq 0x2bdf1(%rip), %r14     # 0x55130
movl $0x3, %ebp
movq 0x58(%rbx), %rax
movl %ebp, 0x1118(%rax)
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x18da0