LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_PingFloor_Menu
void Ref_PingFloor_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(text, "Current Ping Floor:  %3d", ent->client->ctf.pingalertfloor);
	Menu_Set(ent, 0, text, Ref_Main_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2; i < 18; i++)
	{
		sprintf(text, "%d", pingfloor[i]);
		Menu_Set(ent, i, text, PingFloor_Exec);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
movl 0x1110(%rax), %edx
leaq 0x3394c(%rip), %rsi     # 0x4e764
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq 0x4bcc4(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x183a0
leaq 0x333a2(%rip), %rdx     # 0x4e1e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
pushq $0x2
popq %r15
movq 0x4b868(%rip), %rbp     # 0x666c0
leaq 0x33a27(%rip), %r12     # 0x4e886
movq 0x4b6aa(%rip), %r13     # 0x66510
cmpq $0x12, %r15
je 0x1ae94
movl (%rbp,%r15,4), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x183a0
incq %r15
jmp 0x1ae66
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_PingCeiling_Menu
void Ref_PingCeiling_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(text, "Current Ping Ceiling: %3d", ent->client->ctf.pingalertceiling);
	Menu_Set(ent, 0, text, Ref_Main_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2; i < 18; i++)
	{
		sprintf(text, "%d", pingfloor[i]);
		Menu_Set(ent, i, text, PingCeiling_Exec);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
movl 0x1114(%rax), %edx
leaq 0x3389d(%rip), %rsi     # 0x4e77d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq 0x4bbfc(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x183a0
leaq 0x332da(%rip), %rdx     # 0x4e1e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
pushq $0x2
popq %r15
movq 0x4b7a0(%rip), %rbp     # 0x666c0
leaq 0x3395f(%rip), %r12     # 0x4e886
movq 0x4b6ca(%rip), %r13     # 0x665f8
cmpq $0x12, %r15
je 0x1af5c
movl (%rbp,%r15,4), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x183a0
incq %r15
jmp 0x1af2e
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Match_Menu
void Ref_Match_Menu (edict_t *ent)
{
	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	//gi.dprintf("Ref_Match_Menu\n");
	Menu_Set(ent, 0, "Match Menu", Ref_Main_Menu);
	Menu_Set(ent, 1, "----------", NULL);
	Menu_Set(ent, 2, "LMCTF Set 1", Ref_Match_A_Menu);
	Menu_Set(ent, 3, "LMCTF Set 2", Ref_Match_B_Menu);
	Menu_Set(ent, 4, "LMCTF Set 3", Ref_Match_C_Menu);
	Menu_Set(ent, 5, "LMCTF Set 4", Ref_Match_D_Menu);
	Menu_Set(ent, 6, "LMCTF Set 5", Ref_Match_E_Menu);
	if (maplistindex != -2) // No list
		Menu_Set(ent, 7, "Maplist", Ref_Match_Maplist_Menu);
	Menu_Draw (ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
leaq 0x33dc1(%rip), %rdx     # 0x4ed67
movq 0x4bb43(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x183a0
leaq 0x3322c(%rip), %rdx     # 0x4e1ea
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
leaq 0x33da0(%rip), %rdx     # 0x4ed72
movq 0x4b8df(%rip), %rcx     # 0x668b8
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x183a0
leaq 0x33d93(%rip), %rdx     # 0x4ed7e
movq 0x4b3fe(%rip), %rcx     # 0x663f0
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x183a0
leaq 0x33d86(%rip), %rdx     # 0x4ed8a
movq 0x4bc8d(%rip), %rcx     # 0x66c98
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x183a0
leaq 0x33d79(%rip), %rdx     # 0x4ed96
movq 0x4b58c(%rip), %rcx     # 0x665b0
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x183a0
leaq 0x33d6c(%rip), %rdx     # 0x4eda2
movq 0x4bc6b(%rip), %rcx     # 0x66ca8
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x183a0
movq 0x4bd89(%rip), %rax     # 0x66dd8
cmpl $-0x2, (%rax)
je 0x1b06d
leaq 0x33d53(%rip), %rdx     # 0x4edae
movq 0x4be3e(%rip), %rcx     # 0x66ea0
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x183a0
movq %rbx, %rdi
popq %rbx
jmp 0x19880
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Kick_Menu
void Ref_Kick_Menu (edict_t *ent)
{
	int i;
	char message[MAX_INFO_STRING];
	edict_t * player = NULL;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	Menu_Set(ent, 0, "LMCTF Kick Menu", Ref_Main_Menu);
	Menu_Set(ent, 1, "---------------", NULL);

	i = 2;
	player = ctf_findplayer(NULL, NULL, CTF_TEAM_IGNORETEAM);
	while (player && i < 17)
	{
		sprintf(message, "%lu %s", player->client->ctf.ctfid, player->client->pers.netname);
		Menu_Set(ent, i, message, SelectKick);
		player = ctf_findplayer(player, NULL, CTF_TEAM_IGNORETEAM);
		i++;
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
leaq 0x33d2f(%rip), %rdx     # 0x4edd1
movq 0x4ba47(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x183a0
leaq 0x3312b(%rip), %rdx     # 0x4e1e5
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
pushq $-0x4
popq %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x192e0
movq %rax, %rbp
pushq $0x2
popq %r14
leaq 0x33d00(%rip), %r15     # 0x4ede1
movq %rsp, %r12
movq 0x4b8f5(%rip), %r13     # 0x669e0
testq %rbp, %rbp
je 0x1b13b
cmpl $0x10, %r14d
ja 0x1b13b
movq 0x58(%rbp), %rcx
movq 0x9120(%rcx), %rdx
addq $0x2c0, %rcx            # imm = 0x2C0
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x183a0
movq %rbp, %rdi
xorl %esi, %esi
pushq $-0x4
popq %rdx
callq 0x192e0
movq %rax, %rbp
incl %r14d
jmp 0x1b0eb
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Practice_Menu
void Ref_Practice_Menu(edict_t *ent)
{
	char text[MAX_INFO_STRING];
	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 1;
	ctf_validateflags();
	Menu_Set(ent, 1, "LMCTF Practice Menu", Ref_Main_Menu);
	Menu_Set(ent, 2, "-------------------", NULL);
	if (redflag && ((int)refset->value & CTF_RED_FLAG_FROZEN) )
		sprintf(text, "Red Flag:     %s", "FROZEN");
	else
		sprintf(text, "Red Flag:     %s", "NORMAL");
	Menu_Set(ent, 3, text, Ref_PracticeFlagRed_Exec);
	if (blueflag && ((int)refset->value & CTF_BLUE_FLAG_FROZEN) )
		sprintf(text, "Blue Flag:    %s", "FROZEN");
	else
		sprintf(text, "Blue Flag:    %s", "NORMAL");
	Menu_Set(ent, 4, text, Ref_PracticeFlagBlue_Exec);
	Menu_Draw (ent);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0xf84(%rax)
xorl %eax, %eax
callq 0x185d0
leaq 0x3356e(%rip), %rdx     # 0x4e719
movq 0x4b93e(%rip), %rcx     # 0x66af0
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x183a0
leaq 0x3301d(%rip), %rdx     # 0x4e1e1
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
movq 0x4b620(%rip), %rax     # 0x667f8
cmpq $0x0, (%rax)
je 0x1b1f1
movq 0x4b7b3(%rip), %rax     # 0x66998
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x1, %al
jne 0x1b1fa
leaq 0x3354d(%rip), %rdx     # 0x4e745
jmp 0x1b201
leaq 0x3353d(%rip), %rdx     # 0x4e73e
leaq 0x33525(%rip), %rsi     # 0x4e72d
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq 0x4b2ec(%rip), %rcx     # 0x66508
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x183a0
movq 0x4b62f(%rip), %rax     # 0x66860
cmpq $0x0, (%rax)
je 0x1b24a
movq 0x4b75a(%rip), %rax     # 0x66998
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x2, %al
jne 0x1b253
leaq 0x334f4(%rip), %rdx     # 0x4e745
jmp 0x1b25a
leaq 0x334e4(%rip), %rdx     # 0x4e73e
leaq 0x334eb(%rip), %rsi     # 0x4e74c
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq 0x4b1ab(%rip), %rcx     # 0x66420
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x183a0
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Help_Menu
void Ref_Help_Menu(edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i,j, start;

	// Calculate our page
	start = 15*ent->client->menupage;

	// Find if last page was the last
	if (start > 14)
	{
		for (i=start-15;i < start; i++)
		{
			if (!refhelptext[i]) // Last entry
			{
				start = 0;			// Go to first page
				ent->client->menupage = 0;
			}
		}
	}

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	Menu_Set(ent, 0, "LMCTF Ref Commands", Ref_Main_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2, j=start; i < 17 && refhelptext[j]; i++, j++)
	{
		sprintf(text, "%.24s", refhelptext[j]);
		Menu_Set(ent, i, text, NULL);
	}
	Menu_Set(ent, 17, "<next page>", Ref_Help_Menu);

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movl 0x10c0(%rax), %edx
imull $0xf, %edx, %ecx
testl %edx, %edx
jle 0x1b2e5
leal -0xf(%rcx), %edx
movslq %edx, %rdx
movq 0x4b8b0(%rip), %rsi     # 0x66b78
movslq %ecx, %r13
cmpq %r13, %rdx
jge 0x1b2e8
cmpq $0x0, (%rsi,%rdx,8)
jne 0x1b2e0
andl $0x0, 0x10c0(%rax)
xorl %ecx, %ecx
incq %rdx
jmp 0x1b2c8
movslq %ecx, %r13
movq %rbx, %rdi
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
leaq 0x333fd(%rip), %rdx     # 0x4e700
movq 0x4b7e6(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x183a0
leaq 0x32ec7(%rip), %rdx     # 0x4e1e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
shlq $0x3, %r13
addq 0x4b845(%rip), %r13     # 0x66b78
leaq 0x333d9(%rip), %r14     # 0x4e713
movq %rsp, %r15
xorl %ebp, %ebp
cmpl $0xf, %ebp
je 0x1b374
movq (%r13,%rbp,8), %rdx
testq %rdx, %rdx
je 0x1b374
leaq 0x2(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x183a0
incq %rbp
jmp 0x1b33f
leaq 0x32feb(%rip), %rdx     # 0x4e366
movq 0x4b36e(%rip), %rcx     # 0x666f0
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x183a0
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_PracticeFlagRed_Exec
void Ref_PracticeFlagRed_Exec(edict_t *ent)
{
	if (redflag && ((int)refset->value & CTF_RED_FLAG_FROZEN) )
		gi.cvar_set("refset", va("%d", ((int) refset->value & ~CTF_RED_FLAG_FROZEN)));
	else
		gi.cvar_set("refset", va("%d", ((int) refset->value | CTF_RED_FLAG_FROZEN)));
	Ref_Practice_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4b0f4(%rip), %rax     # 0x667f8
cmpq $0x0, (%rax)
sete %al
movq 0x4b286(%rip), %rcx     # 0x66998
movq (%rcx), %rcx
cvttss2si 0x20(%rcx), %ecx
testb $0x1, %cl
sete %dl
orb %al, %dl
movq 0x4aed7(%rip), %rax     # 0x66600
movq 0x128(%rax), %r14
andl $-0x2, %ecx
movzbl %dl, %esi
orl %ecx, %esi
leaq 0x33147(%rip), %rdi     # 0x4e886
xorl %eax, %eax
callq 0x194e0
leaq 0x33010(%rip), %rdi     # 0x4e75d
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19d38
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_PracticeFlagBlue_Exec
void Ref_PracticeFlagBlue_Exec(edict_t *ent)
{
	if (blueflag && ((int)refset->value & CTF_BLUE_FLAG_FROZEN) )
		gi.cvar_set("refset", va("%d", ((int) refset->value & ~CTF_BLUE_FLAG_FROZEN)));
	else
		gi.cvar_set("refset", va("%d", ((int) refset->value | CTF_BLUE_FLAG_FROZEN)));
	Ref_Practice_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4b0f0(%rip), %rax     # 0x66860
cmpq $0x0, (%rax)
sete %al
movq 0x4b21a(%rip), %rcx     # 0x66998
movq (%rcx), %rcx
cvttss2si 0x20(%rcx), %ecx
testb $0x2, %cl
sete %dl
orb %al, %dl
movq 0x4ae6b(%rip), %rax     # 0x66600
movq 0x128(%rax), %r14
andl $-0x3, %ecx
movzbl %dl, %eax
leal (%rcx,%rax,2), %esi
leaq 0x330da(%rip), %rdi     # 0x4e886
xorl %eax, %eax
callq 0x194e0
leaq 0x32fa3(%rip), %rdi     # 0x4e75d
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19d38
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Timelimit_Menu
void Ref_Timelimit_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(text, "Current Timelimit:  %3d", (int)timelimit->value);
	Menu_Set(ent, 0, text, Ref_Settings_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2; i < 18; i++)
	{
		sprintf(text, "%d", timeslist[i]);
		Menu_Set(ent, i, text, SetTimelimit);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
movq 0x4ae75(%rip), %rax     # 0x666b0
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x332fe(%rip), %rsi     # 0x4eb48
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq 0x4b3f2(%rip), %rcx     # 0x66c50
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x183a0
leaq 0x32970(%rip), %rdx     # 0x4e1e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
pushq $0x2
popq %r15
movq 0x4b4f6(%rip), %rbp     # 0x66d80
leaq 0x32ff5(%rip), %r12     # 0x4e886
movq 0x4b0c8(%rip), %r13     # 0x66960
cmpq $0x12, %r15
je 0x1b8c6
movl (%rbp,%r15,4), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x183a0
incq %r15
jmp 0x1b898
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Fraglimit_Menu
void Ref_Fraglimit_Menu (edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(text, "Current Fraglimit:  %3d", (int)fraglimit->value);
	Menu_Set(ent, 0, text, Ref_Settings_Menu);
	Menu_Set(ent, 1, "------------------", NULL);
	for (i=2; i < 18; i++)
	{
		sprintf(text, "%d", fragslist[i]);
		Menu_Set(ent, i, text, SetFraglimit);
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
movq 0x4b4f4(%rip), %rax     # 0x66e00
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x33245(%rip), %rsi     # 0x4eb60
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq 0x4b321(%rip), %rcx     # 0x66c50
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x183a0
leaq 0x3289f(%rip), %rdx     # 0x4e1e2
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
pushq $0x2
popq %r15
movq 0x4aea5(%rip), %rbp     # 0x66800
leaq 0x32f24(%rip), %r12     # 0x4e886
movq 0x4b677(%rip), %r13     # 0x66fe0
cmpq $0x12, %r15
je 0x1b997
movl (%rbp,%r15,4), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %r13, %rcx
callq 0x183a0
incq %r15
jmp 0x1b969
movq %rbx, %rdi
callq 0x19880
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: DMFlags_Exec
void DMFlags_Exec (edict_t *ent)
{
	int i;

	i = ent->client->menuselect - 2;
	if ((int)dmflags->value & (1 << i)) // is it set?
		gi.cvar_set("dmflags", va("%d", ((int)dmflags->value & ~(1 << i))));
	else
		gi.cvar_set("dmflags", va("%d", ((int)dmflags->value |(1 << i))));
	Ref_DMFlags_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0x4a50a(%rip), %rcx     # 0x66618
movq (%rcx), %rcx
cvttss2si 0x20(%rcx), %ecx
movb 0xf88(%rax), %al
addb $-0x2, %al
movzbl %al, %eax
movl %ecx, %edx
btsl %eax, %edx
movl %ecx, %esi
btrl %eax, %esi
btl %eax, %ecx
movq 0x4a4cb(%rip), %rax     # 0x66600
movq 0x128(%rax), %r14
cmovael %edx, %esi
leaq 0x32740(%rip), %rdi     # 0x4e886
xorl %eax, %eax
callq 0x194e0
leaq 0x323c3(%rip), %rdi     # 0x4e517
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c88
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: CTFFlags_Exec
void CTFFlags_Exec (edict_t *ent)
{
	int i;

	i = ent->client->menuselect - 2;
	if ((int)ctfflags->value & (1 << i)) // is it set?
		gi.cvar_set("ctfflags", va("%d", ((int)ctfflags->value & ~(1 << i))));
	else
		gi.cvar_set("ctfflags", va("%d", ((int)ctfflags->value |(1 << i))));
	Ref_CTFFlags_Menu(ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0x4a9dd(%rip), %rcx     # 0x66b58
movq (%rcx), %rcx
cvttss2si 0x20(%rcx), %ecx
movb 0xf88(%rax), %al
addb $-0x2, %al
movzbl %al, %eax
movl %ecx, %edx
btsl %eax, %edx
movl %ecx, %esi
btrl %eax, %esi
btl %eax, %ecx
movq 0x4a45e(%rip), %rax     # 0x66600
movq 0x128(%rax), %r14
cmovael %edx, %esi
leaq 0x326d3(%rip), %rdi     # 0x4e886
xorl %eax, %eax
callq 0x194e0
leaq 0x32362(%rip), %rdi     # 0x4e523
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c90
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Match_Maplist_Menu
void Ref_Match_Maplist_Menu (edict_t *ent)
{
	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	Menu_Set(ent, 0, "Match Maplist <min> <max>", Ref_Main_Menu);
	Menu_Set(ent, 1, "-------------", NULL);
	SetMapsForMenu(ent);
	Menu_Set(ent, 17, "<next page>", Ref_Match_Maplist_Menu);

	Menu_Draw (ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
leaq 0x32780(%rip), %rdx     # 0x4ed02
movq 0x4a567(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x183a0
leaq 0x31c4d(%rip), %rdx     # 0x4e1e7
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
movq %rbx, %rdi
callq 0x199e0
leaq 0x31db0(%rip), %rdx     # 0x4e366
movq 0x4a8e3(%rip), %rcx     # 0x66ea0
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x183a0
movq %rbx, %rdi
popq %rbx
jmp 0x19880
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: Ref_Map_Maplist_Menu
void Ref_Map_Maplist_Menu (edict_t *ent)
{
	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	Menu_Set(ent, 0, "Maplist <min> <max>", Ref_Main_Menu);
	Menu_Set(ent, 1, "-------------", NULL);
	SetMapsForMenu(ent);
	Menu_Set(ent, 17, "<next page>", Ref_Map_Maplist_Menu);

	Menu_Draw (ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %rax
andq $0x0, 0xf84(%rax)
leaq 0x326bc(%rip), %rdx     # 0x4ed08
movq 0x4a49d(%rip), %rcx     # 0x66af0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x183a0
leaq 0x31b83(%rip), %rdx     # 0x4e1e7
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
movq %rbx, %rdi
callq 0x199e0
leaq 0x31ce6(%rip), %rdx     # 0x4e366
movq 0x4a489(%rip), %rcx     # 0x66b10
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x183a0
movq %rbx, %rdi
popq %rbx
jmp 0x19880
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: SetMapsForMenu
void SetMapsForMenu( edict_t *ent)
{
	char text[MAX_INFO_STRING];
	int start;

	SetupShortList();

	MapInfo *slPtr = shortList;

	// Calculate our page
	start = 15*ent->client->menupage;

	slPtr = shortList;
	int mapCtr = 0;
	while (slPtr) {
		mapCtr++;
		slPtr = slPtr->next;
	}

	// Find if last page was the last
	if (start > 14)
	{
		if (start + 15 >= mapCtr)
		{
			start = 0;
			ent->client->menupage = 0;
		}
	}

	slPtr = shortList;
	for (int ct = 0; ct < start; ct++)
		slPtr = slPtr->next;


	for (int endCtr = 2; endCtr < 18 && slPtr; endCtr++) {
		sprintf(text, "%s %d %d", slPtr->mapname, slPtr->minplayers, slPtr->maxplayers);
		Menu_Set(ent, endCtr, text, SetMap);
		slPtr = slPtr->next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
callq 0x19590
movq 0x58(%rbx), %rax
movl 0x10c0(%rax), %edx
xorl %ecx, %ecx
movq 0x4a809(%rip), %rsi     # 0x66ed0
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x1c6d7
incl %ecx
addq $0x10, %rsi
jmp 0x1c6c7
imull $0xf, %edx, %esi
testl %edx, %edx
jle 0x1c6ee
leal 0xf(%rsi), %edx
cmpl %ecx, %edx
jl 0x1c6ee
andl $0x0, 0x10c0(%rax)
xorl %esi, %esi
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
movq 0x4a7d4(%rip), %r13     # 0x66ed0
movq (%r13), %r13
subl $0x1, %eax
jb 0x1c70b
addq $0x10, %r13
jmp 0x1c6fc
pushq $0x2
popq %rbp
leaq 0x32607(%rip), %r14     # 0x4ed1c
movq %rsp, %r15
movq 0x49f59(%rip), %r12     # 0x66678
cmpl $0x11, %ebp
ja 0x1c75a
testq %r13, %r13
je 0x1c75a
movq (%r13), %rdx
movl 0x8(%r13), %ecx
movl 0xc(%r13), %r8d
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x183a0
movq 0x10(%r13), %r13
incl %ebp
jmp 0x1c71f
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: SetupShortList
void SetupShortList()
{
	if (shortList)
	{
		return;
	}
        MapInfo *slPtr = NULL;
        for(int ctr = 0; maplist[ctr].mapname; ctr++) {
                char *thisMap = maplist[ctr].mapname;
                for(int lmNdx = 0; maplmlist[lmNdx]; lmNdx++) {
                        if (!strcmp(maplmlist[lmNdx], thisMap)) {
                                goto end;
                        }
                }
                if (!slPtr) {
                        shortList = slPtr = &maplist[ctr];
			slPtr->next = NULL;
                } else {
                        slPtr->next = &maplist[ctr];
                        slPtr = slPtr->next;
                        slPtr->next = NULL;
                }
                end:
                        continue;
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4a752(%rip), %rax     # 0x66ed0
cmpq $0x0, (%rax)
je 0x1c793
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq 0x4a02b(%rip), %r12     # 0x667c8
xorl %r14d, %r14d
imulq $0x18, %r15, %rbp
movq (%r12,%rbp), %rbx
testq %rbx, %rbx
je 0x1c784
addq %r12, %rbp
movq 0x49cd1(%rip), %r13     # 0x66488
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1c7d2
movq %rbx, %rsi
callq 0x18bc0
addq $0x8, %r13
testl %eax, %eax
jne 0x1c7b7
jmp 0x1c7ef
testq %r14, %r14
jne 0x1c7e0
movq 0x4a6f2(%rip), %r14     # 0x66ed0
jmp 0x1c7e4
addq $0x10, %r14
movq %rbp, (%r14)
andq $0x0, 0x10(%rbp)
movq %rbp, %r14
incq %r15
jmp 0x1c7a0
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: MapMenu
void MapMenu(edict_t *ent, char *maplist[], char *msg)
{
	char text[MAX_INFO_STRING];
        char title[MAX_INFO_STRING];
	int i;

	Menu_Free(ent);
	ent->client->menu = MENU_LOCAL;
	ent->client->menuselect = 0;

	sprintf(title, "%s", msg);

	Menu_Set(ent, 0, title, ent->client->prevmenu);
	Menu_Set(ent, 1, "-----------", NULL);
	for (i=2; i < 18; i++)
	{
		if (maplist[i])
		{
			sprintf(text, "%s", maplist[i]);
			Menu_Set(ent, i, text, SetMap);
		}
	}

	Menu_Draw (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x189e0
movq 0x58(%rbx), %r13
andq $0x0, 0xf84(%r13)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x182c0
movq 0x10b8(%r13), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x183a0
leaq 0x319a2(%rip), %rdx     # 0x4e1e9
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x183a0
pushq $0x2
popq %r15
leaq 0x200(%rsp), %r12
movq 0x49e11(%rip), %r13     # 0x66678
cmpq $0x12, %r15
je 0x1c894
movq (%r14,%r15,8), %rsi
testq %rsi, %rsi
je 0x1c88f
movq %r12, %rdi
callq 0x182c0
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x183a0
incq %r15
jmp 0x1c867
movq %rbx, %rdi
callq 0x19880
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_menu.c
// Function: SelectKick
void SelectKick(edict_t* ent)
{
	int i; //initialize j or you read off into memory
	unsigned long id;
	char kickcommand[MAX_INFO_STRING];

	i = ent->client->menuselect;
	if (sscanf(ent->client->localmenu[i].text, "%lu", &id))
	{
		Com_sprintf(kickcommand, sizeof kickcommand, "\nctfkick %lu\n", id);
		ForceCommand(ent, kickcommand);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movslq 0xf88(%rax), %rcx
shlq $0x4, %rcx
movq 0xf90(%rax,%rcx), %rdi
leaq 0x324e7(%rip), %rsi     # 0x4edbf
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x19110
testl %eax, %eax
je 0x1c913
movq 0x8(%rsp), %rcx
leaq 0x324cf(%rip), %rdx     # 0x4edc3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x18f30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18d20
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_armor
void replace_armor(edict_t *person, char *temp)
{
	gitem_t *item;
	int test, power_armor_type;
	char fill[1024];
	qboolean	hasArmor = false; // MJD Unitialized.  It needs to be


	strcpy(temp, ""); //this will get replaced

	power_armor_type = PowerArmorType(person);

	if (power_armor_type)
	{
		test = person->client->pers.inventory[ITEM_INDEX(FindItem ("cells"))];
		if (test)
		{
			hasArmor = true;
			sprintf(temp, "%i cells of ", test);
			if (power_armor_type == POWER_ARMOR_SCREEN)
				strcat(temp, "power screen ");
			else
				strcat(temp, "power shield ");
		}
	}

	test = ArmorIndex(person);
	if (test)
	{
		item = GetItemByIndex (test);
		if (item)
		{
			hasArmor = true;
			if (strlen(temp) > 1)
				strcat(temp, "and ");
			sprintf(fill, "%i of %s", 
				person->client->pers.inventory[test], item->pickup_name);
			strcat(temp, fill);
		}
	}
	
	if (!hasArmor)
		strcat (temp, "no armor");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rsi)
callq 0x18b50
movb $0x1, %r12b
testl %eax, %eax
je 0x1d4cc
movl %eax, %ebp
movq 0x58(%r14), %r15
leaq 0x35686(%rip), %rdi     # 0x52ad7
callq 0x18a80
subq 0x499e3(%rip), %rax     # 0x66e40
movl $0x88, %ecx
cqto
idivq %rcx
movl 0x318(%r15,%rax,4), %edx
testl %edx, %edx
je 0x1d4cc
leaq 0x31ccf(%rip), %rsi     # 0x4f149
movq %rbx, %rdi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
callq 0x186c0
addq %rbx, %rax
cmpl $0x1, %ebp
jne 0x1d4ae
movabsq $0x206e6565726373, %rcx # imm = 0x206E6565726373
movq %rcx, 0x6(%rax)
movabsq $0x6373207265776f70, %rcx # imm = 0x6373207265776F70
jmp 0x1d4c6
movabsq $0x20646c65696873, %rcx # imm = 0x20646C65696873
movq %rcx, 0x6(%rax)
movabsq $0x6873207265776f70, %rcx # imm = 0x6873207265776F70
movq %rcx, (%rax)
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x187a0
testl %eax, %eax
je 0x1d53e
movl %eax, %ebp
movl %eax, %edi
callq 0x18d10
testq %rax, %rax
je 0x1d53e
movq %rax, %r15
movq %rbx, %rdi
callq 0x186c0
cmpq $0x2, %rax
jb 0x1d50b
movq %rbx, %rdi
callq 0x186c0
movl $0x20646e61, (%rbx,%rax) # imm = 0x20646E61
movb $0x0, 0x4(%rbx,%rax)
movq 0x58(%r14), %rax
movslq %ebp, %rcx
movl 0x318(%rax,%rcx,4), %edx
movq 0x50(%r15), %rcx
leaq 0x31c4e(%rip), %rsi     # 0x4f172
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19800
jmp 0x1d55e
testb %r12b, %r12b
je 0x1d55e
movq %rbx, %rdi
callq 0x186c0
movabsq $0x726f6d7261206f6e, %rcx # imm = 0x726F6D7261206F6E
movq %rcx, (%rbx,%rax)
movb $0x0, 0x8(%rbx,%rax)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_health
void replace_health(edict_t *person, char *temp)
{
	edict_t *cur = NULL;
	int sum = 0;
	char str[10] = "";

	strcpy(temp,"");

	if (person->health <= 0)
		strcpy(temp, "dead");
	else
	{
		sprintf(temp, "%i health", person->health);
		while ((cur = findradius(cur, person->s.origin, 256)) != NULL)
		{
			if (!strcmp(cur->classname, "item_health_small") ||
			!strcmp(cur->classname, "item_health_large") ||
			!strcmp(cur->classname, "item_health") ||
			!strcmp(cur->classname, "item_health_mega") )
				sum += cur->count;
		}

		if (person->health < person->max_health)
		{
			strcat(temp," with ");
			if (!sum)
				strcat(temp,"none ");
			else
			{
				sprintf(str, "%i ", sum);
				strcat(temp, str);
			}
			strcat(temp, "nearby");
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
andw $0x0, 0x10(%rsp)
movq %rsi, %rax
andq $0x0, 0x8(%rsp)
movb $0x0, (%rsi)
movl 0x254(%rdi), %edx
testl %edx, %edx
jle 0x1d6b1
movq %rdi, %rbx
leaq 0x31be3(%rip), %rsi     # 0x4f189
xorl %r15d, %r15d
movq %rax, 0x18(%rsp)
movq %rax, %rdi
xorl %eax, %eax
callq 0x198c0
movq %rbx, 0x20(%rsp)
leaq 0x4(%rbx), %r12
leaq 0x31bcb(%rip), %r13     # 0x4f193
leaq 0x31bd6(%rip), %r14     # 0x4f1a5
leaq 0x31be1(%rip), %rbx     # 0x4f1b7
movl $0x0, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movss 0x31938(%rip), %xmm0    # 0x4ef24
callq 0x19a50
testq %rax, %rax
je 0x1d651
movq %rax, %r15
movq 0x138(%rax), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x18bc0
testl %eax, %eax
je 0x1d640
movq %rbp, %rdi
movq %r14, %rsi
callq 0x18bc0
testl %eax, %eax
je 0x1d640
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x18bc0
testl %eax, %eax
je 0x1d640
movq %rbp, %rdi
leaq 0x31968(%rip), %rsi     # 0x4ef9f
callq 0x18bc0
testl %eax, %eax
jne 0x1d5de
movl 0x4(%rsp), %eax
addl 0x290(%r15), %eax
movl %eax, 0x4(%rsp)
jmp 0x1d5de
movq 0x20(%rsp), %rcx
movl 0x254(%rcx), %eax
cmpl 0x258(%rcx), %eax
jge 0x1d6ee
movq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x186c0
movl $0x74697720, (%r14,%rax) # imm = 0x74697720
movl $0x206874, 0x3(%r14,%rax) # imm = 0x206874
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0x1d6bd
leaq 0x390e4(%rip), %rsi     # 0x56779
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x198c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19800
jmp 0x1d6d5
movb $0x0, 0x4(%rax)
movl $0x64616564, (%rax)     # imm = 0x64616564
jmp 0x1d6ee
movq %r14, %rdi
callq 0x186c0
movl $0x656e6f6e, (%r14,%rax) # imm = 0x656E6F6E
movw $0x20, 0x4(%r14,%rax)
movq %r14, %rdi
callq 0x186c0
movl $0x7261656e, (%r14,%rax) # imm = 0x7261656E
movl $0x796272, 0x3(%r14,%rax) # imm = 0x796272
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_artifact
void replace_artifact(edict_t *person, char *temp)
{
	if (person->client->rune)
	{
		if (person->client->rune->item)
		{
			strcpy(temp,person->client->rune->item->pickup_name);
		}
		else
		{
			strcpy(temp, "an unnamed artifact of power");
		}
	}
	else
	{
		strcpy(temp, "no artifact");
	}
}

// Assembly:
movq 0x58(%rdi), %rax
movq 0xf68(%rax), %rax
testq %rax, %rax
je 0x1d728
movq 0x330(%rax), %rax
testq %rax, %rax
je 0x1d73d
movq 0x50(%rax), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x182c0
movabsq $0x6669747261206f6e, %rax # imm = 0x6669747261206F6E
movq %rax, (%rsi)
movl $0x746361, 0x8(%rsi)    # imm = 0x746361
retq
movups 0x31aa0(%rip), %xmm0    # 0x4f1e4
movups %xmm0, 0xd(%rsi)
movups 0x31a88(%rip), %xmm0    # 0x4f1d7
movups %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_team
void replace_team(edict_t *person, char *temp)
{
	if (person->client->ctf.teamnum == CTF_TEAM_RED)
		strcpy(temp, "red team");
	else if (person->client->ctf.teamnum == CTF_TEAM_BLUE)
		strcpy(temp, "blue team");
	else
		strcpy(temp, "unassigned team");
}

// Assembly:
movq 0x58(%rdi), %rax
movl 0x1100(%rax), %eax
cmpl $0x2, %eax
je 0x1d7ac
cmpl $0x1, %eax
jne 0x1d7c0
movabsq $0x6d61657420646572, %rax # imm = 0x6D61657420646572
movq %rax, (%rsi)
movb $0x0, 0x8(%rsi)
retq
movabsq $0x6165742065756c62, %rax # imm = 0x6165742065756C62
movq %rax, (%rsi)
movw $0x6d, 0x8(%rsi)
retq
movups 0x31a56(%rip), %xmm0    # 0x4f21d
movups %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_flaginfo
void replace_flaginfo(edict_t *person, char *temp)
{
	int flagcount=CTF_TEAM_UNDEFINED+1;										   
	edict_t *whichflag = NULL;

	if (!ctf_validateplayer(person, CTF_TEAM_IGNORETEAM))
		return;// only works for valid players

	strcpy(temp,"");
	while (flagcount < CTF_TEAM_LIMIT)
	{
		if (flagcount == person->client->ctf.teamnum)
			strcat(temp, "Your ");
		else
			strcat(temp, "The enemy ");
		ctf_teamstring(temp, flagcount, CTF_TEAM_MATCHING);
		strcat(temp, " flag ");
		whichflag = ctf_getteamflag(flagcount, CTF_TEAM_MATCHING);
		if (!whichflag)
			strcat(temp, "is missing.  ");
		else if (whichflag->owner)
		{
			strcat(temp,"is held by ");
			strcat(temp,whichflag->owner->client->pers.netname );
			strcat(temp,".  ");
		}
		else if (!ctf_flagathome(whichflag))
			strcat(temp, "is sitting around.  ");
		else
			strcat(temp, "is at home.  " );

		flagcount++;
	}
	strcat(temp,"\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x4
popq %rsi
callq 0x18de0
testl %eax, %eax
je 0x1d953
movb $0x0, (%rbx)
pushq $0x1
popq %rbp
pushq $-0x7
popq %r15
movabsq $0x6d656e6520656854, %r13 # imm = 0x6D656E6520656854
cmpl $0x3, %ebp
je 0x1d945
movq 0x58(%r14), %rax
movl 0x1100(%rax), %r12d
movq %rbx, %rdi
callq 0x186c0
addq %rbx, %rax
cmpl %r12d, %ebp
jne 0x1d832
movw $0x20, 0x4(%rax)
movl $0x72756f59, (%rax)     # imm = 0x72756F59
jmp 0x1d83c
movq %r13, (%rax)
movl $0x20796d, 0x7(%rax)    # imm = 0x20796D
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x18210
movq %rbx, %rdi
callq 0x186c0
movl $0x616c6620, (%rbx,%rax) # imm = 0x616C6620
movl $0x206761, 0x3(%rbx,%rax) # imm = 0x206761
movl %ebp, %edi
movl %r15d, %esi
callq 0x18e90
testq %rax, %rax
je 0x1d8c7
movq %rax, %r12
cmpq $0x0, 0x110(%rax)
je 0x1d8ee
movq %rbx, %rdi
callq 0x186c0
movabsq $0x20646c6568207369, %rcx # imm = 0x20646C6568207369
movq %rcx, (%rbx,%rax)
movl $0x207962, 0x8(%rbx,%rax) # imm = 0x207962
movq 0x110(%r12), %rax
movq 0x58(%rax), %rsi
movl $0x2c0, %eax            # imm = 0x2C0
addq %rax, %rsi
movq %rbx, %rdi
callq 0x19800
movq %rbx, %rdi
callq 0x186c0
movl $0x20202e, (%rbx,%rax)  # imm = 0x20202E
jmp 0x1d93e
movq %rbx, %rdi
callq 0x186c0
movabsq $0x697373696d207369, %rcx # imm = 0x697373696D207369
movq %rcx, (%rbx,%rax)
movabsq $0x20202e676e6973, %rcx # imm = 0x20202E676E6973
movq %rcx, 0x6(%rbx,%rax)
jmp 0x1d93e
movq %r12, %rdi
callq 0x195d0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x186c0
addq %rbx, %rax
testl %r12d, %r12d
je 0x1d926
movabsq $0x20202e656d6f68, %rcx # imm = 0x20202E656D6F68
movq %rcx, 0x6(%rax)
movabsq $0x6f68207461207369, %rcx # imm = 0x6F68207461207369
movq %rcx, (%rax)
jmp 0x1d93e
movups 0x3192b(%rip), %xmm0    # 0x4f258
movups %xmm0, (%rax)
movabsq $0x20202e646e756f, %rcx # imm = 0x20202E646E756F
movq %rcx, 0xd(%rax)
incl %ebp
jmp 0x1d800
movq %rbx, %rdi
callq 0x186c0
movw $0xa, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_viewinfo
void replace_viewinfo(edict_t *person, char *temp)
{
	strcpy(temp, "");
	if (person->client->ctf.popup_ent)
	{
		strcpy(temp, person->client->ctf.popup_ent->client->pers.netname);
		temp[15] = 0;
	}
}

// Assembly:
movb $0x0, (%rsi)
movq 0x58(%rdi), %rax
movq 0x9130(%rax), %rax
testq %rax, %rax
je 0x1d98f
pushq %rbx
movq %rsi, %rbx
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%rax), %rsi
movq %rbx, %rdi
callq 0x182c0
movb $0x0, 0xf(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_carrierinfo
void replace_carrierinfo(edict_t *person, char *temp)
{
	edict_t * teamflag;

	teamflag = ctf_getteamflag(person->client->ctf.teamnum, CTF_TEAM_OPPOSING);

	if (teamflag)
	{
		if (ctf_validateplayer(teamflag->owner, person->client->ctf.teamnum))
		{
			strcpy(temp, teamflag->owner->client->pers.netname);
			strcat(temp, " is at ");
			replace_location(teamflag->owner, temp, true, true);
		}
		else
		{
			strcpy(temp, " no carrier");
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x58(%rdi), %rax
movl 0x1100(%rax), %edi
pushq $-0x6
popq %rsi
callq 0x18e90
testq %rax, %rax
je 0x1da2a
movq %rax, %r14
movq 0x110(%rax), %rdi
movq 0x58(%r15), %rax
movl 0x1100(%rax), %esi
callq 0x18de0
testl %eax, %eax
je 0x1da16
movq 0x110(%r14), %rax
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%rax), %rsi
movq %rbx, %rdi
callq 0x182c0
movq %rbx, %rdi
callq 0x186c0
movabsq $0x20746120736920, %rcx # imm = 0x20746120736920
movq %rcx, (%rbx,%rax)
movq 0x110(%r14), %rdi
pushq $0x1
popq %rcx
movq %rbx, %rsi
movl %ecx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x18e40
movabsq $0x72726163206f6e20, %rax # imm = 0x72726163206F6E20
movq %rax, (%rbx)
movl $0x726569, 0x8(%rbx)    # imm = 0x726569
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: visibility_test
qboolean visibility_test(edict_t *one, edict_t *two)
{
	trace_t	traceresult;
	
	//movetype push obs have bogus origins
	if (one->movetype == MOVETYPE_PUSH)
		return false; //pretend we can't see it
	if (two->movetype == MOVETYPE_PUSH)
		return false; //pretend we can't see it
	
	traceresult = gi.trace(one->s.origin, NULL, NULL, two->s.origin, one, MASK_SOLID);
	if (traceresult.fraction == 1.0)
		return true;
	return false;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, 0x118(%rdi)
je 0x1da8e
movq %rsi, %r8
cmpl $0x2, 0x118(%rsi)
je 0x1da8e
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r9
movq 0x48baa(%rip), %rax     # 0x66600
leaq 0x4(%rdi), %rsi
addq $0x4, %r8
movl $0x3, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x60(%rax)
movss 0x314ac(%rip), %xmm0    # 0x4ef28
cmpeqss 0x8(%rbx), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: replace_visibleplayers
void replace_visibleplayers(edict_t *person, char *temp)
{
	edict_t *cur = NULL;
	qboolean more_than_one = false;	
	
	strcpy(temp,"");
	while ((cur = findradius(cur, person->s.origin, 2048)) != NULL)
	{
		if (cur->client)
		{
			if (cur->inuse && cur != person && visibility_test(person, cur) )
			{
				if (more_than_one)
					strcat(temp," and");
				strcat(temp, cur->client->pers.netname);
				more_than_one = true;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, (%rsi)
leaq 0x4(%rdi), %r15
movb $0x1, %bpl
xorl %r12d, %r12d
movl $0x2c0, %r13d           # imm = 0x2C0
movq %r12, %rdi
movq %r15, %rsi
movss 0x3146b(%rip), %xmm0    # 0x4ef2c
callq 0x19a50
testq %rax, %rax
je 0x1db1f
movq %rax, %r12
cmpq $0x0, 0x58(%rax)
je 0x1dab3
cmpq %r14, %r12
je 0x1dab3
cmpl $0x0, 0x60(%r12)
je 0x1dab3
movq %r14, %rdi
movq %r12, %rsi
callq 0x18430
testl %eax, %eax
je 0x1dab3
testb $0x1, %bpl
jne 0x1db0b
movq %rbx, %rdi
callq 0x186c0
movl $0x646e6120, (%rbx,%rax) # imm = 0x646E6120
movb $0x0, 0x4(%rbx,%rax)
movq 0x58(%r12), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x19800
xorl %ebp, %ebp
jmp 0x1dab3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_replace.c
// Function: LowerCase
void LowerCase(char* src)
{
	size_t len;
	size_t i;

	len = strlen(src);
	for (i = 0; i < len; i++)
	{
		src[i] = tolower(src[i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x186c0
movq %rax, %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x1db5f
callq 0x19c00
movq (%rax), %rax
movsbq (%rbx,%r15), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rbx,%r15)
incq %r15
jmp 0x1db41
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_runes.c
// Function: SelectFarthestRuneSpawnPoint
edict_t *SelectFarthestRuneSpawnPoint (void)
{
	edict_t	*bestspot;
	float	bestdistance, bestrunedistance;
	edict_t	*spot;


	spot = NULL;
	bestspot = NULL;
	bestdistance = 0;
	spot = G_Find (spot, FOFS(classname), "item_health");
	while (spot)
	{
		bestrunedistance = RunesRangeFromSpot (spot);
		
		if (bestrunedistance > bestdistance)
		{
			bestspot = spot;
			bestdistance = bestrunedistance;
		}
		spot = G_Find (spot, FOFS(classname), "item_health");
	}

	if (bestspot)
	{
	    return bestspot;
	}

	spot = SelectRuneSpawnPoint();

	return spot;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x312f1(%rip), %r14     # 0x4f1b7
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x138, %esi            # imm = 0x138
movq %r14, %rdx
callq 0x195e0
movq %rax, %r15
xorps %xmm0, %xmm0
testq %r15, %r15
je 0x1df22
movq %r15, %rdi
movss %xmm0, 0xc(%rsp)
callq 0x19a20
movss 0xc(%rsp), %xmm1
ucomiss %xmm1, %xmm0
cmovaq %r15, %rbx
maxss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r15, %rdi
movl $0x138, %esi            # imm = 0x138
movq %r14, %rdx
callq 0x195e0
movq %rax, %r15
movss 0xc(%rsp), %xmm0
jmp 0x1dedd
testq %rbx, %rbx
je 0x1df34
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x18400
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_runes.c
// Function: Pickup_Rune
qboolean Pickup_Rune (edict_t *ent, edict_t *other)
{
	if (!other->client->rune) // don't already have rune
	{
		// Make sure it will respawn
		ent->flags |= FL_RESPAWN;
		ent->think = NULL;
		ent->nextthink = 0;

		other->client->pers.inventory[ITEM_INDEX(ent->item)]++;
		ent->owner = other;
		other->client->rune = ent;
		ent->solid = SOLID_NOT;
		gi.linkentity (ent); //always pair with solid changes

		ent->svflags |= SVF_NOCLIENT;
		ent->movetype = MOVETYPE_NONE;  // Don't block doors
		gi.sound(ent, CHAN_ITEM, gi.soundindex("misc/power1.wav"), 1, ATTN_NORM, 0);
		return true;
	}

	ent->touch = Touch_Item;
	ent->think = Rune_Think;
	ent->nextthink = level.time + FRAMETIME;
	
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rsi), %rcx
cmpq $0x0, 0xf68(%rcx)
je 0x1e483
movq 0x48435(%rip), %rax     # 0x66880
movq %rax, 0x220(%rbx)
movq 0x487c7(%rip), %rax     # 0x66c20
movq %rax, 0x210(%rbx)
movq 0x48939(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x30e1c(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
xorl %eax, %eax
jmp 0x1e517
orb $-0x80, 0x11f(%rbx)
andq $0x0, 0x210(%rbx)
andl $0x0, 0x200(%rbx)
movq 0x330(%rbx), %rax
subq 0x48999(%rip), %rax     # 0x66e40
movl $0x88, %edi
cqto
idivq %rdi
incl 0x318(%rcx,%rax,4)
movq %rsi, 0x110(%rbx)
movq %rbx, 0xf68(%rcx)
andl $0x0, 0x108(%rbx)
movq 0x4812c(%rip), %r14     # 0x66600
movq %rbx, %rdi
callq *0x90(%r14)
orb $0x1, 0xc8(%rbx)
andl $0x0, 0x118(%rbx)
movq 0x20(%r14), %r15
leaq 0x33d85(%rip), %rdi     # 0x5227c
callq *0x48(%r14)
pushq $0x3
popq %rsi
movss 0x30a22(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_runes.c
// Function: Drop_Rune_Think
void Drop_Rune_Think (edict_t *ent)
{
	ent->touch = Touch_Item;
	ent->owner = NULL;
	ent->think = Rune_Think;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
movq 0x4835c(%rip), %rax     # 0x66880
movq %rax, 0x220(%rdi)
andq $0x0, 0x110(%rdi)
movq 0x486e6(%rip), %rax     # 0x66c20
movq %rax, 0x210(%rdi)
movq 0x48858(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x30d3b(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_runes.c
// Function: tossruneset
static void tossruneset(edict_t *ent)
{
	ent->svflags &= ~SVF_NOCLIENT;
	ent->flags |= FL_RESPAWN;
	ent->spawnflags = DROPPED_ITEM;
	
	if (ent->model)
		gi.setmodel (ent, ent->model);
	else
		gi.setmodel (ent, ent->item->world_model);
	ent->movetype = MOVETYPE_TOSS;  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andb $-0x2, 0xc8(%rdi)
orb $-0x80, 0x11f(%rdi)
movl $0x10000, 0x140(%rdi)   # imm = 0x10000
movq 0x120(%rdi), %rsi
movq 0x47e77(%rip), %rax     # 0x66600
movq 0x58(%rax), %rax
testq %rsi, %rsi
jne 0x1e79d
movq 0x330(%rbx), %rcx
movq 0x30(%rcx), %rsi
movq %rbx, %rdi
callq *%rax
movl $0x7, 0x118(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_runes.c
// Function: DamageRuneHook
int DamageRuneHook(edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, int knockback, int dflags)
{
	if (attacker && attacker->client && attacker->client->rune)
	{
		if (attacker->client->rune->runetype == RUNE_DAMAGE)
		{
			//damage *=2; // Double damage
			damage *= 1.75f; //-bat
		}
	}
	
	return damage;
}

// Assembly:
movl %ecx, %eax
testq %rdx, %rdx
je 0x1e7e3
movq 0x58(%rdx), %rcx
testq %rcx, %rcx
je 0x1e7e3
movq 0xf68(%rcx), %rcx
testq %rcx, %rcx
je 0x1e7e3
cmpl $0x1, 0x478(%rcx)
jne 0x1e7e3
cvtsi2ss %eax, %xmm0
mulss 0x30acd(%rip), %xmm0    # 0x4f2ac
cvttss2si %xmm0, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_runes.c
// Function: ResistRuneHook
int ResistRuneHook(edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, int knockback, int dflags)
{
	if (targ && targ->client && targ->client->rune)
	{
		if (targ->client->rune->runetype == RUNE_RESIST)
		{
			//damage /=2; // Half damage
			damage /= 1.75f; //-bat needs to offset damage rune.
			gi.sound(targ, CHAN_ITEM, gi.soundindex("ctf/resist.wav"), 1, ATTN_NORM, 0);
		}
	}
	
	return damage;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
testq %rdi, %rdi
je 0x1e84f
movq %rdi, %r14
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1e84f
movq 0xf68(%rax), %rax
testq %rax, %rax
je 0x1e84f
cmpl $0x2, 0x478(%rax)
jne 0x1e84f
cvtsi2ss %ebx, %xmm0
divss 0x30a8f(%rip), %xmm0    # 0x4f2ac
cvttss2si %xmm0, %ebx
movq 0x47dd8(%rip), %rax     # 0x66600
movq 0x20(%rax), %r15
leaq 0x30bcb(%rip), %rdi     # 0x4f3fe
callq *0x48(%rax)
pushq $0x3
popq %rsi
movss 0x306e7(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %r14, %rdi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq