LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4dc84(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1b9a4
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1b97c
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1b9d3
callq *0x110(%r14)
leaq 0x3838d(%rip), %rdi     # 0x53d67
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4e0ff(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1ba0b
callq *0x110(%r14)
leaq 0x377d8(%rip), %rdi     # 0x531ea
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movq 0xfb0(%rcx), %rdi
testq %rdi, %rdi
je 0x1ba40
callq *0x110(%r14)
leaq 0x3832b(%rip), %rdi     # 0x53d72
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfb0(%rcx)
movq 0x4de5a(%rip), %rax     # 0x698b8
movq %rax, 0xfb8(%rcx)
movq 0xfc0(%rcx), %rdi
testq %rdi, %rdi
je 0x1ba78
callq *0x110(%r14)
leaq 0x382ff(%rip), %rdi     # 0x53d7e
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfc0(%rcx)
movq 0x4d95a(%rip), %rax     # 0x693f0
movq %rax, 0xfc8(%rcx)
movq 0xfd0(%rcx), %rdi
testq %rdi, %rdi
je 0x1bab0
callq *0x110(%r14)
leaq 0x382d3(%rip), %rdi     # 0x53d8a
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfd0(%rcx)
movq 0x4e1ca(%rip), %rax     # 0x69c98
movq %rax, 0xfd8(%rcx)
movq 0xfe0(%rcx), %rdi
testq %rdi, %rdi
je 0x1bae8
callq *0x110(%r14)
leaq 0x382a7(%rip), %rdi     # 0x53d96
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfe0(%rcx)
movq 0x4daaa(%rip), %rax     # 0x695b0
movq %rax, 0xfe8(%rcx)
movq 0xff0(%rcx), %rdi
testq %rdi, %rdi
je 0x1bb20
callq *0x110(%r14)
leaq 0x3827b(%rip), %rdi     # 0x53da2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xff0(%rcx)
movq 0x4e16a(%rip), %rax     # 0x69ca8
movq %rax, 0xff8(%rcx)
movq 0x4e28c(%rip), %rax     # 0x69dd8
cmpl $-0x2, (%rax)
je 0x1bb89
movq 0x1000(%rcx), %rdi
testq %rdi, %rdi
je 0x1bb64
callq *0x110(%r14)
leaq 0x38243(%rip), %rdi     # 0x53dae
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x1000(%rcx)
movq 0x4e31e(%rip), %rax     # 0x69ea0
movq %rax, 0x1008(%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x196c0
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r15d, %r15d
movq 0x4da4c(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1bbdc
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1bbb4
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1bc0b
callq *0x110(%r14)
leaq 0x381bf(%rip), %rdi     # 0x53dd1
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4dec7(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1bc43
callq *0x110(%r14)
leaq 0x3759b(%rip), %rdi     # 0x531e5
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
xorl %edi, %edi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
testq %rax, %rax
je 0x1bce7
movq %rax, %r14
movl $0x2, %r12d
leaq 0x38159(%rip), %r15     # 0x53de1
movq %rsp, %r13
movq 0x4dd4e(%rip), %rbp     # 0x699e0
movq 0x58(%r14), %rcx
movq 0x9120(%rcx), %rdx
addq $0x2c0, %rcx            # imm = 0x2C0
movq %r13, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x18370
movq %r14, %rdi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
testq %rax, %rax
je 0x1bce7
movq %rax, %r14
leal 0x1(%r12), %eax
cmpl $0x10, %r12d
movl %eax, %r12d
jb 0x1bc92
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4d8c5(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1bd63
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1bd3b
movq 0x58(%rbx), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0xf84(%rax)
xorl %eax, %eax
callq 0x18590
movq 0x58(%rbx), %rax
movq 0xfa0(%rax), %rdi
testq %rdi, %rdi
je 0x1bda3
callq *0x110(%r14)
leaq 0x3796f(%rip), %rdi     # 0x53719
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq 0x4dd2f(%rip), %rax     # 0x69af0
movq %rax, 0xfa8(%rcx)
movq 0xfb0(%rcx), %rdi
testq %rdi, %rdi
je 0x1bddb
callq *0x110(%r14)
leaq 0x373ff(%rip), %rdi     # 0x531e1
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfb0(%rcx)
movq $0x0, 0xfb8(%rcx)
movq 0x4d9f4(%rip), %rax     # 0x697f8
cmpq $0x0, (%rax)
je 0x1be1d
movq 0x4db87(%rip), %rax     # 0x69998
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x1, %al
jne 0x1be26
leaq 0x37921(%rip), %rdx     # 0x53745
jmp 0x1be2d
leaq 0x37911(%rip), %rdx     # 0x5373e
leaq 0x378f9(%rip), %rsi     # 0x5372d
movq %rsp, %rdi
xorl %eax, %eax
callq 0x19700
movq 0x58(%rbx), %rax
movq 0xfc0(%rax), %rdi
testq %rdi, %rdi
je 0x1be55
callq *0x110(%r14)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfc0(%rcx)
movq 0x4d699(%rip), %rax     # 0x69508
movq %rax, 0xfc8(%rcx)
movq 0x4d9e3(%rip), %rax     # 0x69860
cmpq $0x0, (%rax)
je 0x1be96
movq 0x4db0e(%rip), %rax     # 0x69998
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x2, %al
jne 0x1be9f
leaq 0x378a8(%rip), %rdx     # 0x53745
jmp 0x1bea6
leaq 0x37898(%rip), %rdx     # 0x5373e
leaq 0x3789f(%rip), %rsi     # 0x5374c
movq %rsp, %rdi
xorl %eax, %eax
callq 0x19700
movq 0x58(%rbx), %rax
movq 0xfd0(%rax), %rdi
testq %rdi, %rdi
je 0x1bece
callq *0x110(%r14)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfd0(%rcx)
movq 0x4d538(%rip), %rax     # 0x69420
movq %rax, 0xfd8(%rcx)
movq %rbx, %rdi
callq 0x196c0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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), %ecx
leal (%rcx,%rcx,4), %edx
leal (%rdx,%rdx,2), %r14d
testl %ecx, %ecx
jle 0x1bf5a
leal -0xf(%r14), %ecx
movslq %ecx, %rcx
movq 0x4dc3d(%rip), %rdx     # 0x69b78
cmpq $0x0, (%rdx,%rcx,8)
jne 0x1bf4f
movl $0x0, 0x10c0(%rax)
xorl %r14d, %r14d
incq %rcx
movslq %r14d, %rsi
cmpq %rsi, %rcx
jl 0x1bf3b
xorl %r15d, %r15d
movq 0x4d69c(%rip), %r12     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1bf8d
callq *0x110(%r12)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1bf64
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1bfbd
callq *0x110(%r12)
leaq 0x3773c(%rip), %rdi     # 0x53700
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4db15(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1bff6
callq *0x110(%r12)
leaq 0x371e5(%rip), %rdi     # 0x531e2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movslq %r14d, %rbp
shlq $0x3, %rbp
addq 0x4db5d(%rip), %rbp     # 0x69b78
movq $0x0, 0xfa8(%rcx)
leaq 0x376e6(%rip), %r14     # 0x53713
movq %rsp, %r15
xorl %r13d, %r13d
movq (%rbp,%r13,8), %rdx
testq %rdx, %rdx
je 0x1c067
leaq 0x2(%r13), %r12
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x18370
incq %r13
cmpl $0xf, %r13d
jne 0x1c033
movq 0x58(%rbx), %rax
movq 0x10a0(%rax), %rdi
testq %rdi, %rdi
je 0x1c084
movq 0x4d582(%rip), %rax     # 0x69600
callq *0x110(%rax)
leaq 0x372db(%rip), %rdi     # 0x53366
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x10a0(%rcx)
movq 0x4d64e(%rip), %rax     # 0x696f0
movq %rax, 0x10a8(%rcx)
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4d3a1(%rip), %rax     # 0x697f8
cmpq $0x0, (%rax)
je 0x1c472
movq 0x4d534(%rip), %rax     # 0x69998
movq (%rax), %rax
cvttss2si 0x20(%rax), %esi
testb $0x1, %sil
jne 0x1c486
movq 0x4d51f(%rip), %rax     # 0x69998
movq (%rax), %rax
cvttss2si 0x20(%rax), %esi
orl $0x1, %esi
jmp 0x1c489
andl $-0x2, %esi
movq 0x4d170(%rip), %rax     # 0x69600
movq 0x128(%rax), %r14
leaq 0x373e8(%rip), %rdi     # 0x53886
xorl %eax, %eax
callq 0x19340
leaq 0x372b1(%rip), %rdi     # 0x5375d
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19b40
// File: /workspace/github_c_makefile_star2_O1/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 0x4d391(%rip), %rax     # 0x69860
cmpq $0x0, (%rax)
je 0x1c4ea
movq 0x4d4bc(%rip), %rax     # 0x69998
movq (%rax), %rax
cvttss2si 0x20(%rax), %esi
testb $0x2, %sil
jne 0x1c4fe
movq 0x4d4a7(%rip), %rax     # 0x69998
movq (%rax), %rax
cvttss2si 0x20(%rax), %esi
orl $0x2, %esi
jmp 0x1c501
andl $-0x3, %esi
movq 0x4d0f8(%rip), %rax     # 0x69600
movq 0x128(%rax), %r14
leaq 0x37370(%rip), %rdi     # 0x53886
xorl %eax, %eax
callq 0x19340
leaq 0x37239(%rip), %rdi     # 0x5375d
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19b40
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r15d, %r15d
movq 0x4d069(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1c5bf
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1c597
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0x4d0ce(%rip), %rax     # 0x696b0
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x37557(%rip), %rsi     # 0x53b48
movq %rsp, %rdi
xorl %eax, %eax
callq 0x19700
movq 0x58(%rbx), %rax
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1c612
callq *0x110(%r14)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4d624(%rip), %rax     # 0x69c50
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1c646
callq *0x110(%r14)
leaq 0x36b95(%rip), %rdi     # 0x531e2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movl $0x2, %r14d
movq 0x4d70b(%rip), %rbp     # 0x69d80
leaq 0x3720a(%rip), %r15     # 0x53886
movq %rsp, %r12
movq 0x4d2da(%rip), %r13     # 0x69960
movl (%rbp,%r14,4), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x18370
incq %r14
cmpq $0x12, %r14
jne 0x1c686
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r15d, %r15d
movq 0x4cf16(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1c712
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1c6ea
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0x4d6cb(%rip), %rax     # 0x69e00
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x3741c(%rip), %rsi     # 0x53b60
movq %rsp, %rdi
xorl %eax, %eax
callq 0x19700
movq 0x58(%rbx), %rax
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1c765
callq *0x110(%r14)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4d4d1(%rip), %rax     # 0x69c50
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1c799
callq *0x110(%r14)
leaq 0x36a42(%rip), %rdi     # 0x531e2
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movl $0x2, %r14d
movq 0x4d038(%rip), %rbp     # 0x69800
leaq 0x370b7(%rip), %r15     # 0x53886
movq %rsp, %r12
movq 0x4d807(%rip), %r13     # 0x69fe0
movl (%rbp,%r14,4), %edx
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x18370
incq %r14
cmpq $0x12, %r14
jne 0x1c7d9
movq %rbx, %rdi
callq 0x196c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4c10e(%rip), %rcx     # 0x69618
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 0x4c0cf(%rip), %rax     # 0x69600
movq 0x128(%rax), %r14
cmovael %edx, %esi
leaq 0x36344(%rip), %rdi     # 0x53886
xorl %eax, %eax
callq 0x19340
leaq 0x35fc7(%rip), %rdi     # 0x53517
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a90
// File: /workspace/github_c_makefile_star2_O1/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 0x4c5e1(%rip), %rcx     # 0x69b58
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 0x4c062(%rip), %rax     # 0x69600
movq 0x128(%rax), %r14
cmovael %edx, %esi
leaq 0x362d7(%rip), %rdi     # 0x53886
xorl %eax, %eax
callq 0x19340
leaq 0x35f66(%rip), %rdi     # 0x53523
movq %rax, %rsi
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a98
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4bc57(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1d9d1
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1d9a9
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1da00
callq *0x110(%r14)
leaq 0x362fb(%rip), %rdi     # 0x53d02
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4c0d2(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1da38
callq *0x110(%r14)
leaq 0x357a8(%rip), %rdi     # 0x531e7
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movq %rbx, %rdi
callq 0x19810
movq 0x58(%rbx), %rax
movq 0x10a0(%rax), %rdi
testq %rdi, %rdi
je 0x1da79
callq *0x110(%r14)
leaq 0x358e6(%rip), %rdi     # 0x53366
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x10a0(%rcx)
movq 0x4c409(%rip), %rax     # 0x69ea0
movq %rax, 0x10a8(%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x196c0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x4bae4(%rip), %r14     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r15), %rdi
testq %rdi, %rdi
je 0x1db44
callq *0x110(%r14)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r15)
addq $0x10, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x1db1c
movq 0x58(%rbx), %rax
movq $0x0, 0xf84(%rax)
movq 0xf90(%rax), %rdi
testq %rdi, %rdi
je 0x1db73
callq *0x110(%r14)
leaq 0x3618e(%rip), %rdi     # 0x53d08
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq 0x4bf5f(%rip), %rax     # 0x69af0
movq %rax, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1dbab
callq *0x110(%r14)
leaq 0x35635(%rip), %rdi     # 0x531e7
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movq %rbx, %rdi
callq 0x19810
movq 0x58(%rbx), %rax
movq 0x10a0(%rax), %rdi
testq %rdi, %rdi
je 0x1dbec
callq *0x110(%r14)
leaq 0x35773(%rip), %rdi     # 0x53366
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0x10a0(%rcx)
movq 0x4bf06(%rip), %rax     # 0x69b10
movq %rax, 0x10a8(%rcx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x196c0
// File: /workspace/github_c_makefile_star2_O1/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 0x193e0
movq 0x58(%rbx), %rcx
movl 0x10c0(%rcx), %esi
leal (%rsi,%rsi,4), %edx
movq 0x4c285(%rip), %rax     # 0x69ed0
movq (%rax), %r8
xorl %edi, %edi
testq %r8, %r8
je 0x1dc5d
incl %edi
movq 0x10(%r8), %r8
jmp 0x1dc50
leal (%rdx,%rdx,2), %edx
testl %esi, %esi
jle 0x1dc77
leal 0xf(%rdx), %esi
cmpl %edi, %esi
jl 0x1dc77
movl $0x0, 0x10c0(%rcx)
xorl %edx, %edx
movq (%rax), %r13
testl %edx, %edx
jle 0x1dc86
movq 0x10(%r13), %r13
decl %edx
jne 0x1dc7e
testq %r13, %r13
je 0x1dcda
movl $0x2, %ebp
leaq 0x36085(%rip), %r14     # 0x53d1c
movq %rsp, %r15
movq 0x4b9d7(%rip), %r12     # 0x69678
movq (%r13), %rdx
movl 0x8(%r13), %ecx
movl 0xc(%r13), %r8d
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x18370
cmpl $0x10, %ebp
ja 0x1dcda
movq 0x10(%r13), %r13
incl %ebp
testq %r13, %r13
jne 0x1dca1
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq 0x4c1cf(%rip), %rax     # 0x69ed0
cmpq $0x0, (%rax)
jne 0x1ddcb
movq 0x4bab6(%rip), %rax     # 0x697c8
movq (%rax), %r14
testq %r14, %r14
je 0x1ddcb
movq 0x4b763(%rip), %rax     # 0x69488
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
sete 0x7(%rsp)
xorl %r15d, %r15d
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x4ba80(%rip), %r13     # 0x697c8
xorl %r12d, %r12d
cmpq $0x0, 0x8(%rsp)
je 0x1dd8f
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x18b20
movb 0x7(%rsp), %bpl
testl %eax, %eax
je 0x1dd8a
movq 0x10(%rsp), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
sete %bpl
je 0x1dd8f
movq %r14, %rsi
callq 0x18b20
addq $0x8, %rbx
testl %eax, %eax
jne 0x1dd6e
testb %bpl, %bpl
je 0x1ddb0
testq %r12, %r12
jne 0x1dd9d
movq 0x4c135(%rip), %r12     # 0x69ed0
jmp 0x1dda1
addq $0x10, %r12
movq %r13, (%r12)
movq $0x0, 0x10(%r13)
movq %r13, %r12
incq %r15
leaq (%r15,%r15,2), %rax
movq 0x4ba0a(%rip), %rcx     # 0x697c8
leaq (%rcx,%rax,8), %r13
movq (%r13), %r14
testq %r14, %r14
jne 0x1dd4b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_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
xorl %r13d, %r13d
movq 0x4b803(%rip), %r12     # 0x69600
movq 0x58(%rbx), %rax
movq 0xf90(%rax,%r13), %rdi
testq %rdi, %rdi
je 0x1de26
callq *0x110(%r12)
movq 0x58(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xf90(%rax,%r13)
addq $0x10, %r13
cmpq $0x120, %r13            # imm = 0x120
jne 0x1ddfd
movq 0x58(%rbx), %r13
movq $0x0, 0xf84(%r13)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x182a0
movq 0xf90(%r13), %rdi
movq 0x10b8(%r13), %r15
testq %rdi, %rdi
je 0x1de68
callq *0x110(%r12)
movq %rsp, %rdi
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xf90(%rcx)
movq %r15, 0xf98(%rcx)
movq 0xfa0(%rcx), %rdi
testq %rdi, %rdi
je 0x1de96
callq *0x110(%r12)
leaq 0x3534c(%rip), %rdi     # 0x531e9
callq 0x18100
movq 0x58(%rbx), %rcx
movq %rax, 0xfa0(%rcx)
movq $0x0, 0xfa8(%rcx)
movl $0x2, %r15d
leaq 0x200(%rsp), %r12
movq 0x4b7ab(%rip), %r13     # 0x69678
movq (%r14,%r15,8), %rsi
testq %rsi, %rsi
je 0x1deef
movq %r12, %rdi
callq 0x182a0
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x18370
incq %r15
cmpq $0x12, %r15
jne 0x1decd
movq %rbx, %rdi
callq 0x196c0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x35e83(%rip), %rsi     # 0x53dbf
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x18fe0
testl %eax, %eax
je 0x1df77
movq 0x8(%rsp), %rcx
leaq 0x35e6b(%rip), %rdx     # 0x53dc3
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x18e10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18c40
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18ab0
xorl %r12d, %r12d
testl %eax, %eax
je 0x1ecb8
movl %eax, %ebp
movq 0x58(%r14), %r15
leaq 0x38dd1(%rip), %rdi     # 0x57a03
callq 0x189e0
subq 0x4b202(%rip), %rax     # 0x69e40
sarq $0x3, %rax
movabsq $-0x3c3c3c3c3c3c3c3c, %rcx # imm = 0xC3C3C3C3C3C3C3C4
imulq %rax, %rcx
movl 0x318(%r15,%rcx), %edx
testl %edx, %edx
je 0x1ecb8
leaq 0x354e6(%rip), %rsi     # 0x54149
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
callq 0x18680
addq %rbx, %rax
cmpl $0x1, %ebp
jne 0x1ec97
movabsq $0x206e6565726373, %rcx # imm = 0x206E6565726373
movq %rcx, 0x6(%rax)
movabsq $0x6373207265776f70, %rcx # imm = 0x6373207265776F70
jmp 0x1ecaf
movabsq $0x20646c65696873, %rcx # imm = 0x20646C65696873
movq %rcx, 0x6(%rax)
movabsq $0x6873207265776f70, %rcx # imm = 0x6873207265776F70
movq %rcx, (%rax)
movl $0x1, %r12d
movq %r14, %rdi
callq 0x18750
testl %eax, %eax
je 0x1ed2e
movl %eax, %ebp
movl %eax, %edi
callq 0x18c30
testq %rax, %rax
je 0x1ed2e
movq %rax, %r15
movq %rbx, %rdi
callq 0x18680
cmpq $0x2, %rax
jb 0x1ecf7
movq %rbx, %rdi
callq 0x18680
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 0x35462(%rip), %rsi     # 0x54172
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x19700
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19640
movl $0x1, %r12d
testl %r12d, %r12d
jne 0x1ed4e
movq %rbx, %rdi
callq 0x18680
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_O1/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
movq %rsi, %rax
movw $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, (%rsi)
movl 0x254(%rdi), %edx
testl %edx, %edx
jle 0x1eeb1
movq %rdi, %rbx
leaq 0x353ef(%rip), %rsi     # 0x54189
xorl %r14d, %r14d
movq %rax, 0x18(%rsp)
movq %rax, %rdi
xorl %eax, %eax
callq 0x19700
movq %rbx, 0x20(%rsp)
leaq 0x4(%rbx), %r12
movss 0x35167(%rip), %xmm0    # 0x53f24
xorl %edi, %edi
movq %r12, %rsi
callq 0x19880
testq %rax, %rax
je 0x1ee51
movq %rax, %r13
xorl %r14d, %r14d
leaq 0x353b6(%rip), %rbp     # 0x54193
leaq 0x353c1(%rip), %r15     # 0x541a5
movq 0x138(%r13), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x18b20
testl %eax, %eax
je 0x1ee2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18b20
testl %eax, %eax
je 0x1ee2f
movq %rbx, %rdi
leaq 0x353a4(%rip), %rsi     # 0x541b7
callq 0x18b20
testl %eax, %eax
je 0x1ee2f
movq %rbx, %rdi
leaq 0x35179(%rip), %rsi     # 0x53f9f
callq 0x18b20
testl %eax, %eax
jne 0x1ee36
addl 0x290(%r13), %r14d
movq %r13, %rdi
movq %r12, %rsi
movss 0x350e0(%rip), %xmm0    # 0x53f24
callq 0x19880
movq %rax, %r13
testq %rax, %rax
jne 0x1ede4
movq 0x20(%rsp), %rcx
movl 0x254(%rcx), %eax
cmpl 0x258(%rcx), %eax
jge 0x1eeee
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x18680
movl $0x74697720, (%r15,%rax) # imm = 0x74697720
movl $0x206874, 0x3(%r15,%rax) # imm = 0x206874
testl %r14d, %r14d
je 0x1eebd
leaq 0x3c637(%rip), %rsi     # 0x5b4c9
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x19700
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19640
jmp 0x1eed5
movb $0x0, 0x4(%rax)
movl $0x64616564, (%rax)     # imm = 0x64616564
jmp 0x1eeee
movq %r15, %rdi
callq 0x18680
movl $0x656e6f6e, (%r15,%rax) # imm = 0x656E6F6E
movw $0x20, 0x4(%r15,%rax)
movq %r15, %rdi
callq 0x18680
movl $0x7261656e, (%r15,%rax) # imm = 0x7261656E
movl $0x796272, 0x3(%r15,%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_O1/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 0x1ef28
movq 0x330(%rax), %rax
testq %rax, %rax
je 0x1ef3d
movq 0x50(%rax), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x182a0
movabsq $0x6669747261206f6e, %rax # imm = 0x6669747261206F6E
movq %rax, (%rsi)
movl $0x746361, 0x8(%rsi)    # imm = 0x746361
retq
movups 0x352a0(%rip), %xmm0    # 0x541e4
movups %xmm0, 0xd(%rsi)
movups 0x35288(%rip), %xmm0    # 0x541d7
movups %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1efac
cmpl $0x1, %eax
jne 0x1efc0
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 0x35256(%rip), %xmm0    # 0x5421d
movups %xmm0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x18ce0
testl %eax, %eax
je 0x1f152
movb $0x0, (%rbx)
movl $0x1, %ebp
movl $0x2c0, %r13d           # imm = 0x2C0
movabsq $0x6d656e6520656854, %r12 # imm = 0x6D656E6520656854
movq 0x58(%r14), %rax
movl 0x1100(%rax), %r15d
movq %rbx, %rdi
callq 0x18680
addq %rbx, %rax
cmpl %r15d, %ebp
jne 0x1f02f
movw $0x20, 0x4(%rax)
movl $0x72756f59, (%rax)     # imm = 0x72756F59
jmp 0x1f039
movq %r12, (%rax)
movl $0x20796d, 0x7(%rax)    # imm = 0x20796D
movq %rbx, %rdi
movl %ebp, %esi
movl $0xfffffff9, %edx       # imm = 0xFFFFFFF9
callq 0x181f0
movq %rbx, %rdi
callq 0x18680
movl $0x616c6620, (%rbx,%rax) # imm = 0x616C6620
movl $0x206761, 0x3(%rbx,%rax) # imm = 0x206761
movl %ebp, %edi
movl $0xfffffff9, %esi       # imm = 0xFFFFFFF9
callq 0x18d70
testq %rax, %rax
je 0x1f0c2
movq %rax, %r15
cmpq $0x0, 0x110(%rax)
je 0x1f0e9
movq %rbx, %rdi
callq 0x18680
movabsq $0x20646c6568207369, %rcx # imm = 0x20646C6568207369
movq %rcx, (%rbx,%rax)
movl $0x207962, 0x8(%rbx,%rax) # imm = 0x207962
movq 0x110(%r15), %rax
movq 0x58(%rax), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x19640
movq %rbx, %rdi
callq 0x18680
movl $0x20202e, (%rbx,%rax)  # imm = 0x20202E
jmp 0x1f139
movq %rbx, %rdi
callq 0x18680
movabsq $0x697373696d207369, %rcx # imm = 0x697373696D207369
movq %rcx, (%rbx,%rax)
movabsq $0x20202e676e6973, %rcx # imm = 0x20202E676E6973
movq %rcx, 0x6(%rbx,%rax)
jmp 0x1f139
movq %r15, %rdi
callq 0x19420
movl %eax, %r15d
movq %rbx, %rdi
callq 0x18680
addq %rbx, %rax
testl %r15d, %r15d
je 0x1f121
movabsq $0x20202e656d6f68, %rcx # imm = 0x20202E656D6F68
movq %rcx, 0x6(%rax)
movabsq $0x6f68207461207369, %rcx # imm = 0x6F68207461207369
movq %rcx, (%rax)
jmp 0x1f139
movups 0x35130(%rip), %xmm0    # 0x54258
movups %xmm0, (%rax)
movabsq $0x20202e646e756f, %rcx # imm = 0x20202E646E756F
movq %rcx, 0xd(%rax)
incl %ebp
cmpl $0x3, %ebp
jne 0x1f006
movq %rbx, %rdi
callq 0x18680
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_O1/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 0x1f18e
pushq %rbx
movq %rsi, %rbx
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%rax), %rsi
movq %rbx, %rdi
callq 0x182a0
movb $0x0, 0xf(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
callq 0x18d70
testq %rax, %rax
je 0x1f230
movq %rax, %r14
movq 0x110(%rax), %rdi
movq 0x58(%r15), %rax
movl 0x1100(%rax), %esi
callq 0x18ce0
testl %eax, %eax
je 0x1f21c
movq 0x110(%r14), %rax
movl $0x2c0, %esi            # imm = 0x2C0
addq 0x58(%rax), %rsi
movq %rbx, %rdi
callq 0x182a0
movq %rbx, %rdi
callq 0x18680
movabsq $0x20746120736920, %rcx # imm = 0x20746120736920
movq %rcx, (%rbx,%rax)
movq 0x110(%r14), %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %r15
jmp 0x18d40
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_O1/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 0x1f294
movq %rsi, %r8
cmpl $0x2, 0x118(%rsi)
je 0x1f294
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r9
movq 0x4a3a4(%rip), %rax     # 0x69600
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 0x34ca6(%rip), %xmm0    # 0x53f28
cmpeqss 0x8(%rbx), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ebp, %ebp
movss 0x34c75(%rip), %xmm0    # 0x53f2c
xorl %edi, %edi
movq %r15, %rsi
callq 0x19880
testq %rax, %rax
je 0x1f33b
movq %rax, %r12
movl $0x2c0, %r13d           # imm = 0x2C0
cmpq $0x0, 0x58(%r12)
je 0x1f320
cmpq %r14, %r12
je 0x1f320
cmpl $0x0, 0x60(%r12)
je 0x1f320
movq %r14, %rdi
movq %r12, %rsi
callq 0x18400
testl %eax, %eax
je 0x1f320
testl %ebp, %ebp
je 0x1f30b
movq %rbx, %rdi
callq 0x18680
movl $0x646e6120, (%rbx,%rax) # imm = 0x646E6120
movb $0x0, 0x4(%rbx,%rax)
movq 0x58(%r12), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x19640
movl $0x1, %ebp
movq %r12, %rdi
movq %r15, %rsi
movss 0x34bfe(%rip), %xmm0    # 0x53f2c
callq 0x19880
movq %rax, %r12
testq %rax, %rax
jne 0x1f2cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_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 0x18680
testq %rax, %rax
je 0x1f37e
movq %rax, %r14
xorl %r15d, %r15d
callq 0x19a30
movq (%rax), %rcx
movsbq (%rbx,%r15), %rdx
movb (%rcx,%rdx,4), %cl
movb %cl, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x1f367
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x34a97(%rip), %rdx     # 0x541b7
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x19430
testq %rax, %rax
je 0x1f785
movq %rax, %r14
xorps %xmm0, %xmm0
xorl %ebx, %ebx
leaq 0x34a75(%rip), %r15     # 0x541b7
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
callq 0x19850
movss 0xc(%rsp), %xmm1
ucomiss %xmm1, %xmm0
cmovaq %r14, %rbx
maxss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movl $0x138, %esi            # imm = 0x138
movq %r15, %rdx
callq 0x19430
movq %rax, %r14
movss 0xc(%rsp), %xmm0
testq %rax, %rax
jne 0x1f742
testq %rbx, %rbx
je 0x1f797
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x183d0
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rsi), %rax
cmpq $0x0, 0xf68(%rax)
je 0x1fd4a
movq 0x49b6e(%rip), %rax     # 0x69880
movq %rax, 0x220(%rbx)
movq 0x49f00(%rip), %rax     # 0x69c20
movq %rax, 0x210(%rbx)
movq 0x4a072(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x34555(%rip), %xmm0    # 0x54290
movss %xmm0, 0x200(%rbx)
xorl %eax, %eax
jmp 0x1fdec
orb $-0x80, 0x11f(%rbx)
movq $0x0, 0x210(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x200(%rbx)
movq 0x330(%rbx), %rcx
subq 0x4a0ce(%rip), %rcx     # 0x69e40
sarq $0x3, %rcx
movabsq $-0x3c3c3c3c3c3c3c3c, %rdx # imm = 0xC3C3C3C3C3C3C3C4
imulq %rcx, %rdx
incl 0x318(%rax,%rdx)
movq %rsi, 0x110(%rbx)
movq %rbx, 0xf68(%rax)
movl %ebp, 0x108(%rbx)
movq 0x4985a(%rip), %r14     # 0x69600
movq %rbx, %rdi
callq *0x90(%r14)
orb $0x1, 0xc8(%rbx)
movl %ebp, 0x118(%rbx)
movq 0x20(%r14), %r15
leaq 0x373e0(%rip), %rdi     # 0x571a8
callq *0x48(%r14)
movss 0x34154(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x3, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq