LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: vectoangles
void vectoangles (vec3_t value1, vec3_t angles)
{
	float	forward;
	float	yaw, pitch;
	
	if (value1[1] == 0 && value1[0] == 0)
	{
		yaw = 0;
		if (value1[2] > 0)
			pitch = 90;
		else
			pitch = 270;
	}
	else
	{
		if (value1[0])
			yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
		else if (value1[1] > 0)
			yaw = 90;
		else
			yaw = -90;
		if (yaw < 0)
			yaw += 360;

		forward = sqrtf (value1[0]*value1[0] + value1[1]*value1[1]);
		pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
		if (pitch < 0)
			pitch += 360;
	}

	angles[PITCH] = -pitch;
	angles[YAW] = yaw;
	angles[ROLL] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm0
jne 0x3ea8b
jp 0x3ea8b
ucomiss %xmm2, %xmm1
jne 0x3ea8b
jp 0x3ea8b
movss 0x8(%r14), %xmm0
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
leaq 0x1a9c7(%rip), %rcx     # 0x59448
movss (%rcx,%rax,4), %xmm0
jmp 0x3eb48
ucomiss %xmm2, %xmm1
jne 0x3ea92
jnp 0x3eac3
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
callq 0x190b0
mulsd 0x1a989(%rip), %xmm0    # 0x59430
divsd 0x1a989(%rip), %xmm0    # 0x59438
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm2
movss (%r14), %xmm1
movss 0x4(%r14), %xmm0
jmp 0x3ead7
xorl %eax, %eax
ucomiss %xmm2, %xmm0
seta %al
leaq 0x1a96e(%rip), %rcx     # 0x59440
movss (%rcx,%rax,4), %xmm2
movss 0x15285(%rip), %xmm3    # 0x53d64
addss %xmm2, %xmm3
xorps %xmm4, %xmm4
movaps %xmm2, %xmm5
cmpltss %xmm4, %xmm5
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movaps %xmm5, (%rsp)
mulss %xmm0, %xmm0
mulss %xmm1, %xmm1
addss %xmm0, %xmm1
sqrtss %xmm1, %xmm1
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
cvtss2sd %xmm1, %xmm1
callq 0x190b0
mulsd 0x1a90b(%rip), %xmm0    # 0x59430
divsd 0x1a90b(%rip), %xmm0    # 0x59438
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
testl %eax, %eax
jns 0x3eb44
addss 0x15220(%rip), %xmm0    # 0x53d64
movaps (%rsp), %xmm1
xorps 0x17181(%rip), %xmm0    # 0x55cd0
movss %xmm0, (%rbx)
movss %xmm1, 0x4(%rbx)
movl $0x0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_InitEdict
void G_InitEdict (edict_t *e)
{
	e->inuse = true;
	e->classname = "noclass";
	e->gravity = 1.0;
	e->s.number = e - g_edicts;
}

// Assembly:
movl $0x1, 0x60(%rdi)
leaq 0x1a998(%rip), %rax     # 0x59544
movq %rax, 0x138(%rdi)
movl $0x3f800000, 0x1e0(%rdi) # imm = 0x3F800000
movq 0x29994(%rip), %rax     # 0x68558
movq %rdi, %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
imull $0x8ce2cabd, %ecx, %eax # imm = 0x8CE2CABD
movl %eax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_TouchTriggers
void	G_TouchTriggers (edict_t *ent)
{
	int			i, num;
	edict_t		*touch[MAX_EDICTS], *hit;

	// dead things don't activate triggers!
	if ((ent->client || (ent->svflags & SVF_MONSTER)) && (ent->health <= 0))
		return;

	num = gi.BoxEdicts (ent->absmin, ent->absmax, touch
		, MAX_EDICTS, AREA_TRIGGERS);

	// be careful, it is possible to have an entity in this
	// list removed before we get to it (killtriggered)
	for (i=0 ; i<num ; i++)
	{
		hit = touch[i];
		if (!hit->inuse)
			continue;
		if (!hit->touch)
			continue;
		hit->touch (hit, ent, NULL, NULL);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
jne 0x3ebf6
testb $0x4, 0xc8(%rbx)
je 0x3ebff
cmpl $0x0, 0x254(%rbx)
jle 0x3ec59
movq 0x299fa(%rip), %rax     # 0x68600
leaq 0xe4(%rbx), %rdi
leaq 0xf0(%rbx), %rsi
movq %rsp, %rdx
movl $0x400, %ecx            # imm = 0x400
movl $0x2, %r8d
callq *0xa0(%rax)
testl %eax, %eax
jle 0x3ec59
movl %eax, %r14d
xorl %r15d, %r15d
movq (%rsp,%r15,8), %rdi
cmpl $0x0, 0x60(%rdi)
je 0x3ec51
movq 0x220(%rdi), %rax
testq %rax, %rax
je 0x3ec51
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
incq %r15
cmpq %r15, %r14
jne 0x3ec32
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_TouchSolids
void	G_TouchSolids (edict_t *ent)
{
	int			i, num;
	edict_t		*touch[MAX_EDICTS], *hit;

	num = gi.BoxEdicts (ent->absmin, ent->absmax, touch
		, MAX_EDICTS, AREA_SOLID);

	// be careful, it is possible to have an entity in this
	// list removed before we get to it (killtriggered)
	for (i=0 ; i<num ; i++)
	{
		hit = touch[i];
		if (!hit->inuse)
			continue;
		if (ent->touch)
			ent->touch (hit, ent, NULL, NULL);
		if (!ent->inuse)
			break;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2000, %rsp           # imm = 0x2000
movq %rdi, %rbx
movq 0x29985(%rip), %rax     # 0x68600
addq $0xe4, %rdi
leaq 0xf0(%rbx), %rsi
movq %rsp, %rdx
movl $0x400, %ecx            # imm = 0x400
movl $0x1, %r8d
callq *0xa0(%rax)
testl %eax, %eax
jle 0x3ecd6
movl %eax, %ebp
xorl %r14d, %r14d
movl %r14d, %eax
movq (%rsp,%rax,8), %rdi
cmpl $0x0, 0x60(%rdi)
je 0x3ecce
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0x3ecc8
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
cmpl $0x0, 0x60(%rbx)
je 0x3ecd6
incl %r14d
cmpl %ebp, %r14d
jl 0x3eca6
addq $0x2000, %rsp           # imm = 0x2000
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: KillBox
qboolean KillBox (edict_t *ent)
{
	trace_t		tr;

	while (1)
	{
		tr = gi.trace (ent->s.origin, ent->mins, ent->maxs, ent->s.origin, NULL, MASK_PLAYERSOLID);
		if (!tr.ent)
			break;

		// nail it
		T_Damage (tr.ent, ent, ent, vec3_origin, ent->s.origin, vec3_origin, 100000, 0, DAMAGE_NO_PROTECTION, MOD_TELEFRAG);

		// if we didn't kill it, fail
		if (tr.ent->solid)
			return false;
	}

	return true;		// all clear
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x4(%rdi), %r14
leaq 0xcc(%rdi), %r15
leaq 0xd8(%rdi), %r12
movq 0x29a5c(%rip), %rbp     # 0x68768
subq $0x8, %rsp
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
xorl %r9d, %r9d
pushq $0x2010003              # imm = 0x2010003
movq 0x298d0(%rip), %rax     # 0x68600
callq *0x60(%rax)
addq $0x10, %rsp
movq 0x40(%rsp), %r13
testq %r13, %r13
je 0x3ed75
movq %r13, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r14, %r8
movq %rbp, %r9
pushq $0x15
pushq $0x20
pushq $0x0
pushq $0x186a0                # imm = 0x186A0
callq 0x190f0
addq $0x20, %rsp
cmpl $0x0, 0x108(%r13)
je 0x3ed0c
xorl %eax, %eax
jmp 0x3ed7a
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: Team_centerprint
void Team_centerprint (int color, char *message, char *elsemessage)
{
    int i;
    edict_t         *cl_ent;

    for (i=0 ; i<game.maxclients ; i++)    //Go through everyone
    {
		cl_ent = g_edicts + 1 + i;    //Select the client entity from the list of ents.
        if (!cl_ent->inuse)        //Not in game yet is what I think this means.
			continue;
        if (cl_ent->client->ctf.teamnum == color) 
			gi.centerprintf (cl_ent, message);
		else if (elsemessage)
			gi.centerprintf (cl_ent, elsemessage);

	}
	gi.dprintf(elsemessage);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
movq 0x29f9e(%rip), %r15     # 0x68d40
cmpl $0x0, 0x610(%r15)
jle 0x3ee0a
movl %edi, %ebp
movl $0x4a8, %r12d           # imm = 0x4A8
movq 0x2979d(%rip), %r13     # 0x68558
xorl %r14d, %r14d
movq (%r13), %rdi
cmpl $0x0, 0x60(%rdi,%r12)
je 0x3edf4
movq 0x58(%rdi,%r12), %rax
addq %r12, %rdi
cmpl %ebp, 0x1100(%rax)
jne 0x3ede0
movq (%rsp), %rsi
jmp 0x3ede8
testq %rbx, %rbx
je 0x3edf4
movq %rbx, %rsi
xorl %eax, %eax
movq 0x2980f(%rip), %rcx     # 0x68600
callq *0x18(%rcx)
incq %r14
movslq 0x610(%r15), %rax
addq $0x4a8, %r12            # imm = 0x4A8
cmpq %rax, %r14
jl 0x3edbe
movq 0x297ef(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: Team_cprint
void Team_cprint (int color, char *message, char *elsemessage)
{
    int i;
    edict_t         *cl_ent;

    for (i=0 ; i<game.maxclients ; i++)    //Go through everyone
    {
		cl_ent = g_edicts + 1 + i;    //Select the client entity from the list of ents.
        if (!ctf_validateplayer(cl_ent, CTF_TEAM_IGNORETEAM))  //must be a valid player
			continue;
        if (cl_ent->client->ctf.teamnum == color) 
			ctf_SafePrint(cl_ent, PRINT_HIGH, message);
		else if (elsemessage)
			ctf_SafePrint(cl_ent, PRINT_HIGH, elsemessage);

	}
	gi.dprintf(elsemessage);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x29ef7(%rip), %rax     # 0x68d40
cmpl $0x0, 0x610(%rax)
jle 0x3eed0
movl %edi, %ebp
movl $0x4a8, %r13d           # imm = 0x4A8
xorl %r14d, %r14d
movq 0x296f4(%rip), %r12     # 0x68558
movq (%r12), %rbx
leaq (%rbx,%r13), %r15
movq %r15, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x18ce0
testl %eax, %eax
je 0x3eeb3
movq 0x58(%rbx,%r13), %rax
cmpl %ebp, 0x1100(%rax)
jne 0x3ee99
movl $0x2, %esi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
jmp 0x3eeae
cmpq $0x0, 0x8(%rsp)
je 0x3eeb3
movl $0x2, %esi
movq %r15, %rdi
movq 0x8(%rsp), %rdx
callq 0x18da0
incq %r14
movq 0x29e83(%rip), %rax     # 0x68d40
movslq 0x610(%rax), %rax
addq $0x4a8, %r13            # imm = 0x4A8
cmpq %rax, %r14
jl 0x3ee64
movq 0x29729(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
nop
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: blaster_touch
void blaster_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	int		mod;

	if (other == self->owner)
		return;

	if (surf && (surf->flags & SURF_SKY))
	{
		G_FreeEdict (self);
		return;
	}

	if (self->owner->client)
		PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);

	if (other->takedamage)
	{
		if (self->spawnflags & 1)
			mod = MOD_HYPERBLASTER;
		else
			mod = MOD_BLASTER;
		T_Damage (other, self, self->owner, self->velocity, self->s.origin, plane->normal, self->dmg, 1, DAMAGE_ENERGY, mod);
	}
	else
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_BLASTER);
		gi.WritePosition (self->s.origin);
		if (!plane)
			gi.WriteDir (vec3_origin);
		else
			gi.WriteDir (plane->normal);
		gi.multicast (self->s.origin, MULTICAST_PVS);
	}

	G_FreeEdict (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x110(%rdi), %rdi
cmpq %rsi, %rdi
je 0x3f93e
movq %rdx, %r14
movq %rsi, %r15
testq %rcx, %rcx
je 0x3f8dd
testb $0x4, 0x10(%rcx)
jne 0x3f9a1
cmpq $0x0, 0x58(%rdi)
je 0x3f8f2
leaq 0x4(%rbx), %rsi
movl $0x2, %edx
callq 0x18ef0
cmpl $0x0, 0x27c(%r15)
je 0x3f94a
movl 0x140(%rbx), %eax
andl $0x1, %eax
leal (%rax,%rax,8), %eax
incl %eax
movq 0x110(%rbx), %rdx
leaq 0x1c0(%rbx), %rcx
leaq 0x4(%rbx), %r8
movl 0x280(%rbx), %r10d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %r9
pushq %rax
pushq $0x4
pushq $0x1
pushq %r10
callq 0x190f0
addq $0x20, %rsp
jmp 0x3f9a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x28caf(%rip), %r12     # 0x68600
movl $0x3, %edi
callq *0xc8(%r12)
movl $0x2, %edi
callq *0xc8(%r12)
leaq 0x4(%rbx), %r15
movq %r15, %rdi
callq *0xf0(%r12)
testq %r14, %r14
jne 0x3f986
movq 0x28de2(%rip), %r14     # 0x68768
movq %r14, %rdi
callq *0xf8(%r12)
movq %r15, %rdi
movl $0x2, %esi
callq *0xb0(%r12)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: Grenade_Touch
static void Grenade_Touch (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (other == ent->owner)
		return;

	if (surf && (surf->flags & SURF_SKY))
	{
		G_FreeEdict (ent);
		return;
	}

	if (!other->takedamage)
	{
		if (ent->spawnflags & 1)
		{
			if (random() > 0.5)
				gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb1a.wav"), 1, ATTN_NORM, 0);
			else
				gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/hgrenb2a.wav"), 1, ATTN_NORM, 0);
		}
		else
		{
			gi.sound (ent, CHAN_VOICE, gi.soundindex ("weapons/grenlb1b.wav"), 1, ATTN_NORM, 0);
		}
		return;
	}

	ent->enemy = other;
	Grenade_Explode (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x110(%rdi)
je 0x3fe5e
movq %rdi, %rbx
testq %rcx, %rcx
je 0x3fe3f
testb $0x4, 0x10(%rcx)
jne 0x3fe66
cmpl $0x0, 0x27c(%rsi)
je 0x3fe75
movq %rsi, 0x2a0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3fef9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
testb $0x1, 0x140(%rbx)
jne 0x3fe95
movq 0x2877b(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
leaq 0x16861(%rip), %rdi     # 0x566f1
callq *0x48(%rax)
jmp 0x3fed5
callq 0x19a10
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
divss 0x133dd(%rip), %xmm0    # 0x53288
ucomiss 0x1454e(%rip), %xmm0    # 0x54400
movq 0x28747(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
movq 0x48(%rax), %rax
jbe 0x3fecc
leaq 0x197ee(%rip), %rdi     # 0x596b8
jmp 0x3fed3
leaq 0x197fa(%rip), %rdi     # 0x596cd
callq *%rax
movss 0x1304b(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x2, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: fire_rocket
void fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage)
{
	edict_t	*rocket;

	rocket = G_Spawn();
	VectorCopy (start, rocket->s.origin);
	VectorCopy (dir, rocket->movedir);
	vectoangles (dir, rocket->s.angles);
	VectorScale (dir, speed, rocket->velocity);
	rocket->movetype = MOVETYPE_FLYMISSILE;
	rocket->clipmask = MASK_SHOT;
	rocket->solid = SOLID_BBOX;
	rocket->s.effects |= EF_ROCKET;
	VectorClear (rocket->mins);
	VectorClear (rocket->maxs);
	rocket->s.modelindex = gi.modelindex ("models/objects/rocket/tris.md2");
	rocket->owner = self;
	rocket->touch = rocket_touch;
	rocket->nextthink = level.time + 8000/speed;
	rocket->think = G_FreeEdict;
	rocket->dmg = damage;
	rocket->radius_dmg = radius_damage;
	rocket->dmg_radius = damage_radius;
	rocket->s.sound = gi.soundindex ("weapons/rockfly.wav");
	rocket->classname = "rocket";

	if (self->client)
		check_dodge (self, rocket->s.origin, dir, speed);

	gi.linkentity (rocket);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movss %xmm0, 0x4(%rsp)
movl %r8d, %r13d
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r15
callq 0x19700
movq %rax, %r14
movss (%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x4(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movss 0x8(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss (%rbx), %xmm0
movss %xmm0, 0x19c(%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x1a0(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x1a4(%rax)
leaq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x190d0
xorps %xmm0, %xmm0
cvtsi2ss %r13d, %xmm0
leaq 0x1c0(%r14), %rsi
movq %rbx, %rdi
callq 0x189d0
movl $0x8, 0x118(%r14)
movabsq $0x600000300000002, %rax # imm = 0x600000300000002
movq %rax, 0x108(%r14)
orb $0x10, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xcc(%r14)
movq $0x0, 0xdc(%r14)
movq 0x27fce(%rip), %rbp     # 0x68600
leaq 0x18ffe(%rip), %rdi     # 0x59637
callq *0x40(%rbp)
movl %eax, 0x28(%r14)
movq %r15, 0x110(%r14)
movq 0x283d2(%rip), %rax     # 0x68a20
movq %rax, 0x220(%r14)
movq 0x28744(%rip), %rcx     # 0x68da0
movl $0x1f40, %eax           # imm = 0x1F40
xorl %edx, %edx
idivl %r13d
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss 0x4(%rcx), %xmm0
movss %xmm0, 0x200(%r14)
movq 0x27dae(%rip), %rax     # 0x68430
movq %rax, 0x210(%r14)
movl %r12d, 0x280(%r14)
movl (%rsp), %eax
movl %eax, 0x284(%r14)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x288(%r14)
leaq 0x18fa6(%rip), %rdi     # 0x59656
movq %rbp, %r12
callq *0x48(%rbp)
movl %eax, 0x4c(%r14)
leaq 0x19a68(%rip), %rax     # 0x5a129
movq %rax, 0x138(%r14)
cmpq $0x0, 0x58(%r15)
je 0x406de
movq %r14, %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x3fbae
movq %r14, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: fire_bfg
void fire_bfg (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius)
{
	edict_t	*bfg;

	bfg = G_Spawn();
	VectorCopy (start, bfg->s.origin);
	VectorCopy (dir, bfg->movedir);
	vectoangles (dir, bfg->s.angles);
	VectorScale (dir, speed, bfg->velocity);
	bfg->movetype = MOVETYPE_FLYMISSILE;
	bfg->clipmask = MASK_SHOT;
	bfg->solid = SOLID_BBOX;
	bfg->s.effects |= EF_BFG | EF_ANIM_ALLFAST;
	VectorClear (bfg->mins);
	VectorClear (bfg->maxs);
	bfg->s.modelindex = gi.modelindex ("sprites/s_bfg1.sp2");
	bfg->owner = self;
	bfg->touch = bfg_touch;
	bfg->nextthink = level.time + 8000/speed;
	bfg->think = G_FreeEdict;
	bfg->radius_dmg = damage;
	bfg->dmg_radius = damage_radius;
	bfg->classname = "bfg blast";
	bfg->s.sound = gi.soundindex ("weapons/bfg__l1a.wav");

	bfg->think = bfg_think;
	bfg->nextthink = level.time + FRAMETIME;
	bfg->teammaster = bfg;
	bfg->teamchain = NULL;

	if (self->client)
		check_dodge (self, bfg->s.origin, dir, speed);

	gi.linkentity (bfg);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movl %r8d, %r12d
movl %ecx, (%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
callq 0x19700
movq %rax, %r14
movss (%r13), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x4(%r13), %xmm0
movss %xmm0, 0x8(%rax)
movss 0x8(%r13), %xmm0
movss %xmm0, 0xc(%rax)
movss (%rbx), %xmm0
movss %xmm0, 0x19c(%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x1a0(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x1a4(%rax)
leaq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x190d0
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
leaq 0x1c0(%r14), %rsi
movq %rbx, %rdi
callq 0x189d0
movl $0x8, 0x118(%r14)
movabsq $0x600000300000002, %rax # imm = 0x600000300000002
movq %rax, 0x108(%r14)
orl $0x2080, 0x40(%r14)     # imm = 0x2080
xorps %xmm0, %xmm0
movups %xmm0, 0xcc(%r14)
xorl %r13d, %r13d
movq %r13, 0xdc(%r14)
movq 0x2750a(%rip), %rbp     # 0x68600
leaq 0x18595(%rip), %rdi     # 0x59692
callq *0x40(%rbp)
movl %eax, 0x28(%r14)
movq %r15, 0x110(%r14)
movq 0x27526(%rip), %rax     # 0x68638
movq %rax, 0x220(%r14)
movl $0x1f40, %eax           # imm = 0x1F40
xorl %edx, %edx
idivl %r12d
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movq 0x27c6f(%rip), %r12     # 0x68da0
addss 0x4(%r12), %xmm0
movss %xmm0, 0x200(%r14)
movq 0x272e8(%rip), %rax     # 0x68430
movq %rax, 0x210(%r14)
movl (%rsp), %eax
movl %eax, 0x284(%r14)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x288(%r14)
leaq 0x18536(%rip), %rax     # 0x596a5
movq %rax, 0x138(%r14)
leaq 0x12a09(%rip), %rdi     # 0x53b86
callq *0x48(%rbp)
movl %eax, 0x4c(%r14)
movq 0x27d65(%rip), %rax     # 0x68ef0
movq %rax, 0x210(%r14)
movss 0x4(%r12), %xmm0
addss 0x120ef(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%r14)
movq %r14, 0x2d0(%r14)
movq %r13, 0x2c8(%r14)
cmpq %r13, 0x58(%r15)
je 0x411cd
movq %r14, %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x3fbae
movq %r14, %rdi
movq 0x27429(%rip), %rax     # 0x68600
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x90(%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/m_boss3.c
// Function: Use_Boss3
void Use_Boss3 (edict_t *ent, edict_t *other, edict_t *activator)
{
	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (TE_BOSSTPORT);
	gi.WritePosition (ent->s.origin);
	gi.multicast (ent->s.origin, MULTICAST_PVS);
	G_FreeEdict (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x27405(%rip), %r15     # 0x68600
movl $0x3, %edi
callq *0xc8(%r15)
movl $0x16, %edi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
movq %r14, %rdi
movl $0x2, %esi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/m_boss3.c
// Function: SP_monster_boss3_stand
void SP_monster_boss3_stand (edict_t *self)
{
	if (deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}

	self->movetype = MOVETYPE_STEP;
	self->solid = SOLID_BBOX;
	self->model = "models/monsters/boss3/rider/tris.md2";
	self->s.modelindex = gi.modelindex (self->model);
	self->s.frame = FRAME_stand201;

	gi.soundindex ("misc/bigtele.wav");

	VectorSet (self->mins, -32, -32, 0);
	VectorSet (self->maxs, 32, 32, 90);

	self->use = Use_Boss3;
	self->think = Think_Boss3Stand;
	self->nextthink = level.time + FRAMETIME;
	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x27c42(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x41290
jnp 0x4129f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
movl $0x5, 0x118(%rbx)
movl $0x2, 0x108(%rbx)
leaq 0x18446(%rip), %rdi     # 0x59700
movq %rdi, 0x120(%rbx)
movq 0x27338(%rip), %r14     # 0x68600
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0x19e, 0x38(%rbx)      # imm = 0x19E
leaq 0x18448(%rip), %rdi     # 0x59725
callq *0x48(%r14)
movaps 0x161b8(%rip), %xmm0    # 0x574a0
movups %xmm0, 0xcc(%rbx)
movsd 0x183f9(%rip), %xmm0    # 0x596f0
movsd %xmm0, 0xdc(%rbx)
movq 0x271d2(%rip), %rax     # 0x684d8
movq %rax, 0x228(%rbx)
movq 0x27944(%rip), %rax     # 0x68c58
movq %rax, 0x210(%rbx)
movq 0x27a7e(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x11f61(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/m_move.c
// Function: SV_StepDirection
qboolean SV_StepDirection (edict_t *ent, float yaw, float dist)
{
	vec3_t		move, oldorigin;
	float		delta;
	
	ent->ideal_yaw = yaw;
	M_ChangeYaw (ent);
	
	yaw = yaw*M_PI*2 / 360;
	move[0] = cos(yaw)*dist;
	move[1] = sin(yaw)*dist;
	move[2] = 0;

	VectorCopy (ent->s.origin, oldorigin);
	if (SV_movestep (ent, move, false))
	{
		delta = ent->s.angles[YAW] - ent->ideal_yaw;
		if (delta > 45 && delta < 315)
		{		// not turned far enough, so don't take the step
			VectorCopy (oldorigin, ent->s.origin);
		}
		gi.linkentity (ent);
		G_TouchTriggers (ent);
		return true;
	}
	gi.linkentity (ent);
	G_TouchTriggers (ent);
	return false;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movss %xmm1, 0x10(%rsp)
movss %xmm0, (%rsp)
movq %rdi, %rbx
movss %xmm0, 0x1fc(%rdi)
callq 0x18330
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
mulsd 0x1786f(%rip), %xmm0    # 0x59438
addsd %xmm0, %xmm0
divsd 0x17b8b(%rip), %xmm0    # 0x59760
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x18990
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x19550
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd 0x10(%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
cvtpd2ps %xmm0, %xmm0
leaq 0x28(%rsp), %rsi
movlpd %xmm0, (%rsi)
movl $0x0, 0x8(%rsi)
movsd 0x4(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movss 0xc(%rbx), %xmm0
movss %xmm0, (%rsp)
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19a40
testl %eax, %eax
je 0x41c8f
movss 0x14(%rbx), %xmm0
subss 0x1fc(%rbx), %xmm0
ucomiss 0x17ae4(%rip), %xmm0    # 0x5974c
movl $0x1, %ebp
jbe 0x41c8f
movss 0x17ad9(%rip), %xmm1    # 0x59750
ucomiss %xmm0, %xmm1
jbe 0x41c8f
movaps 0x10(%rsp), %xmm0
movlps %xmm0, 0x4(%rbx)
movss (%rsp), %xmm0
movss %xmm0, 0xc(%rbx)
movq 0x2696a(%rip), %rax     # 0x68600
movq %rbx, %rdi
callq *0x90(%rax)
movq %rbx, %rdi
callq 0x19200
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/m_move.c
// Function: M_MoveToGoal
void M_MoveToGoal (edict_t *ent, float dist)
{
	edict_t		*goal;
	
	goal = ent->goalentity;
	
	if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
		return;
	
	// if the next step hits the enemy, return immediately
	if (ent->enemy &&  SV_CloseEnough (ent, ent->enemy, dist) )
		return;
	
	// bump around
	if ((rand() & 3) == 1 || !SV_StepDirection (ent, ent->ideal_yaw, dist))
	{
		if (ent->inuse)
			SV_NewChaseDir (ent, goal, dist);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x1e8(%rdi), %rbx
cmpq $0x0, 0x2b8(%rdi)
jne 0x42006
testb $0x3, 0x11c(%r14)
je 0x420a5
movq 0x2a0(%r14), %rax
testq %rax, %rax
je 0x42055
movq $-0xc, %rcx
movss 0xf0(%rax,%rcx), %xmm2
movss 0xfc(%r14,%rcx), %xmm1
addss %xmm0, %xmm1
ucomiss %xmm1, %xmm2
ja 0x42055
movss 0xf0(%r14,%rcx), %xmm1
subss %xmm0, %xmm1
ucomiss 0xfc(%rax,%rcx), %xmm1
ja 0x42055
addq $0x4, %rcx
jne 0x42019
jmp 0x420a5
movss %xmm0, 0x4(%rsp)
callq 0x19a10
movss 0x4(%rsp), %xmm1
andl $0x3, %eax
cmpl $0x1, %eax
je 0x42089
movss 0x1fc(%r14), %xmm0
movq %r14, %rdi
callq 0x18200
movss 0x4(%rsp), %xmm1
testl %eax, %eax
jne 0x420a5
cmpl $0x0, 0x60(%r14)
je 0x420a5
movq %r14, %rdi
movq %rbx, %rsi
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18840
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/m_move.c
// Function: M_walkmove
qboolean M_walkmove (edict_t *ent, float yaw, float dist)
{
	vec3_t	move;
	
	if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
		return false;

	yaw = yaw * M_PI * 2 / 360;
	
	move[0] = cos(yaw)*dist;
	move[1] = sin(yaw)*dist;
	move[2] = 0;

	return SV_movestep(ent, move, true);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x2b8(%rdi)
jne 0x420cc
testb $0x3, 0x11c(%rbx)
je 0x42156
cvtss2sd %xmm0, %xmm0
mulsd 0x17360(%rip), %xmm0    # 0x59438
addsd %xmm0, %xmm0
divsd 0x1767c(%rip), %xmm0    # 0x59760
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movss %xmm1, (%rsp)
callq 0x18990
movaps %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
movaps %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x19550
movapd 0x20(%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd (%rsp), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
cvtpd2ps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movlpd %xmm0, (%rsi)
movl $0x0, 0x8(%rsi)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x19a40
addq $0x40, %rsp
popq %rbx
retq
xorl %eax, %eax
jmp 0x42150
nop
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: ClientHasFlag
edict_t *ClientHasFlag(edict_t *ent)
{
	edict_t	*flag;
	int		teamnum = ent->client->ctf.teamnum;
	
	// ctf_validateflags(); //make sure nothing wrong with flags before calling this
	
	// Were we carrying a flag?
	flag = ctf_getteamflag(teamnum, CTF_TEAM_OPPOSING);
	
	if (flag && flag->item)
	{
		if (ent->client->pers.inventory[ITEM_INDEX(flag->item)])
			return flag;
		else
			return NULL;
	}
	return NULL;
	
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movl 0x1100(%rax), %edi
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
callq 0x18d70
testq %rax, %rax
je 0x421b2
movq 0x330(%rax), %rcx
testq %rcx, %rcx
je 0x421b2
movq 0x58(%rbx), %rdx
subq 0x26cb0(%rip), %rcx     # 0x68e40
sarq $0x3, %rcx
movabsq $-0x3c3c3c3c3c3c3c3c, %rsi # imm = 0xC3C3C3C3C3C3C3C4
imulq %rcx, %rsi
xorl %ecx, %ecx
cmpl $0x0, 0x318(%rdx,%rsi)
cmoveq %rcx, %rax
jmp 0x421b4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SP_info_player_start
void SP_info_player_start(edict_t *self)
{
	if (!coop->value)
		return;
	if(Q_stricmp(level.mapname, "security") == 0)
	{
		// invoke one of our gross, ugly, disgusting hacks
		self->think = SP_CreateCoopSpots;
		self->nextthink = level.time + FRAMETIME;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x26d9f(%rip), %rax     # 0x68f60
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x421d3
jnp 0x42215
movq %rdi, %rbx
movq 0x26bc3(%rip), %r14     # 0x68da0
leaq 0x48(%r14), %rdi
leaq 0x14d16(%rip), %rsi     # 0x56efe
callq 0x18690
testl %eax, %eax
jne 0x42215
leaq 0x25(%rip), %rax        # 0x4221d
movq %rax, 0x210(%rbx)
movss 0x4(%r14), %xmm0
addss 0x11083(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SP_CreateCoopSpots
static void SP_CreateCoopSpots (edict_t *self)
{
	edict_t	*spot;

	if(Q_stricmp(level.mapname, "security") == 0)
	{
		spot = G_Spawn();
		spot->classname = "info_player_coop";
		spot->s.origin[0] = 188 - 64;
		spot->s.origin[1] = -164;
		spot->s.origin[2] = 80;
		spot->targetname = "jail3";
		spot->s.angles[1] = 90;

		spot = G_Spawn();
		spot->classname = "info_player_coop";
		spot->s.origin[0] = 188 + 64;
		spot->s.origin[1] = -164;
		spot->s.origin[2] = 80;
		spot->targetname = "jail3";
		spot->s.angles[1] = 90;

		spot = G_Spawn();
		spot->classname = "info_player_coop";
		spot->s.origin[0] = 188 + 128;
		spot->s.origin[1] = -164;
		spot->s.origin[2] = 80;
		spot->targetname = "jail3";
		spot->s.angles[1] = 90;

		return;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x26b75(%rip), %rdi     # 0x68da0
addq $0x48, %rdi
leaq 0x14cc8(%rip), %rsi     # 0x56efe
callq 0x18690
testl %eax, %eax
jne 0x422d1
callq 0x19700
leaq 0x15f25(%rip), %rbx     # 0x58174
movq %rbx, 0x138(%rax)
movsd 0x17542(%rip), %xmm0    # 0x597a0
movsd %xmm0, 0x4(%rax)
movl $0x42a00000, %ebp       # imm = 0x42A00000
movl %ebp, 0xc(%rax)
leaq 0x183bf(%rip), %r14     # 0x5a631
movq %r14, 0x158(%rax)
movl $0x42b40000, %r15d      # imm = 0x42B40000
movl %r15d, 0x14(%rax)
callq 0x19700
movq %rbx, 0x138(%rax)
movsd 0x17519(%rip), %xmm0    # 0x597b0
movsd %xmm0, 0x4(%rax)
movl %ebp, 0xc(%rax)
movq %r14, 0x158(%rax)
movl %r15d, 0x14(%rax)
callq 0x19700
movq %rbx, 0x138(%rax)
movsd 0x17502(%rip), %xmm0    # 0x597c0
movsd %xmm0, 0x4(%rax)
movl %ebp, 0xc(%rax)
movq %r14, 0x158(%rax)
movl %r15d, 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SP_info_player_coop
void SP_info_player_coop(edict_t *self)
{
	if (!coop->value)
	{
		G_FreeEdict (self);
		return;
	}

	if((Q_stricmp(level.mapname, "jail2") == 0)   ||
	   (Q_stricmp(level.mapname, "jail4") == 0)   ||
	   (Q_stricmp(level.mapname, "mine1") == 0)   ||
	   (Q_stricmp(level.mapname, "mine2") == 0)   ||
	   (Q_stricmp(level.mapname, "mine3") == 0)   ||
	   (Q_stricmp(level.mapname, "mine4") == 0)   ||
	   (Q_stricmp(level.mapname, "lab") == 0)     ||
	   (Q_stricmp(level.mapname, "boss1") == 0)   ||
	   (Q_stricmp(level.mapname, "fact3") == 0)   ||
	   (Q_stricmp(level.mapname, "biggun") == 0)  ||
	   (Q_stricmp(level.mapname, "space") == 0)   ||
	   (Q_stricmp(level.mapname, "command") == 0) ||
	   (Q_stricmp(level.mapname, "power2") == 0) ||
	   (Q_stricmp(level.mapname, "strike") == 0))
	{
		// invoke one of our gross, ugly, disgusting hacks
		self->think = SP_FixCoopSpots;
		self->nextthink = level.time + FRAMETIME;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x26c52(%rip), %rax     # 0x68f60
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x42324
jnp 0x4247f
movq 0x26a75(%rip), %r15     # 0x68da0
leaq 0x48(%r15), %r14
leaq 0x175fa(%rip), %rsi     # 0x59930
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x175e9(%rip), %rsi     # 0x59936
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x1607f(%rip), %rsi     # 0x583e3
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x16074(%rip), %rsi     # 0x583ef
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x16df8(%rip), %rsi     # 0x5918a
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x17593(%rip), %rsi     # 0x5993c
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x17582(%rip), %rsi     # 0x59942
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x1756f(%rip), %rsi     # 0x59946
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x16e06(%rip), %rsi     # 0x591f0
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x1754f(%rip), %rsi     # 0x5994c
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x17e45(%rip), %rsi     # 0x5a255
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x16392(%rip), %rsi     # 0x587b5
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x1751d(%rip), %rsi     # 0x59953
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
je 0x42455
leaq 0x14bdc(%rip), %rsi     # 0x57025
movq %r14, %rdi
callq 0x18690
testl %eax, %eax
jne 0x42479
leaq 0x30(%rip), %rax        # 0x4248c
movq %rax, 0x210(%rbx)
movss 0x4(%r15), %xmm0
addss 0x10e1f(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SP_FixCoopSpots
static void SP_FixCoopSpots (edict_t *self)
{
	edict_t	*spot;
	vec3_t	d;

	spot = NULL;

	while(1)
	{
		spot = G_Find(spot, FOFS(classname), "info_player_start");
		if (!spot)
			return;
		if (!spot->targetname)
			continue;
		VectorSubtract(self->s.origin, spot->s.origin, d);
		if (VectorLength(d) < 384)
		{
			if ((!self->targetname) || Q_stricmp(self->targetname, spot->targetname) != 0)
			{
//				gi.dprintf("FixCoopSpots changed %s at %s targetname from %s to %s\n", self->classname, vtos(self->s.origin), self->targetname, spot->targetname);
				self->targetname = spot->targetname;
			}
			return;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x110b8(%rip), %rdx     # 0x53559
xorl %edi, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x19430
testq %rax, %rax
je 0x4254c
movq %rax, %r14
leaq 0x11099(%rip), %r15     # 0x53559
leaq 0x8(%rsp), %r12
cmpq $0x0, 0x158(%r14)
je 0x42508
movsd 0x4(%rbx), %xmm0
movsd 0x4(%r14), %xmm1
subps %xmm1, %xmm0
movlps %xmm0, 0x8(%rsp)
movss 0xc(%rbx), %xmm0
subss 0xc(%r14), %xmm0
movss %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0x192e0
movss 0x17285(%rip), %xmm1    # 0x59788
ucomiss %xmm0, %xmm1
ja 0x42522
movq %r14, %rdi
movl $0x138, %esi            # imm = 0x138
movq %r15, %rdx
callq 0x19430
movq %rax, %r14
testq %rax, %rax
jne 0x424c5
jmp 0x4254c
movq 0x158(%rbx), %rdi
testq %rdi, %rdi
je 0x4253e
movq 0x158(%r14), %rsi
callq 0x18690
testl %eax, %eax
je 0x4254c
movq 0x158(%r14), %rax
movq %rax, 0x158(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SP_info_player_red
void SP_info_player_red(edict_t *self)
{
	vec3_t	end, angles;
	
	// If we have no facing for this spawn point...
	//  Turn it to face the flag
	if (!self->s.angles[1] && redflag)
	{
		VectorSubtract(redflag->s.origin, self->s.origin, end);
		vectoangles(end, angles);
		
		self->s.angles[1] = angles[1];
	}
	self->classname = "info_player_red";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
ucomiss 0x14(%rdi), %xmm0
setnp %al
sete %cl
andb %al, %cl
movq 0x26280(%rip), %rax     # 0x687f8
movq (%rax), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x425c2
movsd 0x4(%rax), %xmm0
movsd 0x4(%rbx), %xmm1
subps %xmm1, %xmm0
movq %rsp, %rdi
movlps %xmm0, (%rdi)
movss 0xc(%rax), %xmm0
subss 0xc(%rbx), %xmm0
movss %xmm0, 0x8(%rdi)
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x190d0
movss 0x4(%r14), %xmm0
movss %xmm0, 0x14(%rbx)
leaq 0x129e6(%rip), %rax     # 0x54faf
movq %rax, 0x138(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SP_info_player_blue
void SP_info_player_blue(edict_t *self)
{
	vec3_t	end, angles;
	
	// If we have no facing for this spawn point...
	//  Turn it to face the flag
	if (!self->s.angles[1] && blueflag)
	{
		VectorSubtract(blueflag->s.origin, self->s.origin, end);
		vectoangles(end, angles);
		
		self->s.angles[1] = angles[1];
	}
	self->classname = "info_player_blue";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
ucomiss 0x14(%rdi), %xmm0
setnp %al
sete %cl
andb %al, %cl
movq 0x26268(%rip), %rax     # 0x68860
movq (%rax), %rax
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x42642
movsd 0x4(%rax), %xmm0
movsd 0x4(%rbx), %xmm1
subps %xmm1, %xmm0
movq %rsp, %rdi
movlps %xmm0, (%rdi)
movss 0xc(%rax), %xmm0
subss 0xc(%rbx), %xmm0
movss %xmm0, 0x8(%rdi)
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x190d0
movss 0x4(%r14), %xmm0
movss %xmm0, 0x14(%rbx)
leaq 0x12976(%rip), %rax     # 0x54fbf
movq %rax, 0x138(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: IsNeutral
qboolean IsNeutral (edict_t *ent)
{
	char		*info;

	if (!ent->client)
		return false;

	info = Info_ValueForKey (ent->client->pers.userinfo, "gender");
	if (info[0] != 'f' && info[0] != 'F' && info[0] != 'm' && info[0] != 'M')
		return true;
	return false;
}

// Assembly:
movq 0x58(%rdi), %rdi
xorl %eax, %eax
testq %rdi, %rdi
je 0x426d2
pushq %rax
addq $0xc0, %rdi
leaq 0x172b4(%rip), %rsi     # 0x5995a
callq 0x18bb0
movzbl (%rax), %ecx
movl $0x1, %eax
addl $-0x46, %ecx
cmpl $0x27, %ecx
leaq 0x8(%rsp), %rsp
ja 0x426d2
movabsq $0x8100000081, %rdx     # imm = 0x8100000081
btq %rcx, %rdx
jae 0x426d2
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: LookAtKiller
void LookAtKiller (edict_t *self, edict_t *inflictor, edict_t *attacker)
{
	vec3_t		dir;

	if (attacker && attacker != world && attacker != self)
	{
		VectorSubtract (attacker->s.origin, self->s.origin, dir);
	}
	else if (inflictor && inflictor != world && inflictor != self)
	{
		VectorSubtract (inflictor->s.origin, self->s.origin, dir);
	}
	else
	{
		self->client->killer_yaw = self->s.angles[YAW];
		return;
	}

	if (dir[0])
		self->client->killer_yaw = 180/M_PI*atan2(dir[1], dir[0]);
	else {
		self->client->killer_yaw = 0;
		if (dir[1] > 0)
			self->client->killer_yaw = 90;
		else if (dir[1] < 0)
			self->client->killer_yaw = -90;
	}
	if (self->client->killer_yaw < 0)
		self->client->killer_yaw += 360;
	

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x25625(%rip), %rax     # 0x68558
movq (%rax), %rax
cmpq %rdi, %rdx
je 0x42f45
testq %rdx, %rdx
je 0x42f45
cmpq %rdx, %rax
jne 0x42f57
cmpq %rbx, %rsi
je 0x42fc3
testq %rsi, %rsi
je 0x42fc3
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x42fc3
movss 0x4(%rdx), %xmm1
movss 0x8(%rdx), %xmm0
subss 0x4(%rbx), %xmm1
subss 0x8(%rbx), %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x42f75
jnp 0x42fa4
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
callq 0x190b0
mulsd 0x1698e(%rip), %xmm0    # 0x59918
cvtsd2ss %xmm0, %xmm0
movq 0x58(%rbx), %rax
movss %xmm0, 0xe74(%rax)
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x42fe8
jmp 0x42ff8
movq 0x58(%rbx), %rax
movl $0x0, 0xe74(%rax)
ucomiss %xmm2, %xmm0
jbe 0x42fce
movl $0x42b40000, 0xe74(%rax) # imm = 0x42B40000
jmp 0x42ff8
movss 0x14(%rbx), %xmm0
movq 0x58(%rbx), %rax
jmp 0x42ff0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x42ff8
movl $0xc2b40000, 0xe74(%rax) # imm = 0xC2B40000
movss 0x16440(%rip), %xmm0    # 0x59428
addss 0x10d74(%rip), %xmm0    # 0x53d64
movss %xmm0, 0xe74(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: InitClientPersistent
void InitClientPersistent (gclient_t *client)
{
	gitem_t		*item;

	memset (&client->pers, 0, sizeof(client->pers));
	
	// CTF CODE -- LM_JORM
	item = FindItem("Grappling Hook");
	client->pers.inventory[ITEM_INDEX(item)] = 1;
	// END CTF CODE -- LM_JORM
	
	
	item = FindItem("Blaster");
	client->pers.selected_item = ITEM_INDEX(item);
	client->pers.inventory[client->pers.selected_item] = 1;

	client->pers.weapon = item;

	client->pers.health			= 100;
	client->pers.max_health		= 100;

	client->pers.max_bullets	= 200;
	client->pers.max_shells		= 100;
	client->pers.max_rockets	= 50;
	client->pers.max_grenades	= 50;
	client->pers.max_cells		= 200;
	client->pers.max_slugs		= 50;

	client->pers.connected = true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0xc0, %rdi
movl $0x698, %edx            # imm = 0x698
xorl %esi, %esi
callq 0x18880
leaq 0xfcda(%rip), %rdi      # 0x537f7
callq 0x189e0
movq 0x25317(%rip), %r14     # 0x68e40
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x3c3c3c3c3c3c3c3c, %rcx # imm = 0xC3C3C3C3C3C3C3C4
imulq %rax, %rcx
movl $0x1, %ebp
movl %ebp, 0x318(%rbx,%rcx)
leaq 0x12ce6(%rip), %rdi     # 0x56837
callq 0x189e0
movq %rax, %rcx
subq %r14, %rcx
sarq $0x3, %rcx
movabsq $-0xf0f0f0f0f0f0f0f, %rdx # imm = 0xF0F0F0F0F0F0F0F1
imulq %rcx, %rdx
movl %edx, 0x314(%rbx)
movslq %edx, %rcx
movl %ebp, 0x318(%rbx,%rcx,4)
movq %rax, 0x730(%rbx)
movl $0x64, 0x30c(%rbx)
movaps 0x15c3a(%rip), %xmm0    # 0x597d0
movups %xmm0, 0x718(%rbx)
movabsq $0x32000000c8, %rax     # imm = 0x32000000C8
movq %rax, 0x728(%rbx)
movabsq $0x6400000001, %rax     # imm = 0x6400000001
movq %rax, 0x304(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: InitClientResp
void InitClientResp (gclient_t *client)
{
	//surt
	//	  int teamnum, radio, extra_flags;
	//	  qboolean	goodskin;	// Flags that skin has been approved, no need to forcecommand
	//	  int 		pingalertfloor;
	//	  int 		pingalertceiling;
	//	  int 	compass;
	stats_player_s *playertemp;
	
	ctftemp = client->ctf;
	playertemp = client->p_stats_player;
	
	memset (&client->resp, 0, sizeof(client->resp));
	client->resp.enterframe = level.framenum;
	
	client->ctf = ctftemp;
	client->p_stats_player = playertemp;

	if ((int)ctfflags->value & CTF_TEAM_RESET)
	{
		//if (client->ctf.teamnum != CTF_TEAM_OBSERVER)
		//bat
		if (client->ctf.teamnum != CTF_TEAM_OBSERVER && 
			client->ctf.teamnum != CTF_TEAM_OBSERVER_RED &&
			client->ctf.teamnum != CTF_TEAM_OBSERVER_BLUE)
				client->ctf.teamnum = CTF_TEAM_UNDEFINED; // LM_JORM -- This will cause us to be on a new team
	}
	//surt above is allowed as a special case for now, otherwise only set teamnum
	//in ctf_SetEntTeam
	
	client->resp.coop_respawn = client->pers;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1100(%rdi), %r14
leaq 0x4d3ce(%rip), %rdi     # 0x90fa8
movl $0x8038, %edx           # imm = 0x8038
movq %r14, %rsi
callq 0x18c80
leaq 0x758(%rbx), %r15
movl $0x6b0, %edx            # imm = 0x6B0
movq %r15, %rdi
xorl %esi, %esi
callq 0x18880
movq 0x2519c(%rip), %rax     # 0x68da0
movl (%rax), %eax
movl %eax, 0xdf0(%rbx)
movq 0x24f45(%rip), %rax     # 0x68b58
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
testb $0x4, %al
je 0x43c2c
cmpl $-0x4, (%r14)
ja 0x43c2c
movl $0x0, (%r14)
addq $0xc0, %rbx
movl $0x698, %edx            # imm = 0x698
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x18c80
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: SaveClientData
void SaveClientData (void)
{
	int		i;
	edict_t	*ent;

	for (i=0 ; i<game.maxclients ; i++)
	{
		ent = &g_edicts[1+i];
		if (!ent->inuse)
			continue;
		game.clients[i].pers.health = ent->health;
		game.clients[i].pers.max_health = ent->max_health;
		game.clients[i].pers.savedFlags = (ent->flags & (FL_GODMODE|FL_NOTARGET|FL_POWER_ARMOR));
		if (coop->value)
			game.clients[i].pers.score = ent->client->resp.score;
	}
}

// Assembly:
movq 0x250f1(%rip), %rdi     # 0x68d40
movslq 0x610(%rdi), %rsi
testq %rsi, %rsi
jle 0x43cea
movq 0x248f2(%rip), %rax     # 0x68558
movq (%rax), %rax
movq 0x252f0(%rip), %rcx     # 0x68f60
movq (%rcx), %rcx
movl $0x308, %edx            # imm = 0x308
addq 0x408(%rdi), %rdx
imulq $0x4a8, %rsi, %rsi      # imm = 0x4A8
xorl %edi, %edi
movl $0x1030, %r8d           # imm = 0x1030
xorps %xmm0, %xmm0
cmpl $0x0, 0x508(%rax,%rdi)
je 0x43cd7
movq 0x6fc(%rax,%rdi), %r9
movq %r9, (%rdx)
movl 0x5c4(%rax,%rdi), %r9d
andl %r8d, %r9d
movl %r9d, 0x8(%rdx)
movss 0x20(%rcx), %xmm1
ucomiss %xmm0, %xmm1
jne 0x43cc1
jnp 0x43cd7
movq 0x500(%rax,%rdi), %r9
movl 0xdf4(%r9), %r9d
movl %r9d, 0x43c(%rdx)
addq $0x9140, %rdx           # imm = 0x9140
addq $0x4a8, %rdi            # imm = 0x4A8
cmpq %rdi, %rsi
jne 0x43c91
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: FetchClientEntData
void FetchClientEntData (edict_t *ent)
{
	ent->health = ent->client->pers.health;
	ent->max_health = ent->client->pers.max_health;
	ent->flags |= ent->client->pers.savedFlags;
	if (coop->value)
		ent->client->resp.score = ent->client->pers.score;
}

// Assembly:
movq 0x58(%rdi), %rax
movq 0x308(%rax), %rcx
movq %rcx, 0x254(%rdi)
movl 0x310(%rax), %ecx
orl %ecx, 0x11c(%rdi)
movq 0x25250(%rip), %rcx     # 0x68f60
movq (%rcx), %rcx
movss 0x20(%rcx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x43d22
jnp 0x43d2e
movl 0x744(%rax), %ecx
movl %ecx, 0xdf4(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/p_client.c
// Function: PlayersRangeFromSpot
float	PlayersRangeFromSpot (edict_t *spot)
{
	edict_t	*player;
	float	bestplayerdistance;
	vec3_t	v;
	int		n;
	float	playerdistance;


	bestplayerdistance = 9999999;

	for (n = 1; n <= maxclients->value; n++)
	{
		player = &g_edicts[n];

		if (!player->inuse)
			continue;

		if (player->health <= 0)
			continue;

		VectorSubtract (spot->s.origin, player->s.origin, v);
		playerdistance = VectorLength (v);

		if (playerdistance < bestplayerdistance)
			bestplayerdistance = playerdistance;
	}

	return bestplayerdistance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x247ec(%rip), %r15     # 0x68530
movq (%r15), %rax
movss 0x20(%rax), %xmm0
ucomiss 0xf1d5(%rip), %xmm0     # 0x52f28
jae 0x43d68
movss 0xf52f(%rip), %xmm0     # 0x5328c
movss %xmm0, 0x8(%rsp)
jmp 0x43e1a
movq %rdi, %rbx
movq 0x247e6(%rip), %r12     # 0x68558
movq (%r12), %rax
movss 0xf50e(%rip), %xmm0     # 0x5328c
movss %xmm0, 0x8(%rsp)
movl $0x4ac, %r13d           # imm = 0x4AC
movl $0x2, %ebp
leaq 0xc(%rsp), %r14
cmpl $0x0, 0x5c(%rax,%r13)
je 0x43df9
cmpl $0x0, 0x250(%rax,%r13)
jle 0x43df9
movss 0x4(%rbx), %xmm0
subss (%rax,%r13), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x8(%rbx), %xmm0
subss 0x4(%rax,%r13), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0xc(%rbx), %xmm0
subss 0x8(%rax,%r13), %xmm0
movss %xmm0, 0x14(%rsp)
movq %r14, %rdi
callq 0x192e0
movss 0x8(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movq (%r12), %rax
jbe 0x43df9
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movq (%r15), %rcx
movss 0x20(%rcx), %xmm1
addq $0x4a8, %r13            # imm = 0x4A8
incl %ebp
ucomiss %xmm0, %xmm1
jae 0x43d94
movss 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq