LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_AngleInfo_f
void Cmd_AngleInfo_f (edict_t *ent)
{
	double a1, a2, a3;
	double t1, t2, t3;
	vec3_t tempvec;
	char message[MAX_INFO_STRING];

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movss 0xebc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movss 0xec0(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movss 0xec4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
leaq -0x44(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x192a0
movss -0x44(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x40(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x250(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movsd -0x30(%rbp), %xmm4
movsd -0x38(%rbp), %xmm5
leaq 0x437de(%rip), %rsi     # 0x718b5
movb $0x6, %al
callq 0x19940
movq -0x8(%rbp), %rdi
leaq -0x250(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Unhook_f
void Cmd_Unhook_f (edict_t *ent)
{
	gitem_t		*it;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x545b5(%rip), %rax     # 0x82b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2e5f5
leaq 0x4221d(%rip), %rdi     # 0x707d7
callq 0x18a90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x730(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x2e5ea
movq -0x8(%rbp), %rdi
leaq 0x43707(%rip), %rsi     # 0x71cea
callq 0x18d80
jmp 0x2e5f5
movq -0x8(%rbp), %rdi
callq 0x18690
jmp 0x2e5f5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Refmenu_f
void Cmd_Refmenu_f (edict_t *ent)
{
	if (!(ent->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee\n");
		return;
	}

	ent->client->showmenu = true;
	Ref_Main_Menu(ent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x2e659
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x436a1(%rip), %rdx     # 0x71cf3
callq 0x18f20
jmp 0x2e674
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0xf80(%rax)
movq -0x8(%rbp), %rdi
callq 0x19da8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Compass_f
void Cmd_Compass_f (edict_t *ent)
{
	char *p;

	p = gi.args();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x5301d(%rip), %rax     # 0x82600
callq *0x148(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x2f60e
movq -0x10(%rbp), %rdi
leaq 0x429a5(%rip), %rsi     # 0x71fa9
callq 0x18bf0
cmpl $0x0, %eax
jne 0x2f63a
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0x1118(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x42a25(%rip), %rdx     # 0x72055
callq 0x18f20
jmp 0x2f736
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
je 0x2f65b
movq -0x10(%rbp), %rdi
leaq 0x42a1e(%rip), %rsi     # 0x7206f
callq 0x18bf0
cmpl $0x0, %eax
jne 0x2f687
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0x1118(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x429f9(%rip), %rdx     # 0x72076
callq 0x18f20
jmp 0x2f734
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x32, %eax
je 0x2f6a8
movq -0x10(%rbp), %rdi
leaq 0x4740d(%rip), %rsi     # 0x76aab
callq 0x18bf0
cmpl $0x0, %eax
jne 0x2f6d1
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x2, 0x1118(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x429d1(%rip), %rdx     # 0x7209b
callq 0x18f20
jmp 0x2f732
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x33, %eax
je 0x2f6f2
movq -0x10(%rbp), %rdi
leaq 0x48433(%rip), %rsi     # 0x77b1b
callq 0x18bf0
cmpl $0x0, %eax
jne 0x2f71b
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x3, 0x1118(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x429a0(%rip), %rdx     # 0x720b4
callq 0x18f20
jmp 0x2f730
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x429ba(%rip), %rdx     # 0x720e5
callq 0x18f20
jmp 0x2f732
jmp 0x2f734
jmp 0x2f736
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_GotoMap_f
void Cmd_GotoMap_f (edict_t *ent)
{
	char *p;
	int i;
	char message[MAX_INFO_STRING];

	if (!(ent->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee.\n");
		return;
	}


	p = gi.args();

	if (strlen(p))
	{
		// convert to lower case for comparison
		for (i = 0; i < (int)strlen(p); i++)
			p[i] = tolower(p[i]);

		for (i=0; maplist[i].mapname; i++)
		{
			if (!strcmp(maplist[i].mapname, p))
			{
				ctf_ChangeMap(p, false);
				return;
			}
		}
		sprintf(message, "%s is not a map from the maplist.\n", p);
		ctf_SafePrint(ent, PRINT_HIGH, message);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x2f92f
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x42855(%rip), %rdx     # 0x7217a
callq 0x18f20
jmp 0x2fa2c
movq 0x52cca(%rip), %rax     # 0x82600
callq *0x148(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x186e0
cmpq $0x0, %rax
je 0x2fa2c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x224(%rbp)
movq -0x10(%rbp), %rdi
callq 0x186e0
movq %rax, %rcx
movl -0x224(%rbp), %eax
cmpl %ecx, %eax
jge 0x2f9a2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x19070
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f95a
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
movq 0x52e14(%rip), %rax     # 0x827c8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x2f9fe
movslq -0x14(%rbp), %rcx
movq 0x52dfc(%rip), %rax     # 0x827c8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x2f9f1
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x19990
jmp 0x2fa2c
jmp 0x2f9f3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f9a9
leaq -0x220(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x42782(%rip), %rsi     # 0x72192
movb $0x0, %al
callq 0x19940
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Users_f
void Cmd_Users_f (edict_t *ent)
{
//	int		i;
//	int		count=0;
//	char	small[64];
//	char	large[1280];

	char message[MAX_INFO_STRING];
	char status[MAX_INFO_STRING];

	// print information
	edict_t * player = NULL;
	player = ctf_findplayer(NULL, NULL, CTF_TEAM_IGNORETEAM);
	while (player)
	{
		strcpy(status, "");
		if (player->client->ctf.extra_flags & CTF_EXTRAFLAGS_RCON)
			strcat(status, "[RCON] ");
		else if (player->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE)
			strcat(status, "(REF)  ");
		else
			strcat(status, "PLAYER ");
		sprintf(message, " id: %lu %s frags: %d\n",
			player->client->ctf.ctfid,
			player->client->pers.netname,
			player->client->ps.stats[STAT_FRAGS]);
		strcat(status, message);
		ctf_SafePrint(ent, PRINT_HIGH, status);

		player = ctf_findplayer(player, NULL, CTF_TEAM_IGNORETEAM);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq $0x0, -0x418(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
movq %rsi, %rdi
callq 0x19340
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
je 0x2fba0
leaq -0x410(%rbp), %rdi
leaq 0x414f2(%rip), %rsi     # 0x70f80
callq 0x182c0
movq -0x418(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2fac1
leaq -0x410(%rbp), %rdi
leaq 0x426fb(%rip), %rsi     # 0x721b5
callq 0x19880
jmp 0x2fb04
movq -0x418(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2faef
leaq -0x410(%rbp), %rdi
leaq 0x426d5(%rip), %rsi     # 0x721bd
callq 0x19880
jmp 0x2fb02
leaq -0x410(%rbp), %rdi
leaq 0x426c8(%rip), %rsi     # 0x721c5
callq 0x19880
jmp 0x2fb04
leaq -0x210(%rbp), %rdi
movq -0x418(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x9120(%rax), %rdx
movq -0x418(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0xc0, %rcx
addq $0x200, %rcx            # imm = 0x200
movq -0x418(%rbp), %rax
movq 0x58(%rax), %rax
movswl 0x94(%rax), %r8d
leaq 0x4267d(%rip), %rsi     # 0x721cd
movb $0x0, %al
callq 0x19940
leaq -0x410(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x19880
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
movq -0x418(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19340
movq %rax, -0x418(%rbp)
jmp 0x2fa72
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_QuadTime_f
void Cmd_QuadTime_f (edict_t *ent) {
        unsigned long i=0;
        char *p;
        gitem_t * target = NULL;

        if (!(ent->client->ctf.extra_flags & (CTF_EXTRAFLAGS_REFEREE | CTF_EXTRAFLAGS_RCON)))
        {
                ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee or Rcon\n");
                return;
        }

        p = gi.args();
        if (!sscanf(p, "%lu", &i))
        {
                ctf_SafePrint(ent, PRINT_HIGH, "Usage: quadtime <seconds>\n");
                return;
        }

	target = FindItem("Quad Damage");
	if (target && i > 0 && i < 1200) {
		target->quantity = i;
                ctf_SafePrint(ent, PRINT_HIGH, "Quad respawn updated\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x6, %eax
cmpl $0x0, %eax
jne 0x2fe4c
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x4249a(%rip), %rdx     # 0x722dc
callq 0x18f20
jmp 0x2fed9
movq 0x527ad(%rip), %rax     # 0x82600
callq *0x148(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x3ff47(%rip), %rsi     # 0x6fdaf
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x19180
cmpl $0x0, %eax
jne 0x2fe8f
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x42473(%rip), %rdx     # 0x722fb
callq 0x18f20
jmp 0x2fed9
leaq 0x3f8f1(%rip), %rdi     # 0x6f787
callq 0x18a90
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2fed9
cmpq $0x0, -0x10(%rbp)
jbe 0x2fed9
cmpq $0x4b0, -0x10(%rbp)     # imm = 0x4B0
jae 0x2fed9
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x42442(%rip), %rdx     # 0x72316
callq 0x18f20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Match_f
void Cmd_Match_f (edict_t *ent)
{
	char *p;
	int i;
	char message[MAX_INFO_STRING];

	if (!(ent->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee\n");
		return;
	}

	p = gi.args();

	if (!p || !strlen(p))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "USAGE: match <mapname>\n");
		return;
	}
	else
	{
		for (i=0; maplist[i].mapname; i++)
		{
			if (!strcmp(maplist[i].mapname, p))
			{
				ctf_SafePrint(ent, PRINT_HIGH, "Match countdown beginning.\n");
				StartMatch (p);
				return;
			}
		}
		sprintf(message, "%s is not a map from the maplist.\n", p);
		ctf_SafePrint(ent, PRINT_HIGH, message);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x3016f
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41b8e(%rip), %rdx     # 0x71cf3
callq 0x18f20
jmp 0x3024d
movq 0x5248a(%rip), %rax     # 0x82600
callq *0x148(%rax)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x30196
movq -0x10(%rbp), %rdi
callq 0x186e0
cmpq $0x0, %rax
jne 0x301b0
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x42235(%rip), %rdx     # 0x723db
callq 0x18f20
jmp 0x3024d
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
movq 0x52606(%rip), %rax     # 0x827c8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x3021f
movslq -0x14(%rbp), %rcx
movq 0x525ee(%rip), %rax     # 0x827c8
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x30212
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x421f1(%rip), %rdx     # 0x723f3
callq 0x18f20
movq -0x10(%rbp), %rdi
callq 0x18360
jmp 0x3024d
jmp 0x30214
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x301b7
leaq -0x220(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x41f61(%rip), %rsi     # 0x72192
movb $0x0, %al
callq 0x19940
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_PingAlert_f
void Cmd_PingAlert_f (edict_t *ent)
{
	char *p;
	int i, j;

	i = j = 0;

	p = gi.args();
	if (sscanf(p, "%d %d", &i, &j) < 1)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Usage: pingalert <floor> <ceiling>\nUse zero to set no alert for that value.\n");
		return;
	}
	ent->client->ctf.pingalertfloor = i;
	ent->client->ctf.pingalertceiling = j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x5237f(%rip), %rax     # 0x82600
callq *0x148(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3fa79(%rip), %rsi     # 0x6fd0f
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
movb $0x0, %al
callq 0x19180
cmpl $0x1, %eax
jge 0x302c1
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x42155(%rip), %rdx     # 0x7240f
callq 0x18f20
jmp 0x302e3
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, 0x1110(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, 0x1114(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: PlayerSort
int PlayerSort (void const *a, void const *b)
{
	int		anum, bnum;

	anum = *(int *)a;
	bnum = *(int *)b;

	anum = game.clients[anum].ps.stats[STAT_FRAGS];
	bnum = game.clients[bnum].ps.stats[STAT_FRAGS];

	if (anum < bnum)
		return -1;
	if (anum > bnum)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq 0x52a2b(%rip), %rax     # 0x82d40
movq 0x408(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x9140, %rcx, %rcx     # imm = 0x9140
addq %rcx, %rax
movswl 0x94(%rax), %eax
movl %eax, -0x1c(%rbp)
movq 0x52a05(%rip), %rax     # 0x82d40
movq 0x408(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x9140, %rcx, %rcx     # imm = 0x9140
addq %rcx, %rax
movswl 0x94(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3036b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x30383
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x3037c
movl $0x1, -0x4(%rbp)
jmp 0x30383
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Wave_f
void Cmd_Wave_f (edict_t *ent)
{
	int		i;

	i = atoi (gi.argv(1));

	// can't wave when ducked
	if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
		return;

	if (ent->client->anim_priority > ANIM_WAVE)
		return;

	ent->client->anim_priority = ANIM_WAVE;

	switch (i)
	{
	case 0:
		ctf_SafePrint(ent, PRINT_HIGH, "flipoff\n");
		ent->s.frame = FRAME_flip01-1;
		ent->client->anim_end = FRAME_flip12;
		break;
	case 1:
		ctf_SafePrint(ent, PRINT_HIGH, "salute\n");
		ent->s.frame = FRAME_salute01-1;
		ent->client->anim_end = FRAME_salute11;
		break;
	case 2:
		ctf_SafePrint(ent, PRINT_HIGH, "taunt\n");
		ent->s.frame = FRAME_taunt01-1;
		ent->client->anim_end = FRAME_taunt17;
		break;
	case 3:
		ctf_SafePrint(ent, PRINT_HIGH, "wave\n");
		ent->s.frame = FRAME_wave01-1;
		ent->client->anim_end = FRAME_wave11;
		break;
	case 4:
	default:
		ctf_SafePrint(ent, PRINT_HIGH, "point\n");
		ent->s.frame = FRAME_point01-1;
		ent->client->anim_end = FRAME_point12;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movq 0x52238(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, %rdi
callq 0x19820
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzbl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x303f2
jmp 0x30549
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0xef8(%rax)
jle 0x30408
jmp 0x30549
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0xef8(%rax)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x30517
movq -0x18(%rbp), %rax
leaq 0x40ffa(%rip), %rcx     # 0x71430
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x4200d(%rip), %rdx     # 0x7245c
callq 0x18f20
movq -0x8(%rbp), %rax
movl $0x47, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x53, 0xef4(%rax)
jmp 0x30549
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41fdf(%rip), %rdx     # 0x72465
callq 0x18f20
movq -0x8(%rbp), %rax
movl $0x53, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x5e, 0xef4(%rax)
jmp 0x30549
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41fb0(%rip), %rdx     # 0x7246d
callq 0x18f20
movq -0x8(%rbp), %rax
movl $0x5e, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x6f, 0xef4(%rax)
jmp 0x30549
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41f83(%rip), %rdx     # 0x72474
callq 0x18f20
movq -0x8(%rbp), %rax
movl $0x6f, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x7a, 0xef4(%rax)
jmp 0x30549
jmp 0x30517
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41f53(%rip), %rdx     # 0x7247a
callq 0x18f20
movq -0x8(%rbp), %rax
movl $0x7a, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x86, 0xef4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Observe_f
void Cmd_Observe_f(edict_t *ent, int Observer_Type)
{
int i;
int numspec;

	//first check to see if the maxspectator var is set.
	for(i = 1, numspec = 0; i <= maxclients->value; i++)
		if(g_edicts[i].inuse && g_edicts[i].client->pers.spectator)
			numspec++;

	if (numspec >= maxspectators->value)
	{
		gi.cprintf(ent, PRINT_HIGH, "Server spectator limit is full.");
		return;
	}



	if(Observer_Type == CTF_TEAM_OBSERVER_BLUE)
	{
		if(!Team_Observer_OK(CTF_TEAM_BLUE, ent))
			return;

		//gi.bprintf (PRINT_HIGH, "%s is watching the blue team\n", ent->client->pers.netname);
	}
	else if(Observer_Type == CTF_TEAM_OBSERVER_RED)
	{
		if(!Team_Observer_OK(CTF_TEAM_RED, ent))
			return;

		//gi.bprintf (PRINT_HIGH, "%s is watching the red team\n", ent->client->pers.netname);
	}
	//else
		//gi.bprintf (PRINT_HIGH, "%s has moved to the sidelines\n", ent->client->pers.netname);


	Drop_All(ent);
	ent->client->ctf.teamnum = Observer_Type;
	ent->client->chase_target = NULL;
	//ent->client->pers.spectator = 1;
	//ent->client->resp.spectator = 1;
	ForceCommand(ent, "spectator 1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm1
movq 0x51a77(%rip), %rax     # 0x82530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x30b1f
movq 0x51a8b(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
cmpl $0x0, 0x60(%rax)
je 0x30b12
movq 0x51a6d(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0x750(%rax)
je 0x30b12
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30b14
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x30aad
cvtsi2ssl -0x14(%rbp), %xmm0
movq 0x5240d(%rip), %rax     # 0x82f38
movq (%rax), %rax
ucomiss 0x20(%rax), %xmm0
jb 0x30b55
movq 0x51ac5(%rip), %rax     # 0x82600
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41977(%rip), %rdx     # 0x724c6
movb $0x0, %al
callq *%rcx
jmp 0x30bce
cmpl $-0x2, -0xc(%rbp)
jne 0x30b72
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x19970
cmpl $0x0, %eax
jne 0x30b70
jmp 0x30bce
jmp 0x30b91
cmpl $-0x3, -0xc(%rbp)
jne 0x30b8f
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x19970
cmpl $0x0, %eax
jne 0x30b8d
jmp 0x30bce
jmp 0x30b8f
jmp 0x30b91
movq -0x8(%rbp), %rdi
callq 0x19810
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, 0x1100(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq $0x0, 0xf30(%rax)
movq -0x8(%rbp), %rdi
leaq 0x4191d(%rip), %rsi     # 0x724e6
callq 0x18d80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_ToggleFastSwitch_f
void Cmd_ToggleFastSwitch_f(edict_t *ent)
{
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
		return;
	}

	char *newval = (((int)fastswitch->value) == 1) ? "0" : "1";
	gi.cvar_set("fastswitch", newval);
	gi.bprintf(PRINT_HIGH, "Fast weapon switching now %sabled\n", (fastswitch->value) ? "en" : "dis");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x30c26
movq 0x519f7(%rip), %rax     # 0x82600
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x408cd(%rip), %rdx     # 0x714ea
movb $0x0, %al
callq *%rcx
jmp 0x30cb5
movq 0x51f73(%rip), %rax     # 0x82ba0
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x3e418(%rip), %rax     # 0x6f054
leaq 0x4706d(%rip), %rcx     # 0x77cb0
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x10(%rbp)
movq 0x519ab(%rip), %rax     # 0x82600
movq 0x128(%rax), %rax
movq -0x10(%rbp), %rsi
leaq 0x41d42(%rip), %rdi     # 0x729a9
callq *%rax
movq 0x51990(%rip), %rax     # 0x82600
movq (%rax), %rcx
movq 0x51f26(%rip), %rax     # 0x82ba0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
leaq 0x41889(%rip), %rdx     # 0x72515
leaq 0x42459(%rip), %rax     # 0x730ec
ucomiss %xmm1, %xmm0
setp %dil
setne %sil
orb %dil, %sil
cmovneq %rax, %rdx
movl $0x2, %edi
leaq 0x41841(%rip), %rsi     # 0x724f2
movb $0x0, %al
callq *%rcx
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_ChangeMap_f
void Cmd_ChangeMap_f(edict_t *ent)
{
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
		return;
	}

	if (gi.argc() < 2) {
		gi.cprintf(ent, PRINT_HIGH, "Usage: changemap <mapname>\n");
		return;
	}

	char *map = gi.argv(1);
	ctf_ChangeMap(map, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x30e93
movq 0x51787(%rip), %rax     # 0x82600
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x4065d(%rip), %rdx     # 0x714ea
movb $0x0, %al
callq *%rcx
jmp 0x30ee7
movq 0x51766(%rip), %rax     # 0x82600
callq *0x138(%rax)
cmpl $0x2, %eax
jge 0x30ec6
movq 0x51754(%rip), %rax     # 0x82600
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x419bd(%rip), %rdx     # 0x7287d
movb $0x0, %al
callq *%rcx
jmp 0x30ee7
movl $0x1, %edi
movq 0x5172e(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x19990
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_SetTimelimit_f
void Cmd_SetTimelimit_f(edict_t *ent)
{
    if (!ISREF(ent)) {
        gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
        return;
    }

    if (gi.argc() < 2) {
        gi.cprintf(ent, PRINT_HIGH, "Usage: settimelimit <minutes>\n");
        return;
    }

    char *minutes = gi.argv(1);
    gi.cvar_set("timelimit", minutes);

    gi.cprintf(ent, PRINT_HIGH, "Timelimit set to %d minutes\n", (int)timelimit->value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1108(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x30f36
movq 0x516e7(%rip), %rax     # 0x82600
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x405bd(%rip), %rdx     # 0x714ea
movb $0x0, %al
callq *%rcx
jmp 0x30fc9
movq 0x516c3(%rip), %rax     # 0x82600
callq *0x138(%rax)
cmpl $0x2, %eax
jge 0x30f69
movq 0x516b1(%rip), %rax     # 0x82600
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x41936(%rip), %rdx     # 0x72899
movb $0x0, %al
callq *%rcx
jmp 0x30fc9
movl $0x1, %edi
movq 0x5168b(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, -0x10(%rbp)
movq 0x5167a(%rip), %rax     # 0x82600
movq 0x128(%rax), %rax
movq -0x10(%rbp), %rsi
leaq 0x3e588(%rip), %rdi     # 0x6f520
callq *%rax
movq 0x5165f(%rip), %rax     # 0x82600
movq 0x10(%rax), %r8
movq -0x8(%rbp), %rdi
movq 0x51700(%rip), %rax     # 0x826b0
movq (%rax), %rax
cvttss2si 0x20(%rax), %ecx
movl $0x2, %esi
leaq 0x418f4(%rip), %rdx     # 0x728b8
movb $0x0, %al
callq *%r8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_combat.c
// Function: Killed
void Killed (edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	if (targ->health < -999)
		targ->health = -999;

	targ->enemy = attacker;

#ifdef MONSTERS_OK
	if ((targ->svflags & SVF_MONSTER) && (targ->deadflag != DEAD_DEAD))
	{
//		targ->svflags |= SVF_DEADMONSTER;	// now treat as a different content type
		if (!(targ->monsterinfo.aiflags & AI_GOOD_GUY))
		{
			level.killed_monsters++;
			if (coop->value && attacker->client)
			{
				stats_add(attacker, STATS_SCORE, 1);
				attacker->client->resp.score++;
			}
			// medics won't heal monsters that they kill themselves
			if (strcmp(attacker->classname, "monster_medic") == 0)
				targ->owner = attacker;
		}
	}
#endif

	if (targ->movetype == MOVETYPE_PUSH || targ->movetype == MOVETYPE_STOP || targ->movetype == MOVETYPE_NONE)
	{	// doors, triggers, etc
		targ->die (targ, inflictor, attacker, damage, point);
		return;
	}

#ifdef MONSTERS_OK
	if ((targ->svflags & SVF_MONSTER) && (targ->deadflag != DEAD_DEAD))
	{
		targ->touch = NULL;
		monster_death_use (targ);
	}
#endif

	targ->die (targ, inflictor, attacker, damage, point);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xfffffc19, 0x254(%rax) # imm = 0xFFFFFC19
jge 0x322c9
movq -0x8(%rbp), %rax
movl $0xfffffc19, 0x254(%rax) # imm = 0xFFFFFC19
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2a0(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x118(%rax)
je 0x322ff
movq -0x8(%rbp), %rax
cmpl $0x3, 0x118(%rax)
je 0x322ff
movq -0x8(%rbp), %rax
cmpl $0x0, 0x118(%rax)
jne 0x32321
movq -0x8(%rbp), %rax
movq 0x238(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
callq *%rax
jmp 0x32341
movq -0x8(%rbp), %rax
movq 0x238(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_combat.c
// Function: SpawnDamage
void SpawnDamage (int type, vec3_t origin, vec3_t normal, int damage)
{
	if (damage > 255)
		damage = 255;
	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (type);
//	gi.WriteByte (damage);
	gi.WritePosition (origin);
	gi.WriteDir (normal);
	gi.multicast (origin, MULTICAST_PVS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0xff, -0x1c(%rbp)
jle 0x32376
movl $0xff, -0x1c(%rbp)
movl $0x3, %edi
movq 0x5027e(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x50271(%rip), %rax     # 0x82600
movq 0xc8(%rax), %rax
movl -0x4(%rbp), %edi
callq *%rax
movq 0x5025e(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq 0x5024a(%rip), %rax     # 0x82600
movq 0xf8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq 0x50236(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_combat.c
// Function: CheckTeamDamage
qboolean CheckTeamDamage (edict_t *targ, edict_t *attacker)
{
		//FIXME make the next line real and uncomment this block
		// if ((ability to damage a teammate == OFF) && (targ's team == attacker's team))
	// TEAM CODE - LM_JORM
	if (targ == attacker || matchstate == MATCH_RAILGUN_INPLAY)
		return false;
	if (attacker->client && targ->client && (OnSameTeam(attacker, targ)))
		return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x32416
movq 0x503c7(%rip), %rax     # 0x827d8
cmpl $0x6, (%rax)
jne 0x3241f
movl $0x0, -0x4(%rbp)
jmp 0x32457
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x32450
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x32450
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18770
cmpl $0x0, %eax
je 0x32450
movl $0x1, -0x4(%rbp)
jmp 0x32457
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_combat.c
// Function: CheckArmor
static int CheckArmor (edict_t *ent, vec3_t point, vec3_t normal, int damage, int te_sparks, int dflags)
{
	gclient_t	*client;
	int			save;
	int			index;
	gitem_t		*armor;

	if (!damage)
		return 0;

	client = ent->client;

	if (!client)
		return 0;

	if (dflags & DAMAGE_NO_ARMOR)
		return 0;

	index = ArmorIndex (ent);
	if (!index)
		return 0;

	armor = GetItemByIndex (index);

	if (dflags & DAMAGE_ENERGY)
		save = ceilf(((gitem_armor_t *)armor->info)->energy_protection*damage);
	else
		save = ceilf(((gitem_armor_t *)armor->info)->normal_protection*damage);
	if (save >= client->pers.inventory[index])
		save = client->pers.inventory[index];

	if (!save)
		return 0;

	client->pers.inventory[index] -= save;
	SpawnDamage (te_sparks, point, normal, save);

	return save;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x330d1
movl $0x0, -0x4(%rbp)
jmp 0x331eb
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x330f0
movl $0x0, -0x4(%rbp)
jmp 0x331eb
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x33107
movl $0x0, -0x4(%rbp)
jmp 0x331eb
movq -0x10(%rbp), %rdi
callq 0x187c0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jne 0x33125
movl $0x0, -0x4(%rbp)
jmp 0x331eb
movl -0x40(%rbp), %edi
callq 0x18d70
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x33160
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rax
movss 0xc(%rax), %xmm0
cvtsi2ssl -0x24(%rbp), %xmm1
mulss %xmm1, %xmm0
callq 0x18b00
cvttss2si %xmm0, %eax
movl %eax, -0x3c(%rbp)
jmp 0x33182
movq -0x48(%rbp), %rax
movq 0x70(%rax), %rax
movss 0x8(%rax), %xmm0
cvtsi2ssl -0x24(%rbp), %xmm1
mulss %xmm1, %xmm0
callq 0x18b00
cvttss2si %xmm0, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
movslq -0x40(%rbp), %rdx
cmpl 0x318(%rcx,%rdx,4), %eax
jl 0x331a8
movq -0x38(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl 0x318(%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x331b7
movl $0x0, -0x4(%rbp)
jmp 0x331eb
movl -0x3c(%rbp), %esi
movq -0x38(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl 0x318(%rax,%rcx,4), %edx
subl %esi, %edx
movl %edx, 0x318(%rax,%rcx,4)
movl -0x28(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x19cb0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Move_Final
void Move_Final (edict_t *ent)
{
	if (ent->moveinfo.remaining_distance == 0)
	{
		Move_Done (ent);
		return;
	}

	VectorScale (ent->moveinfo.dir, ent->moveinfo.remaining_distance / FRAMETIME, ent->velocity);

	ent->think = Move_Done;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x3a4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x334bd
jp 0x334bd
movq -0x8(%rbp), %rdi
callq 0x19d40
jmp 0x33526
movq -0x8(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
addq $0x54, %rdi
movq -0x8(%rbp), %rax
movss 0x3a4(%rax), %xmm0
movss 0x3cdb4(%rip), %xmm1    # 0x70294
divss %xmm1, %xmm0
movq -0x8(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
callq 0x18a80
movq -0x8(%rbp), %rax
movq 0x4f371(%rip), %rcx     # 0x82870
movq %rcx, 0x210(%rax)
movss 0x3cd86(%rip), %xmm0    # 0x70294
movq 0x4f88b(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Move_Begin
void Move_Begin (edict_t *ent)
{
	float	frames;

	if ((ent->moveinfo.speed * FRAMETIME) >= ent->moveinfo.remaining_distance)
	{
		Move_Final (ent);
		return;
	}
	VectorScale (ent->moveinfo.dir, ent->moveinfo.speed, ent->velocity);
	frames = floor((ent->moveinfo.remaining_distance / ent->moveinfo.speed) / FRAMETIME);
	ent->moveinfo.remaining_distance -= frames * ent->moveinfo.speed * FRAMETIME;
	ent->nextthink = level.time + (frames * FRAMETIME);
	ent->think = Move_Final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x3cd4c(%rip), %xmm0    # 0x70294
mulss 0x378(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x3a4(%rax), %xmm0
jb 0x3356b
movq -0x8(%rbp), %rdi
callq 0x19db8
jmp 0x3364e
movq -0x8(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
addq $0x54, %rdi
movq -0x8(%rbp), %rax
movss 0x378(%rax), %xmm0
movq -0x8(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
callq 0x18a80
movq -0x8(%rbp), %rax
movss 0x3a4(%rax), %xmm0
movq -0x8(%rbp), %rax
divss 0x378(%rax), %xmm0
movss 0x3ccde(%rip), %xmm1    # 0x70294
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19790
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss 0x378(%rax), %xmm0
movq -0x8(%rbp), %rax
movss 0x3a4(%rax), %xmm1
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss 0x3cc95(%rip), %xmm2    # 0x70294
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x3a4(%rax)
movq 0x4f78a(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
movss -0xc(%rbp), %xmm0
movss 0x3cc6c(%rip), %xmm2    # 0x70294
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4f619(%rip), %rcx     # 0x82c60
movq %rcx, 0x210(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Move_Calc
void Move_Calc (edict_t *ent, vec3_t dest, void(*func)(edict_t*))
{
	VectorClear (ent->velocity);
	VectorSubtract (dest, ent->s.origin, ent->moveinfo.dir);
	ent->moveinfo.remaining_distance = VectorNormalize (ent->moveinfo.dir);
	ent->moveinfo.endfunc = func;

	if (ent->moveinfo.speed == ent->moveinfo.accel && ent->moveinfo.speed == ent->moveinfo.decel)
	{
		if (level.current_entity == ((ent->flags & FL_TEAMSLAVE) ? ent->teammaster : ent))
		{
			Move_Begin (ent);
		}
		else
		{
			ent->nextthink = level.time + FRAMETIME;
			ent->think = Move_Begin;
		}
	}
	else
	{
		// accelerative
		ent->moveinfo.current_speed = 0;
		ent->think = Think_AccelMove;
		ent->nextthink = level.time + FRAMETIME;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c0(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x38c(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x390(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x394(%rax)
movq -0x8(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
addq $0x54, %rdi
callq 0x183d0
movq -0x8(%rbp), %rax
movss %xmm0, 0x3a4(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3b0(%rax)
movq -0x8(%rbp), %rax
movss 0x378(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x374(%rax), %xmm0
jne 0x337fa
jp 0x337fa
movq -0x8(%rbp), %rax
movss 0x378(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x37c(%rax), %xmm0
jne 0x337fa
jp 0x337fa
movq 0x4f62a(%rip), %rax     # 0x82da0
movq 0x148(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x337a6
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x337ae
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x337c6
movq -0x8(%rbp), %rdi
callq 0x19d68
jmp 0x337f8
movss 0x3cac6(%rip), %xmm0    # 0x70294
movq 0x4f5cb(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4f15f(%rip), %rcx     # 0x82950
movq %rcx, 0x210(%rax)
jmp 0x3383b
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x398(%rax)
movq -0x8(%rbp), %rax
movq 0x4ed8c(%rip), %rcx     # 0x825a0
movq %rcx, 0x210(%rax)
movss 0x3ca71(%rip), %xmm0    # 0x70294
movq 0x4f576(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Think_AccelMove
void Think_AccelMove (edict_t *ent)
{
	ent->moveinfo.remaining_distance -= ent->moveinfo.current_speed;

	if (ent->moveinfo.current_speed == 0)		// starting or blocked
		plat_CalcAcceleratedMove(&ent->moveinfo);

	plat_Accelerate (&ent->moveinfo);

	// will the entire move complete on next frame?
	if (ent->moveinfo.remaining_distance <= ent->moveinfo.current_speed)
	{
		Move_Final (ent);
		return;
	}

	VectorScale (ent->moveinfo.dir, ent->moveinfo.current_speed*10, ent->velocity);
	ent->nextthink = level.time + FRAMETIME;
	ent->think = Think_AccelMove;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x398(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x3a4(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x3a4(%rax)
movq -0x8(%rbp), %rax
movss 0x398(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x338a6
jp 0x338a6
movq -0x8(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
callq 0x19400
movq -0x8(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
callq 0x19250
movq -0x8(%rbp), %rax
movss 0x3a4(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x398(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x338de
movq -0x8(%rbp), %rdi
callq 0x19db8
jmp 0x33943
movq -0x8(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
addq $0x54, %rdi
movq -0x8(%rbp), %rax
movss 0x3c5f7(%rip), %xmm0    # 0x6fef0
mulss 0x398(%rax), %xmm0
movq -0x8(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
callq 0x18a80
movss 0x3c97b(%rip), %xmm0    # 0x70294
movq 0x4f480(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4ec64(%rip), %rcx     # 0x825a0
movq %rcx, 0x210(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: AngleMove_Final
void AngleMove_Final (edict_t *ent)
{
	vec3_t	move;

	if (ent->moveinfo.state == STATE_UP)
		VectorSubtract (ent->moveinfo.end_angles, ent->s.angles, move);
	else
		VectorSubtract (ent->moveinfo.start_angles, ent->s.angles, move);

	if (VectorCompare (move, vec3_origin))
	{
		AngleMove_Done (ent);
		return;
	}

	VectorScale (move, 1.0f/FRAMETIME, ent->avelocity);

	ent->think = AngleMove_Done;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x388(%rax)
jne 0x33a09
movq -0x8(%rbp), %rax
movss 0x35c(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0x360(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x14(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x364(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x18(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x33a57
movq -0x8(%rbp), %rax
movss 0x344(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0x348(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x14(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x34c(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x18(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0x14(%rbp), %rdi
movq 0x4ed06(%rip), %rsi     # 0x82768
callq 0x18c60
cmpl $0x0, %eax
je 0x33a77
movq -0x8(%rbp), %rdi
callq 0x19da0
jmp 0x33ac5
leaq -0x14(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1cc, %rsi            # imm = 0x1CC
movss 0x3c462(%rip), %xmm0    # 0x6fef0
callq 0x18a80
movq -0x8(%rbp), %rax
movq 0x4f01a(%rip), %rcx     # 0x82ab8
movq %rcx, 0x210(%rax)
movss 0x3c7e7(%rip), %xmm0    # 0x70294
movq 0x4f2ec(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: AngleMove_Begin
void AngleMove_Begin (edict_t *ent)
{
	vec3_t	destdelta;
	float	len;
	float	traveltime;
	float	frames;

	// set destdelta to the vector needed to move
	if (ent->moveinfo.state == STATE_UP)
		VectorSubtract (ent->moveinfo.end_angles, ent->s.angles, destdelta);
	else
		VectorSubtract (ent->moveinfo.start_angles, ent->s.angles, destdelta);
	
	// calculate length of vector
	len = VectorLength (destdelta);
	
	// divide by speed to get time to reach dest
	traveltime = len / ent->moveinfo.speed;

	if (traveltime < FRAMETIME)
	{
		AngleMove_Final (ent);
		return;
	}

	frames = floor(traveltime / FRAMETIME);

	// scale the destdelta vector by the time spent traveling to get velocity
	VectorScale (destdelta, 1.0 / traveltime, ent->avelocity);

	// set nextthink to trigger a think when dest is reached
	ent->nextthink = level.time + frames * FRAMETIME;
	ent->think = AngleMove_Final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x388(%rax)
jne 0x33b39
movq -0x8(%rbp), %rax
movss 0x35c(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0x360(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x14(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x364(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x18(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x33b87
movq -0x8(%rbp), %rax
movss 0x344(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x10(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0x348(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x14(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x34c(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0x18(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x194e0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
divss 0x378(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss 0x3c6e1(%rip), %xmm0    # 0x70294
ucomiss -0x1c(%rbp), %xmm0
jbe 0x33bc7
movq -0x8(%rbp), %rdi
callq 0x19dd8
jmp 0x33c56
movss -0x1c(%rbp), %xmm0
movss 0x3c6c0(%rip), %xmm1    # 0x70294
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19790
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0x14(%rbp), %rdi
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x3c341(%rip), %xmm0    # 0x6ff40
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rsi
addq $0x1cc, %rsi            # imm = 0x1CC
callq 0x18a80
movq 0x4f182(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
movss -0x20(%rbp), %xmm0
movss 0x3c664(%rip), %xmm2    # 0x70294
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4f1e1(%rip), %rcx     # 0x82e30
movq %rcx, 0x210(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)