LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Id_f
void Cmd_Id_f (edict_t *ent)
{
	vec3_t	forward, right, start, offset, mins, maxs, end;
	trace_t	tr;
	float	*v;

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

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

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

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

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
movss 0x2a43d(%rip), %xmm0    # 0x50404
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x196c0
movsd (%rax), %xmm0
leaq 0x20(%rsp), %rcx
movsd %xmm0, (%rcx)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rcx)
movss 0x2945b(%rip), %xmm0    # 0x4f44c
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
callq 0x196c0
movsd (%rax), %xmm0
leaq 0x10(%rsp), %rcx
movsd %xmm0, (%rcx)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rcx)
movl $0xebc, %edi            # imm = 0xEBC
addq 0x58(%rbx), %rdi
leaq 0x64(%rsp), %r12
leaq 0x58(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x183d0
movss 0x28ebd(%rip), %xmm0    # 0x4eef8
leaq 0x30(%rsp), %rbp
movlps %xmm0, (%rbp)
movl 0x278(%rbx), %eax
addl $-0x8, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x8(%rbp)
leaq 0x4(%rbx), %rdi
leaq 0x4c(%rsp), %r14
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x190d0
movss 0x2a390(%rip), %xmm0    # 0x50408
movlps %xmm0, (%rbp)
andl $0x0, 0x8(%rbp)
leaq 0x40(%rsp), %r15
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x190d0
movq 0x40560(%rip), %r13     # 0x66600
movl $0x6000003, (%rsp)      # imm = 0x6000003
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %r8
movq %rbx, %r9
callq *0x60(%r13)
movq 0x40(%r12), %rax
testq %rax, %rax
je 0x260fb
movq 0x58(%rax), %rsi
testq %rsi, %rsi
je 0x260e2
addq $0x2c0, %rsi            # imm = 0x2C0
jmp 0x260f2
movq 0x330(%rax), %rax
testq %rax, %rax
je 0x260fb
movq 0x50(%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r13)
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Position_f
void Cmd_Position_f(edict_t* ent)
{
	char temp[MAX_INFO_STRING];
	double f1, f2, f3, a1, a2, a3;
	char message[MAX_INFO_STRING];

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

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

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

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

	ctf_SafePrint(ent, PRINT_HIGH, message);
}

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

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

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

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

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

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

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

			it = FindItem("Grappling Hook");

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, 0x118(%rdi)
je 0x26492
movq %rdi, %rbx
movq 0x40723(%rip), %rax     # 0x66b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x10, %al
jne 0x26484
leaq 0x2fe13(%rip), %rdi     # 0x5625b
callq 0x18a80
movq %rax, %rsi
subq 0x409e9(%rip), %rax     # 0x66e40
movq 0x58(%rbx), %rcx
movl $0x88, %edi
cqto
idivq %rdi
cmpl $0x0, 0x318(%rcx,%rax,4)
je 0x2649a
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x26492
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movq 0x58(%rbx), %rax
cmpq $0x0, 0xf60(%rax)
je 0x264a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2a888(%rip), %rdx     # 0x50d29
jmp 0x2653f
leaq 0x2934a(%rip), %rdi     # 0x4f7f7
callq 0x18a80
movq 0x58(%rbx), %rcx
cmpq %rax, 0x730(%rcx)
je 0x26551
testq %rax, %rax
je 0x26538
subq 0x40971(%rip), %rax     # 0x66e40
movl $0x88, %esi
cqto
idivq %rsi
cmpl $0x0, 0x318(%rcx,%rax,4)
je 0x26538
movq 0x408b6(%rip), %rax     # 0x66da0
cvtsi2ssl (%rax), %xmm0
movss 0xf04(%rcx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x26529
movq 0x400fe(%rip), %rax     # 0x66600
movq 0x20(%rax), %r14
leaq 0x2c6a4(%rip), %rdi     # 0x52bb1
callq *0x48(%rax)
pushq $0x3
popq %rsi
movss 0x28a0d(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19d08
leaq 0x2a7d7(%rip), %rdx     # 0x50d16
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18ec0
leaq 0x2a7b5(%rip), %rsi     # 0x50d0d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18d20
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Unhook_f
void Cmd_Unhook_f (edict_t *ent)
{
	gitem_t		*it;

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

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

// Assembly:
pushq %rbx
movq 0x405e9(%rip), %rax     # 0x66b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x10, %al
jne 0x2657d
popq %rbx
retq
movq %rdi, %rbx
leaq 0x29270(%rip), %rdi     # 0x4f7f7
callq 0x18a80
movq 0x58(%rbx), %rcx
cmpq %rax, 0x730(%rcx)
je 0x265a2
movq %rbx, %rdi
popq %rbx
jmp 0x18670
leaq 0x2a79d(%rip), %rsi     # 0x50d46
movq %rbx, %rdi
popq %rbx
jmp 0x18d20
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Radio_f
void Cmd_Radio_f (edict_t *ent)
{
	char *p;

	p = gi.args();

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3f79b(%rip), %rax     # 0x66600
callq *0x148(%rax)
movzbl (%rax), %ebp
cmpl $0x30, %ebp
je 0x26ede
movq %rax, %r14
leaq 0x2a188(%rip), %rsi     # 0x51005
movq %rax, %rdi
callq 0x18bc0
testl %eax, %eax
je 0x26ede
cmpl $0x31, %ebp
je 0x26f1e
cmpl $0x32, %ebp
je 0x26eff
cmpl $0x6f, %ebp
jne 0x26eaa
cmpb $0x6e, 0x1(%r14)
jne 0x26eaa
cmpb $0x0, 0x2(%r14)
je 0x26f1e
leaq 0x2a191(%rip), %rsi     # 0x51042
movq %r14, %rdi
callq 0x18bc0
testl %eax, %eax
je 0x26eff
cmpl $0x33, %ebp
je 0x26f3d
leaq 0x2a197(%rip), %rsi     # 0x51060
movq %r14, %rdi
callq 0x18bc0
testl %eax, %eax
je 0x26f3d
leaq 0x2a1b3(%rip), %rdx     # 0x5108f
jmp 0x26ef0
movq 0x58(%rbx), %rax
andl $-0x31, 0x1108(%rax)
leaq 0x2a119(%rip), %rdx     # 0x51009
pushq $0x2
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x18ec0
movq 0x58(%rbx), %rax
movl 0x1108(%rax), %ecx
andl $-0x31, %ecx
orl $0x10, %ecx
movl %ecx, 0x1108(%rax)
leaq 0x2a12b(%rip), %rdx     # 0x51047
jmp 0x26ef0
movq 0x58(%rbx), %rax
movl 0x1108(%rax), %ecx
andl $-0x31, %ecx
orl $0x20, %ecx
movl %ecx, 0x1108(%rax)
leaq 0x2a0e6(%rip), %rdx     # 0x51021
jmp 0x26ef0
movq 0x58(%rbx), %rax
orl $0x30, 0x1108(%rax)
leaq 0x2a116(%rip), %rdx     # 0x51065
jmp 0x26ef0
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Compass_f
void Cmd_Compass_f (edict_t *ent)
{
	char *p;

	p = gi.args();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x3f69d(%rip), %rax     # 0x66600
callq *0x148(%rax)
movzbl (%rax), %r12d
xorl %ebp, %ebp
leaq 0x2a13b(%rip), %r14     # 0x510b1
cmpl $0x30, %r12d
je 0x27009
movq %rax, %r15
leaq 0x2a07b(%rip), %rsi     # 0x51005
movq %rax, %rdi
callq 0x18bc0
testl %eax, %eax
je 0x27009
leaq 0x2a135(%rip), %r14     # 0x510d2
pushq $0x1
popq %rbp
cmpl $0x31, %r12d
je 0x27009
leaq 0x2a11e(%rip), %rsi     # 0x510cb
movq %r15, %rdi
callq 0x18bc0
testl %eax, %eax
je 0x27009
leaq 0x2a137(%rip), %r14     # 0x510f7
pushq $0x2
popq %rbp
cmpl $0x32, %r12d
je 0x27009
cmpl $0x33, %r12d
je 0x26fff
cmpl $0x6f, %r12d
jne 0x26fe3
cmpb $0x6e, 0x1(%r15)
jne 0x26fe3
cmpb $0x0, 0x2(%r15)
je 0x27009
leaq 0x2ff11(%rip), %rsi     # 0x56efb
movq %r15, %rdi
callq 0x18bc0
testl %eax, %eax
je 0x26fff
leaq 0x2a144(%rip), %r14     # 0x51141
jmp 0x27013
leaq 0x2a10a(%rip), %r14     # 0x51110
pushq $0x3
popq %rbp
movq 0x58(%rbx), %rax
movl %ebp, 0x1118(%rax)
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x18ec0
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Referee_f
void Cmd_Referee_f (edict_t *ent)
{
	char *p;

	p = gi.args();

	// check for a password
	//surt adjusted this so that a blank ref password doesn't deny access to rcon,
	//and created rcon access mode
	if (strcmp(rconpassword->string, p) == 0)
	{
		//deny access if password is blank on server
		if (!strlen(rconpassword->string))
		{
			ctf_SafePrint(ent, PRINT_HIGH, "Rcon Mode is off\n");
			return;
		}

		ctf_SafePrint(ent, PRINT_HIGH, "You are now an Rcon\n");
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_REFEREE;
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_RCON;
		Ctf_Menu(ent);
	}

	else if (strcmp(refpassword->string, p) == 0)
	{
		//deny access if password is blank on server
		if (!strlen(refpassword->string))
		{
			ctf_SafePrint(ent, PRINT_HIGH, "Referee Mode is off\n");
			return;
		}
		ctf_SafePrint(ent, PRINT_HIGH, "You are now a Referee\n");
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_REFEREE;
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_RCON;
		Ctf_Menu(ent);
	}
	else
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Incorrect Referee Password\n");
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_REFEREE;
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_RCON;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3f5c8(%rip), %rax     # 0x66600
callq *0x148(%rax)
movq %rax, %r14
movq 0x3fa10(%rip), %rax     # 0x66a58
movq (%rax), %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18bc0
testl %eax, %eax
je 0x2709e
movq 0x3f5ab(%rip), %rax     # 0x66610
movq (%rax), %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18bc0
testl %eax, %eax
je 0x270c3
leaq 0x2a138(%rip), %rdx     # 0x511ba
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18ec0
movq 0x58(%rbx), %rax
andl $-0x7, 0x1108(%rax)
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, (%r15)
je 0x270fe
leaq 0x2a0ce(%rip), %rdx     # 0x51179
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18ec0
movq 0x58(%rbx), %rax
orl $0x6, 0x1108(%rax)
jmp 0x270f1
cmpb $0x0, (%r15)
je 0x27107
leaq 0x2a0d3(%rip), %rdx     # 0x511a3
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18ec0
movq 0x58(%rbx), %rax
movl 0x1108(%rax), %ecx
andl $-0x7, %ecx
orl $0x2, %ecx
movl %ecx, 0x1108(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x199b0
leaq 0x2a062(%rip), %rdx     # 0x51167
jmp 0x2710e
leaq 0x2a080(%rip), %rdx     # 0x5118e
pushq $0x2
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18ec0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x27158
leaq 0x2a095(%rip), %rdx     # 0x511d6
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x18ec0
movq 0x3f4a1(%rip), %rax     # 0x66600
callq *0x148(%rax)
cmpb $0x0, (%rax)
je 0x271f6
movq %rax, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x186c0
cltq
cmpq %rax, %r15
jge 0x2719c
callq 0x19c00
movq (%rax), %rax
movsbq (%r14,%r15), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%r14,%r15)
incq %r15
jmp 0x27174
movq 0x3f625(%rip), %r15     # 0x667c8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x271d1
movq %r14, %rsi
callq 0x18bc0
addq $0x18, %r15
testl %eax, %eax
jne 0x271a3
movq %r14, %rdi
xorl %esi, %esi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x19910
leaq 0x2a016(%rip), %rsi     # 0x511ee
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x198c0
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18ec0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
pushq $-0x4
popq %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x192e0
movq %rax, %r12
movq %rsp, %r14
leaq 0x200(%rsp), %r13
pushq $0x2
popq %rbp
testq %r12, %r12
je 0x272e6
movb $0x0, (%rsp)
movq 0x58(%r12), %rax
movl 0x1108(%rax), %r15d
movq %r14, %rdi
testb $0x4, %r15b
jne 0x2726d
callq 0x186c0
testb $0x2, %r15b
jne 0x2727e
movabsq $0x20524559414c50, %rcx # imm = 0x20524559414C50
jmp 0x27288
callq 0x186c0
movabsq $0x205d4e4f43525b, %rcx # imm = 0x205D4E4F43525B
jmp 0x27288
movabsq $0x20202946455228, %rcx # imm = 0x20202946455228
movq %rcx, (%rsp,%rax)
movq 0x58(%r12), %rcx
movq 0x9120(%rcx), %rdx
movswl 0x94(%rcx), %r8d
addq $0x2c0, %rcx            # imm = 0x2C0
movq %r13, %rdi
leaq 0x29f60(%rip), %rsi     # 0x51211
xorl %eax, %eax
callq 0x198c0
movq %r14, %rdi
movq %r13, %rsi
callq 0x19800
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x18ec0
movq %r12, %rdi
xorl %esi, %esi
pushq $-0x4
popq %rdx
callq 0x192e0
movq %rax, %r12
jmp 0x27234
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x6, 0x1108(%rax)
je 0x274d3
movq 0x3f188(%rip), %rax     # 0x66600
callq *0x148(%rax)
leaq 0x2793a(%rip), %rsi     # 0x4edbf
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x19110
testl %eax, %eax
je 0x274ea
leaq 0x272f8(%rip), %rdi     # 0x4e797
callq 0x18a80
testq %rax, %rax
setne %dl
movq 0x8(%rsp), %rcx
leaq -0x1(%rcx), %rsi
cmpq $0x4af, %rsi            # imm = 0x4AF
setb %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x274fc
movl %ecx, 0x5c(%rax)
leaq 0x29e89(%rip), %rdx     # 0x5135a
jmp 0x274f1
leaq 0x29e46(%rip), %rdx     # 0x51320
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x18ec0
leaq 0x29e4e(%rip), %rdx     # 0x5133f
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18ec0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x276be
leaq 0x29693(%rip), %rdx     # 0x50d4f
jmp 0x27724
movq 0x3ef3b(%rip), %rax     # 0x66600
callq *0x148(%rax)
testq %rax, %rax
je 0x2771d
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x2771d
movq 0x3f0e9(%rip), %r15     # 0x667c8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2773b
movq %r14, %rsi
callq 0x18bc0
addq $0x18, %r15
testl %eax, %eax
jne 0x276df
leaq 0x29d39(%rip), %rdx     # 0x51437
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18ec0
movq %r14, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x18350
leaq 0x29cfb(%rip), %rdx     # 0x5141f
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x18ec0
leaq 0x29aac(%rip), %rsi     # 0x511ee
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x198c0
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18ec0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andl $0x0, (%r14)
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
movq 0x3ee6e(%rip), %rax     # 0x66600
callq *0x148(%rax)
leaq 0x27580(%rip), %rsi     # 0x4ed1f
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x19110
testl %eax, %eax
jle 0x277cd
movl 0xc(%rsp), %eax
movq 0x58(%rbx), %rcx
movl %eax, 0x1110(%rcx)
movl 0x8(%rsp), %eax
movl %eax, 0x1114(%rcx)
jmp 0x277df
leaq 0x29c7f(%rip), %rdx     # 0x51453
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x18ec0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_PlayerList_f
void Cmd_PlayerList_f(edict_t *ent)
{
	int i;
	char st[80];
	char text[MAX_MSGLEN];
	edict_t *e2;

	// connect time, ping, score, name
	*text = 0;
	for (i = 0, e2 = g_edicts + 1; i < maxclients->value; i++, e2++) {
		if (!e2->inuse)
			continue;

		Com_sprintf(st, sizeof(st), "%02d:%02d %4d %3d %s%s id: %i\n",
			(level.framenum - e2->client->resp.enterframe) / 600,
			((level.framenum - e2->client->resp.enterframe) % 600)/10,
			e2->client->ping,
			e2->client->resp.score,
			e2->client->pers.netname,
			e2->client->resp.spectator ? " (spectator)" : "",
			e2->client->ctf.ctfid);
		if (strlen(text) + strlen(st) > sizeof(text) - 50) {
			sprintf(text+strlen(text), "And more...\n");
			gi.cprintf(ent, PRINT_HIGH, "%s", text);
			return;
		}
		strcat(text, st);
	}
	gi.cprintf(ent, PRINT_HIGH, "%s", text);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5d8, %rsp            # imm = 0x5D8
movq %rdi, 0x8(%rsp)
leaq 0x60(%rsp), %r14
movb $0x0, (%r14)
movq 0x3ea4a(%rip), %rax     # 0x66558
movq 0x3ea1b(%rip), %rcx     # 0x66530
movq (%rcx), %r13
movl $0x508, %ebx            # imm = 0x508
addq (%rax), %rbx
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
cvtsi2ss %r15d, %xmm0
movss 0x20(%r13), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x27c25
cmpl $0x0, (%rbx)
je 0x27bf8
movq 0x3f254(%rip), %rax     # 0x66da0
movl (%rax), %eax
movq -0x8(%rbx), %r10
subl 0xdf0(%r10), %eax
cltd
movl $0x258, %ecx            # imm = 0x258
idivl %ecx
movl %eax, %ecx
movl %edx, %eax
cwtd
movw $0xa, %si
idivw %si
movswl %ax, %r8d
movl 0xb8(%r10), %r9d
movl 0xdf4(%r10), %r11d
cmpl $0x0, 0xe04(%r10)
leaq 0x2c0(%r10), %r13
leaq 0x2995a(%rip), %rbp     # 0x514f0
leaq 0x283a8(%rip), %rax     # 0x4ff45
cmoveq %rax, %rbp
movq %r12, %rdi
pushq $0x50
popq %rsi
leaq 0x29923(%rip), %rdx     # 0x514d1
xorl %eax, %eax
pushq 0x9120(%r10)
pushq %rbp
pushq %r13
pushq %r11
callq 0x18f30
addq $0x20, %rsp
movq %r14, %rdi
callq 0x186c0
movq %rax, %r13
movq %r12, %rdi
callq 0x186c0
addq %r13, %rax
cmpq $0x547, %rax            # imm = 0x547
jae 0x27c07
movq 0x3e946(%rip), %rax     # 0x66530
movq (%rax), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x19800
incl %r15d
addq $0x4a8, %rbx            # imm = 0x4A8
jmp 0x27b28
movabsq $0xa2e2e2e65726f, %rax  # imm = 0xA2E2E2E65726F
movq %rax, 0x65(%rsp,%r13)
movabsq $0x65726f6d20646e41, %rax # imm = 0x65726F6D20646E41
movq %rax, 0x60(%rsp,%r13)
movq 0x3e9d4(%rip), %r8      # 0x66600
leaq 0x26d7a(%rip), %rdx     # 0x4e9ad
pushq $0x2
popq %rsi
leaq 0x60(%rsp), %rcx
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq *0x10(%r8)
addq $0x5d8, %rsp            # imm = 0x5D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x3e8c9(%rip), %rax     # 0x66530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movq 0x3e8e2(%rip), %rcx     # 0x66558
movl $0x508, %eax            # imm = 0x508
addq (%rcx), %rax
xorl %ecx, %ecx
pushq $0x1
popq %rdx
cvtsi2ss %edx, %xmm1
ucomiss %xmm1, %xmm0
jb 0x27ca9
cmpl $0x0, (%rax)
je 0x27c9f
movq -0x8(%rax), %rsi
cmpl $0x1, 0x750(%rsi)
sbbl $-0x1, %ecx
addq $0x4a8, %rax            # imm = 0x4A8
incl %edx
jmp 0x27c83
cvtsi2ss %ecx, %xmm0
movq 0x3f284(%rip), %rax     # 0x66f38
movq (%rax), %rax
ucomiss 0x20(%rax), %xmm0
jae 0x27ccb
cmpl $-0x3, %ebp
je 0x27ced
cmpl $-0x2, %ebp
jne 0x27cfc
pushq $0x2
jmp 0x27cef
movq 0x3e92e(%rip), %rax     # 0x66600
movq 0x10(%rax), %rcx
leaq 0x2982d(%rip), %rdx     # 0x5150a
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x198f0
testl %eax, %eax
je 0x27d2b
movq %rbx, %rdi
callq 0x19790
movq 0x58(%rbx), %rax
movl %ebp, 0x1100(%rax)
andq $0x0, 0xf30(%rax)
leaq 0x2980d(%rip), %rsi     # 0x5152a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x18d20
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x27d58
movq 0x3e8ba(%rip), %rax     # 0x66600
movq 0x10(%rax), %rcx
leaq 0x287f5(%rip), %rdx     # 0x50546
pushq $0x2
popq %rsi
xorl %eax, %eax
jmpq *%rcx
pushq %r14
pushq %rbx
pushq %rax
movq 0x3ee3d(%rip), %rbx     # 0x66ba0
movq (%rbx), %rax
cvttss2si 0x20(%rax), %eax
cmpl $0x1, %eax
leaq 0x2f337(%rip), %rax     # 0x570ac
leaq 0x262e8(%rip), %rsi     # 0x4e064
cmoveq %rax, %rsi
movq 0x3e879(%rip), %r14     # 0x66600
leaq 0x29c52(%rip), %rdi     # 0x519e0
callq *0x128(%r14)
movq (%r14), %rcx
movq (%rbx), %rax
xorps %xmm0, %xmm0
ucomiss 0x20(%rax), %xmm0
leaq 0x2a48f(%rip), %rax     # 0x52238
leaq 0x297a9(%rip), %rdx     # 0x51559
cmovneq %rax, %rdx
cmovpq %rax, %rdx
leaq 0x29777(%rip), %rsi     # 0x51536
pushq $0x2
popq %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x280ab
movq 0x3e562(%rip), %rax     # 0x66600
movq 0x10(%rax), %rcx
leaq 0x2849d(%rip), %rdx     # 0x50546
jmp 0x280c9
movq 0x3e54e(%rip), %r14     # 0x66600
callq *0x138(%r14)
cmpl $0x1, %eax
jg 0x280da
movq 0x10(%r14), %rcx
leaq 0x297f8(%rip), %rdx     # 0x518c1
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
pushq $0x1
popq %rdi
callq *0x140(%r14)
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19910
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x2811d
movq 0x3e4f0(%rip), %rax     # 0x66600
movq 0x10(%rax), %rcx
leaq 0x2842b(%rip), %rdx     # 0x50546
jmp 0x2813b
movq 0x3e4dc(%rip), %r14     # 0x66600
callq *0x138(%r14)
cmpl $0x1, %eax
jg 0x2814c
movq 0x10(%r14), %rcx
leaq 0x297a2(%rip), %rdx     # 0x518dd
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
pushq $0x1
popq %rdi
callq *0x140(%r14)
leaq 0x263d3(%rip), %rdi     # 0x4e530
movq %rax, %rsi
callq *0x128(%r14)
movq 0x3e542(%rip), %rax     # 0x666b0
movq (%rax), %rax
cvttss2si 0x20(%rax), %ecx
movq 0x10(%r14), %r8
leaq 0x2977b(%rip), %rdx     # 0x518fc
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x3d5f8(%rip), %r15     # 0x66600
pushq $0x3
popq %rdi
callq *0xc8(%r15)
movl %ebp, %edi
callq *0xc8(%r15)
movq %r14, %rdi
callq *0xf0(%r15)
movq %rbx, %rdi
callq *0xf8(%r15)
movq 0xb0(%r15), %rax
pushq $0x2
popq %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
xorl %ebx, %ebx
cmpq %rsi, %rdi
je 0x2907f
movq 0x3d781(%rip), %rcx     # 0x667d8
cmpl $0x6, (%rcx)
je 0x2907f
cmpq $0x0, 0x58(%rsi)
je 0x2907f
movq %rdi, %rax
cmpq $0x0, 0x58(%rdi)
je 0x2907f
movq %rsi, %rdi
movq %rax, %rsi
callq 0x18750
testl %eax, %eax
je 0x2907f
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rax
movss 0x3a4(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x29bc6
jp 0x29bc6
andl $0x0, 0x1c8(%rax)
andq $0x0, 0x1c0(%rax)
movq %rax, %rdi
jmpq *0x3b0(%rax)
pushq %rbx
leaq 0x38c(%rax), %rdi
divss 0x256ba(%rip), %xmm0    # 0x4f290
leaq 0x1c0(%rax), %rsi
movq %rax, %rbx
callq 0x18a70
movq 0x3cc84(%rip), %rax     # 0x66870
movq %rax, 0x210(%rbx)
movq 0x3d1a6(%rip), %rax     # 0x66da0
movss 0x2568e(%rip), %xmm0    # 0x4f290
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss 0x378(%rdi), %xmm0
movss 0x25667(%rip), %xmm1    # 0x4f290
mulss %xmm0, %xmm1
ucomiss 0x3a4(%rdi), %xmm1
jae 0x29cce
leaq 0x38c(%rbx), %rdi
leaq 0x1c0(%rbx), %rsi
callq 0x18a70
movss 0x378(%rbx), %xmm1
movss %xmm1, 0x8(%rsp)
movss 0x3a4(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
divss %xmm1, %xmm0
divss 0x2561b(%rip), %xmm0    # 0x4f290
callq 0x196f0
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
movss 0x25604(%rip), %xmm3    # 0x4f290
mulss %xmm3, %xmm1
movss 0xc(%rsp), %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x3a4(%rbx)
movq 0x3d0f7(%rip), %rax     # 0x66da0
mulss %xmm3, %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x3cf9f(%rip), %rax     # 0x66c60
movq %rax, 0x210(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x19d28
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
andl $0x0, 0x1c8(%rdi)
andq $0x0, 0x1c0(%rdi)
movss (%rsi), %xmm0
subss 0x4(%rdi), %xmm0
addq $0x38c, %rdi            # imm = 0x38C
movss %xmm0, 0x38c(%rbx)
movss 0x4(%rsi), %xmm0
subss 0x8(%rbx), %xmm0
movss %xmm0, 0x390(%rbx)
movss 0x8(%rsi), %xmm0
subss 0xc(%rbx), %xmm0
movss %xmm0, 0x394(%rbx)
callq 0x183c0
movss %xmm0, 0x3a4(%rbx)
movq %r14, 0x3b0(%rbx)
movss 0x378(%rbx), %xmm0
ucomiss 0x374(%rbx), %xmm0
jne 0x29dad
jp 0x29dad
ucomiss 0x37c(%rbx), %xmm0
jne 0x29dad
jp 0x29dad
movq 0x3d037(%rip), %rax     # 0x66da0
movq 0x148(%rax), %rcx
testb $0x4, 0x11d(%rbx)
movq %rbx, %rdx
je 0x29d83
movq 0x2d0(%rbx), %rdx
cmpq %rdx, %rcx
je 0x29de6
movss 0x4(%rax), %xmm0
addss 0x254fb(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
movq 0x3cbac(%rip), %rax     # 0x66950
movq %rax, 0x210(%rbx)
jmp 0x29dde
andl $0x0, 0x398(%rbx)
movq 0x3c7e5(%rip), %rax     # 0x665a0
movq %rax, 0x210(%rbx)
movq 0x3cfd7(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x254ba(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19ce0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x338(%rdi), %r14
movss 0x398(%rdi), %xmm0
movss 0x3a4(%rdi), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x3a4(%rdi)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x29e31
jp 0x29e31
movq %r14, %rdi
callq 0x19390
movq %r14, %rdi
callq 0x191f0
movss 0x398(%rbx), %xmm0
ucomiss 0x3a4(%rbx), %xmm0
jae 0x29e97
leaq 0x38c(%rbx), %rdi
mulss 0x250bb(%rip), %xmm0    # 0x4ef14
leaq 0x1c0(%rbx), %rsi
callq 0x18a70
movq 0x3cf34(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x25417(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
movq 0x3c718(%rip), %rax     # 0x665a0
movq %rax, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19d28
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x344(%rdi), %rax
leaq 0x35c(%rdi), %rcx
leaq 0x348(%rdi), %rdx
leaq 0x360(%rdi), %rsi
addq $0x34c, %rdi            # imm = 0x34C
leaq 0x364(%rbx), %r8
cmpl $0x2, 0x388(%rbx)
cmoveq %rcx, %rax
cmovneq %rdx, %rsi
cmovneq %rdi, %r8
movss (%r8), %xmm0
subss 0x18(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movss (%rsi), %xmm2
movss (%rax), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
subps %xmm1, %xmm3
movq %rsp, %rdi
movlps %xmm3, (%rdi)
movss %xmm0, 0x8(%rdi)
movq 0x3c839(%rip), %rsi     # 0x66768
callq 0x18c20
testl %eax, %eax
je 0x29f52
andl $0x0, 0x1d4(%rbx)
andq $0x0, 0x1cc(%rbx)
movq %rbx, %rdi
callq *0x3b0(%rbx)
jmp 0x29f93
leaq 0x1cc(%rbx), %rsi
movq %rsp, %rdi
movss 0x24fb0(%rip), %xmm0    # 0x4ef14
callq 0x18a70
movq 0x3cb48(%rip), %rax     # 0x66ab8
movq %rax, 0x210(%rbx)
movq 0x3ce22(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x25305(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x344(%rdi), %rax
leaq 0x35c(%rdi), %rcx
leaq 0x348(%rdi), %rdx
leaq 0x360(%rdi), %rsi
addq $0x34c, %rdi            # imm = 0x34C
leaq 0x364(%rbx), %r8
cmpl $0x2, 0x388(%rbx)
cmoveq %rcx, %rax
cmovneq %rdx, %rsi
cmovneq %rdi, %r8
movss (%r8), %xmm0
subss 0x18(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movss (%rsi), %xmm2
movss (%rax), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
subps %xmm1, %xmm3
leaq 0x10(%rsp), %rdi
movlps %xmm3, (%rdi)
movss %xmm0, 0x8(%rdi)
callq 0x19460
divss 0x378(%rbx), %xmm0
movss 0x25273(%rip), %xmm1    # 0x4f290
ucomiss %xmm0, %xmm1
jbe 0x2a02c
movq %rbx, %rdi
callq 0x19d48
jmp 0x2a090
movss %xmm0, 0x8(%rsp)
divss %xmm1, %xmm0
callq 0x196f0
movss %xmm0, 0xc(%rsp)
movss 0x24edf(%rip), %xmm0    # 0x4ef28
divss 0x8(%rsp), %xmm0
leaq 0x1cc(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x18a70
movq 0x3cd39(%rip), %rax     # 0x66da0
movss 0xc(%rsp), %xmm0
mulss 0x2521b(%rip), %xmm0    # 0x4f290
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x3cda7(%rip), %rax     # 0x66e30
movq %rax, 0x210(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: AngleMove_Calc
void AngleMove_Calc (edict_t *ent, void(*func)(edict_t*))
{
	VectorClear (ent->avelocity);
	ent->moveinfo.endfunc = func;
	if (level.current_entity == ((ent->flags & FL_TEAMSLAVE) ? ent->teammaster : ent))
	{
		AngleMove_Begin (ent);
	}
	else
	{
		ent->nextthink = level.time + FRAMETIME;
		ent->think = AngleMove_Begin;
	}
}

// Assembly:
andl $0x0, 0x1d4(%rdi)
andq $0x0, 0x1cc(%rdi)
movq %rsi, 0x3b0(%rdi)
movq 0x3cced(%rip), %rax     # 0x66da0
movq 0x148(%rax), %rcx
testb $0x4, 0x11d(%rdi)
movq %rdi, %rdx
je 0x2a0cd
movq 0x2d0(%rdi), %rdx
cmpq %rdx, %rcx
je 0x19c70
movss 0x4(%rax), %xmm0
addss 0x251ad(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rdi)
movq 0x3c4c6(%rip), %rax     # 0x665b8
movq %rax, 0x210(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_CalcAcceleratedMove
void plat_CalcAcceleratedMove(moveinfo_t *moveinfo)
{
	float	accel_dist;
	float	decel_dist;

	moveinfo->move_speed = moveinfo->speed;

	if (moveinfo->remaining_distance < moveinfo->accel)
	{
		moveinfo->current_speed = moveinfo->remaining_distance;
		return;
	}

	accel_dist = AccelerationDistance (moveinfo->speed, moveinfo->accel);
	decel_dist = AccelerationDistance (moveinfo->speed, moveinfo->decel);

	if ((moveinfo->remaining_distance - accel_dist - decel_dist) < 0)
	{
		float	f;

		f = (moveinfo->accel + moveinfo->decel) / (moveinfo->accel * moveinfo->decel);
		moveinfo->move_speed = (-2 + sqrtf(4 - 4 * f * (-2 * moveinfo->remaining_distance))) / (2 * f);
		decel_dist = AccelerationDistance (moveinfo->move_speed, moveinfo->decel);
	}

	moveinfo->decel_distance = decel_dist;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movss 0x3c(%rdi), %xmm0
movss 0x40(%rdi), %xmm4
movss %xmm4, 0x64(%rdi)
movss 0x6c(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2a126
pushq $0x60
popq %r14
jmp 0x2a1e0
movss 0x44(%rbx), %xmm2
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movaps %xmm0, %xmm5
unpcklps %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
movaps %xmm4, %xmm3
divps %xmm5, %xmm3
addps 0x27afe(%rip), %xmm3    # 0x51c40
mulps %xmm4, %xmm3
mulps 0x27b04(%rip), %xmm3    # 0x51c50
movaps %xmm1, %xmm4
subss %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
pushq $0x70
popq %r14
ucomiss %xmm4, %xmm3
jbe 0x2a19d
movaps %xmm0, %xmm3
addss %xmm2, %xmm3
mulss %xmm2, %xmm0
divss %xmm0, %xmm3
mulss 0x26299(%rip), %xmm1    # 0x50410
movss 0x27aa5(%rip), %xmm0    # 0x51c24
mulss %xmm3, %xmm0
mulss %xmm1, %xmm0
addss 0x24d79(%rip), %xmm0    # 0x4ef08
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2a1a2
sqrtss %xmm0, %xmm0
jmp 0x2a1af
movaps %xmm3, %xmm1
jmp 0x2a1e0
movaps %xmm3, (%rsp)
callq 0x18fa0
movaps (%rsp), %xmm3
addss 0x26259(%rip), %xmm0    # 0x50410
addss %xmm3, %xmm3
divss %xmm3, %xmm0
movss %xmm0, 0x64(%rbx)
movaps %xmm0, %xmm1
divss 0x44(%rbx), %xmm1
addss 0x24d54(%rip), %xmm1    # 0x4ef28
mulss %xmm0, %xmm1
mulss 0x26220(%rip), %xmm1    # 0x50400
movss %xmm1, (%rbx,%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
retq