LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_Find
edict_t *G_Find (edict_t *from, int fieldofs, char *match)
{
	char	*s;

	if (!from)
		from = g_edicts;
	else
		from++;

	for ( ; from < &g_edicts[globals.num_edicts] ; from++)
	{
		if (!from->inuse)
			continue;
		s = *(char **) ((byte *)from + fieldofs);
		if (!s)
			continue;
		if (!Q_stricmp (s, match))
			return from;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x501fa
movq 0x32367(%rip), %rax     # 0x82558
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x50208
movq -0x10(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x10(%rbp)
jmp 0x5020a
movq -0x10(%rbp), %rax
movq 0x32343(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
movq 0x328e9(%rip), %rdx     # 0x82b08
movslq 0x8c(%rdx), %rdx
imulq $0x4a8, %rdx, %rdx      # imm = 0x4A8
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x50288
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x50241
jmp 0x50278
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5025a
jmp 0x50278
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x186f0
cmpl $0x0, %eax
jne 0x50276
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50290
jmp 0x50278
movq -0x10(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x10(%rbp)
jmp 0x5020a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: findradius
edict_t *findradius (edict_t *from, vec3_t org, float rad)
{
	vec3_t	eorg;
	int		j;

	if (!from)
		from = g_edicts;
	else
		from++;
	for ( ; from < &g_edicts[globals.num_edicts]; from++)
	{
		if (!from->inuse)
			continue;
		if (from->solid == SOLID_NOT)
			continue;
		for (j=0 ; j<3 ; j++)
			eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5f);
		if (VectorLength(eorg) > rad)
			continue;
		return from;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x502cc
movq 0x32295(%rip), %rax     # 0x82558
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x502da
movq -0x10(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x10(%rbp)
jmp 0x502dc
movq -0x10(%rbp), %rax
movq 0x32271(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
movq 0x32817(%rip), %rdx     # 0x82b08
movslq 0x8c(%rdx), %rdx
imulq $0x4a8, %rdx, %rdx      # imm = 0x4A8
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x503cd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x5031a
jmp 0x503ba
movq -0x10(%rbp), %rax
cmpl $0x0, 0x108(%rax)
jne 0x5032c
jmp 0x503ba
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x5039f
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss 0x4(%rax,%rcx,4), %xmm2
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss 0xcc(%rax,%rcx,4), %xmm1
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addss 0xd8(%rax,%rcx,4), %xmm1
movss 0x227d2(%rip), %xmm3    # 0x72b50
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
subss %xmm1, %xmm0
movslq -0x2c(%rbp), %rax
movss %xmm0, -0x28(%rbp,%rax,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x50333
leaq -0x28(%rbp), %rdi
callq 0x194e0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x503b0
jmp 0x503ba
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x503d5
movq -0x10(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x10(%rbp)
jmp 0x502dc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: findallradius
edict_t *findallradius (edict_t *from, vec3_t org, float rad)
{
	vec3_t	eorg;
	int		j;

	if (!from)
		from = g_edicts;
	else
		from++;
	for ( ; from < &g_edicts[globals.num_edicts]; from++)
	{
		if (!from->inuse)
			continue;
		for (j=0 ; j<3 ; j++)
			eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5f);
		if (VectorLength(eorg) > rad)
			continue;
		return from;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5040c
movq 0x32155(%rip), %rax     # 0x82558
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5041a
movq -0x10(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x10(%rbp)
jmp 0x5041c
movq -0x10(%rbp), %rax
movq 0x32131(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
movq 0x326d7(%rip), %rdx     # 0x82b08
movslq 0x8c(%rdx), %rdx
imulq $0x4a8, %rdx, %rdx      # imm = 0x4A8
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x504fb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x5045a
jmp 0x504e8
movl $0x0, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x504cd
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss 0x4(%rax,%rcx,4), %xmm2
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movss 0xcc(%rax,%rcx,4), %xmm1
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addss 0xd8(%rax,%rcx,4), %xmm1
movss 0x226a4(%rip), %xmm3    # 0x72b50
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
subss %xmm1, %xmm0
movslq -0x2c(%rbp), %rax
movss %xmm0, -0x28(%rbp,%rax,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x50461
leaq -0x28(%rbp), %rdi
callq 0x194e0
ucomiss -0x1c(%rbp), %xmm0
jbe 0x504de
jmp 0x504e8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50503
movq -0x10(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x10(%rbp)
jmp 0x5041c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_PickTarget
edict_t *G_PickTarget (char *targetname)
{
	edict_t	*ent = NULL;
	int		num_choices = 0;
	edict_t	*choice[MAXCHOICES];

	if (!targetname)
	{
		gi.dprintf("G_PickTarget called with NULL targetname\n");
		return NULL;
	}

	while(1)
	{
		ent = G_Find (ent, FOFS(targetname), targetname);
		if (!ent)
			break;
		choice[num_choices++] = ent;
		if (num_choices == MAXCHOICES)
			break;
	}

	if (!num_choices)
	{
		gi.dprintf("G_PickTarget: target %s not found\n", targetname);
		return NULL;
	}

	return choice[rand() % num_choices];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x50552
leaq 0x25bef(%rip), %rdi     # 0x76128
movq 0x320c0(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x8(%rcx)
movq $0x0, -0x8(%rbp)
jmp 0x505d7
jmp 0x50554
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %eax, %eax
addq $0x158, %rax            # imm = 0x158
movl %eax, %esi
callq 0x19660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x50578
jmp 0x50598
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
cltq
movq %rcx, -0x60(%rbp,%rax,8)
cmpl $0x8, -0x1c(%rbp)
jne 0x50596
jmp 0x50598
jmp 0x50554
cmpl $0x0, -0x1c(%rbp)
jne 0x505c2
movq 0x3205b(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rsi
leaq 0x25b9e(%rip), %rdi     # 0x76152
movb $0x0, %al
callq *%rcx
movq $0x0, -0x8(%rbp)
jmp 0x505d7
callq 0x19c80
cltd
idivl -0x1c(%rbp)
movslq %edx, %rax
movq -0x60(%rbp,%rax,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_FreeEdict
void G_FreeEdict (edict_t *ed)
{
	gi.unlinkentity (ed);		// unlink from world

	// LM_JORM -- REMOVE later
/*	
	if (!strcmp(ed->classname, "flag") ||
		!strcmp(ed->classname, "damage_rune") ||
		!strcmp(ed->classname, "haste_rune") ||
		!strcmp(ed->classname, "resist_rune") ||
		!strcmp(ed->classname, "regen_rune"))
		assert(false);
*/
	// LM_JORM END
	if ((ed - g_edicts) <= (maxclients->value + BODY_QUEUE_SIZE))
	{
//		gi.dprintf("tried to free special edict\n");
		return;
	}

	memset (ed, 0, sizeof(*ed));
	ed->classname = "freed";
	ed->freetime = level.time;
	ed->inuse = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x31c8d(%rip), %rax     # 0x82600
movq 0x98(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x31bcd(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x4a8, %ecx            # imm = 0x4A8
cqto
idivq %rcx
cvtsi2ss %rax, %xmm1
movq 0x31b89(%rip), %rax     # 0x82530
movq (%rax), %rax
movss 0x1f54a(%rip), %xmm0    # 0x6fefc
addss 0x20(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x509be
jmp 0x50a03
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x4a8, %edx            # imm = 0x4A8
callq 0x188f0
movq -0x8(%rbp), %rax
leaq 0x25864(%rip), %rcx     # 0x7623d
movq %rcx, 0x138(%rax)
movq 0x323b9(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x128(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_Spawn
edict_t *G_Spawn (void)
{
	int			i;
	edict_t		*e;

	e = &g_edicts[(int)maxclients->value+1];
	for ( i=maxclients->value+1 ; i<globals.num_edicts ; i++, e++)
	{
		// the first couple seconds of server time can involve a lot of
		// freeing and allocating, so relax the replacement policy
		if (!e->inuse && ( e->freetime < 2 || level.time - e->freetime > 0.5f ) )
		{
			G_InitEdict (e);
			return e;
		}
	}
	
	if (i == game.maxentities)
		gi.error ("ED_Alloc: no free edicts");
		
	globals.num_edicts++;
	G_InitEdict (e);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x31b39(%rip), %rax     # 0x82558
movq (%rax), %rax
movq 0x31b07(%rip), %rcx     # 0x82530
movq (%rcx), %rcx
cvttss2si 0x20(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x31ae4(%rip), %rax     # 0x82530
movq (%rax), %rax
movss 0x1f495(%rip), %xmm0    # 0x6feec
addss 0x20(%rax), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x3209b(%rip), %rcx     # 0x82b08
cmpl 0x8c(%rcx), %eax
jge 0x50aea
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x50acc
movq -0x18(%rbp), %rax
movss 0x1f45d(%rip), %xmm0    # 0x6fee8
ucomiss 0x128(%rax), %xmm0
ja 0x50ab9
movq 0x32305(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
subss 0x128(%rax), %xmm0
movss 0x2209c(%rip), %xmm1    # 0x72b50
ucomiss %xmm1, %xmm0
jbe 0x50acc
movq -0x18(%rbp), %rdi
callq 0x18f50
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50b3d
jmp 0x50ace
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x18(%rbp)
jmp 0x50a63
movl -0xc(%rbp), %eax
movq 0x3224c(%rip), %rcx     # 0x82d40
cmpl 0x614(%rcx), %eax
jne 0x50b0f
leaq 0x25721(%rip), %rdi     # 0x76224
movq 0x31af6(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x38(%rcx)
movq 0x31ff2(%rip), %rax     # 0x82b08
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movq 0x31fe2(%rip), %rax     # 0x82b08
movl %ecx, 0x8c(%rax)
movq -0x18(%rbp), %rdi
callq 0x18f50
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: tv
float	*tv (float x, float y, float z)
{
	static	int		index = 1;
	static	vec3_t	vecs[8];
	float	*v;

	// use an array so that multiple tempvectors won't collide
	// for a while
	v = vecs[index];
	index = (index + 1) & 7;

	v[0] = x;
	v[1] = y;
	v[2] = z;

	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movslq 0x36c06(%rip), %rcx     # 0x87770
leaq 0x5a43f(%rip), %rax     # 0xaafb0
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl 0x36bee(%rip), %eax     # 0x87770
addl $0x1, %eax
andl $0x7, %eax
movl %eax, 0x36be2(%rip)     # 0x87770
movss -0x4(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: vtos
char	*vtos (vec3_t v)
{
	static	int		index;
	static	char	str[8][32];
	char	*s;

	// use an array so that multiple vtos won't collide
	s = str[index];
	index = (index + 1)&7;

	Com_sprintf (s, 32, "(%i %i %i)", (int)v[0], (int)v[1], (int)v[2]);

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movslq 0x5a43d(%rip), %rcx     # 0xab010
leaq 0x5a446(%rip), %rax     # 0xab020
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl 0x5a425(%rip), %eax     # 0xab010
addl $0x1, %eax
andl $0x7, %eax
movl %eax, 0x5a419(%rip)     # 0xab010
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
cvttss2si (%rax), %ecx
movq -0x8(%rbp), %rax
cvttss2si 0x4(%rax), %r8d
movq -0x8(%rbp), %rax
cvttss2si 0x8(%rax), %r9d
movl $0x20, %esi
leaq 0x255ee(%rip), %rdx     # 0x76211
movb $0x0, %al
callq 0x18f90
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_SetMovedir
void G_SetMovedir (vec3_t angles, vec3_t movedir)
{
	if (VectorCompare (angles, VEC_UP))
	{
		VectorCopy (MOVEDIR_UP, movedir);
	}
	else if (VectorCompare (angles, VEC_DOWN))
	{
		VectorCopy (MOVEDIR_DOWN, movedir);
	}
	else
	{
		AngleVectors (angles, movedir, NULL, NULL);
	}

	VectorClear (angles);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x31f75(%rip), %rsi     # 0x82bd0
callq 0x18c60
cmpl $0x0, %eax
je 0x50ca4
movq 0x318cc(%rip), %rax     # 0x82538
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq 0x318b9(%rip), %rax     # 0x82538
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq 0x318a4(%rip), %rax     # 0x82538
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
jmp 0x50d0e
movq -0x8(%rbp), %rdi
movq 0x322c1(%rip), %rsi     # 0x82f70
callq 0x18c60
cmpl $0x0, %eax
je 0x50cf8
movq 0x31720(%rip), %rax     # 0x823e0
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq 0x3170d(%rip), %rax     # 0x823e0
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq 0x316f8(%rip), %rax     # 0x823e0
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
jmp 0x50d0c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x183e0
jmp 0x50d0e
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: vectoyaw
float vectoyaw (vec3_t vec)
{
	float	yaw;
	
	if (/*vec[YAW] == 0 &&*/ vec[PITCH] == 0) 
	{
		yaw = 0;
		if (vec[YAW] > 0)
			yaw = 90;
		else if (vec[YAW] < 0)
			yaw = -90;
	} 
	else
	{
		yaw = (int) (atan2(vec[YAW], vec[PITCH]) * 180 / M_PI);
		if (yaw < 0)
			yaw += 360;
	}

	return yaw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x50da4
jp 0x50da4
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x50d86
movss 0x206a5(%rip), %xmm0    # 0x71424
movss %xmm0, -0xc(%rbp)
jmp 0x50da2
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
ucomiss 0x4(%rax), %xmm0
jbe 0x50da0
movss 0x25371(%rip), %xmm0    # 0x7610c
movss %xmm0, -0xc(%rbp)
jmp 0x50da2
jmp 0x50e04
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm1
callq 0x19270
movsd 0x25356(%rip), %xmm1    # 0x76120
mulsd %xmm1, %xmm0
movsd 0x25342(%rip), %xmm1    # 0x76118
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x50e02
movss 0x1ff2c(%rip), %xmm0    # 0x70d24
addss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x50e04
movss -0xc(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x60(%rax)
movq -0x8(%rbp), %rax
leaq 0x251ae(%rip), %rcx     # 0x7621c
movq %rcx, 0x138(%rax)
movq -0x8(%rbp), %rax
movss 0x1ee6b(%rip), %xmm0    # 0x6feec
movss %xmm0, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movq 0x314c4(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x4a8, %ecx            # imm = 0x4A8
cqto
idivq %rcx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x510dc
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x510ee
movq -0x8(%rbp), %rax
cmpl $0x0, 0x254(%rax)
jg 0x510ee
jmp 0x51198
movq 0x3150b(%rip), %rax     # 0x82600
movq 0xa0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0xe4, %rdi
movq -0x8(%rbp), %rsi
addq $0xf0, %rsi
leaq -0x2010(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
movl $0x2, %r8d
callq *%rax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x51198
movslq -0xc(%rbp), %rax
movq -0x2010(%rbp,%rax,8), %rax
movq %rax, -0x2018(%rbp)
movq -0x2018(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x5115a
jmp 0x5118d
movq -0x2018(%rbp), %rax
cmpq $0x0, 0x220(%rax)
jne 0x5116d
jmp 0x5118d
movq -0x2018(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x2018(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x51130
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq 0x3143a(%rip), %rax     # 0x82600
movq 0xa0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0xe4, %rdi
movq -0x8(%rbp), %rsi
addq $0xf0, %rsi
leaq -0x2010(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
movl $0x1, %r8d
callq *%rax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5126f
movslq -0xc(%rbp), %rax
movq -0x2010(%rbp,%rax,8), %rax
movq %rax, -0x2018(%rbp)
movq -0x2018(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x5122b
jmp 0x51264
movq -0x8(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0x51256
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x2018(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x51262
jmp 0x5126f
jmp 0x51264
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x51201
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq 0x3136a(%rip), %rax     # 0x82600
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
addq $0xcc, %rdx
movq -0x10(%rbp), %rcx
addq $0xd8, %rcx
movq -0x10(%rbp), %r8
addq $0x4, %r8
leaq -0xa0(%rbp), %rdi
xorl %r9d, %r9d
movl $0x2010003, (%rsp)      # imm = 0x2010003
callq *%rax
leaq -0x58(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x48, %edx
callq 0x18dc0
cmpq $0x0, -0x18(%rbp)
jne 0x512f1
jmp 0x51350
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq 0x3145c(%rip), %r9      # 0x82768
xorl %eax, %eax
movq %r9, %rcx
movl $0x186a0, (%rsp)        # imm = 0x186A0
movl $0x0, 0x8(%rsp)
movl $0x20, 0x10(%rsp)
movl $0x15, 0x18(%rsp)
callq 0x192c0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x108(%rax)
je 0x5134b
movl $0x0, -0x4(%rbp)
jmp 0x51357
jmp 0x5128f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x319ac(%rip), %rcx     # 0x82d40
cmpl 0x610(%rcx), %eax
jge 0x5142a
movq 0x311b1(%rip), %rax     # 0x82558
movq (%rax), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movslq -0x1c(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x513ce
jmp 0x5141c
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1100(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x513fa
movq 0x31218(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq *%rcx
jmp 0x5141a
cmpq $0x0, -0x18(%rbp)
je 0x51418
movq 0x311f8(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq *%rcx
jmp 0x5141a
jmp 0x5141c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5138a
movq 0x311cf(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rdi
movb $0x0, %al
callq *%rcx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x318cc(%rip), %rcx     # 0x82d40
cmpl 0x610(%rcx), %eax
jge 0x51509
movq 0x310d1(%rip), %rax     # 0x82558
movq (%rax), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movslq -0x1c(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x18e40
cmpl $0x0, %eax
jne 0x514b7
jmp 0x514fb
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1100(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x514de
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
jmp 0x514f9
cmpq $0x0, -0x18(%rbp)
je 0x514f7
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
jmp 0x514f9
jmp 0x514fb
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5146a
movq 0x310f0(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rdi
movb $0x0, %al
callq *%rcx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x5237e
jmp 0x524ed
cmpq $0x0, -0x20(%rbp)
je 0x523a2
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x523a2
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x524ed
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
cmpq $0x0, 0x58(%rax)
je 0x523d1
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl $0x2, %edx
callq 0x19080
movq -0x10(%rbp), %rax
cmpl $0x0, 0x27c(%rax)
je 0x5245a
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x523f9
movl $0xa, -0x24(%rbp)
jmp 0x52400
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdx
movq -0x8(%rbp), %rcx
addq $0x1c0, %rcx            # imm = 0x1C0
movq -0x8(%rbp), %r8
addq $0x4, %r8
movq -0x18(%rbp), %r9
movq -0x8(%rbp), %rax
movl 0x280(%rax), %r10d
movl -0x24(%rbp), %eax
movl %r10d, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x4, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x192c0
jmp 0x524e4
movl $0x3, %edi
movq 0x3019a(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movl $0x2, %edi
movq 0x30188(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x3017b(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq *%rax
cmpq $0x0, -0x18(%rbp)
jne 0x524b3
movq 0x302c4(%rip), %rdi     # 0x82768
movq 0x30155(%rip), %rax     # 0x82600
callq *0xf8(%rax)
jmp 0x524c7
movq 0x30146(%rip), %rax     # 0x82600
movq 0xf8(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq 0x30132(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x19cd0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: check_dodge
static void check_dodge (edict_t *self, vec3_t start, vec3_t dir, int speed)
{
	vec3_t	end;
#ifdef MONSTERS_OK
	vec3_t	v;
	trace_t	tr;
	float	eta;
#endif

	// easy mode only ducks one quarter the time
	if (skill->value == 0)
	{
		if (random() > 0.25)
			return;
	}
	VectorMA (start, 8192, dir, end);
#ifdef MONSTERS_OK
	tr = gi.trace (start, NULL, NULL, end, self, MASK_SHOT);
	if ((tr.ent) && (tr.ent->svflags & SVF_MONSTER) && (tr.ent->health > 0) && (tr.ent->monsterinfo.dodge) && infront(tr.ent, self))
	{
		VectorSubtract (tr.endpos, start, v);
		eta = (VectorLength(v) - tr.ent->maxs[0]) / speed;
		tr.ent->monsterinfo.dodge (tr.ent, self, eta);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0x2ff1a(%rip), %rax     # 0x82738
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x52860
jp 0x52860
callq 0x19c80
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
movss 0x1da42(%rip), %xmm1    # 0x70288
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x239fa(%rip), %xmm1    # 0x76250
ucomisd %xmm1, %xmm0
jbe 0x5285e
jmp 0x52879
jmp 0x52860
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movss 0x239d0(%rip), %xmm0    # 0x76244
callq 0x199c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jne 0x52bbe
jmp 0x52d28
cmpq $0x0, -0x20(%rbp)
je 0x52be2
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x52be2
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x52d28
movq -0x10(%rbp), %rax
cmpl $0x0, 0x27c(%rax)
jne 0x52d10
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x52cc7
callq 0x19c80
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
movss 0x1d669(%rip), %xmm1    # 0x70288
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1e7f9(%rip), %xmm1    # 0x71428
ucomisd %xmm1, %xmm0
jbe 0x52c7e
movq 0x2f9c4(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x23725(%rip), %rdi     # 0x76378
movq 0x2f9a6(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x30(%rbp), %rdi
movl %eax, %edx
movq -0x28(%rbp), %rax
movl $0x2, %esi
movss 0x1d278(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
jmp 0x52cc5
movq 0x2f97b(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x236f1(%rip), %rdi     # 0x7638d
movq 0x2f95d(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x40(%rbp), %rdi
movl %eax, %edx
movq -0x38(%rbp), %rax
movl $0x2, %esi
movss 0x1d22f(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
jmp 0x52d0e
movq 0x2f932(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x208a0(%rip), %rdi     # 0x73585
movq 0x2f914(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x50(%rbp), %rdi
movl %eax, %edx
movq -0x48(%rbp), %rax
movl $0x2, %esi
movss 0x1d1e6(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
jmp 0x52d28
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2a0(%rax)
movq -0x8(%rbp), %rdi
callq 0x52d30
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, %edi
movq 0x2dd50(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movl $0x16, %edi
movq 0x2dd3e(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x2dd31(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq *%rax
movq 0x2dd19(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x19cd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/m_boss3.c
// Function: Think_Boss3Stand
void Think_Boss3Stand (edict_t *ent)
{
	if (ent->s.frame == FRAME_stand260)
		ent->s.frame = FRAME_stand201;
	else
		ent->s.frame++;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1d9, 0x38(%rax)      # imm = 0x1D9
jne 0x54932
movq -0x8(%rbp), %rax
movl $0x19e, 0x38(%rax)      # imm = 0x19E
jmp 0x5493f
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movss 0x1b94d(%rip), %xmm0    # 0x70294
movq 0x2e452(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2e53d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x54997
jp 0x54997
jmp 0x549a5
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x54adb
movq -0x8(%rbp), %rax
movl $0x5, 0x118(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x108(%rax)
movq -0x8(%rbp), %rax
leaq 0x219d6(%rip), %rcx     # 0x763a2
movq %rcx, 0x120(%rax)
movq 0x2dc26(%rip), %rax     # 0x82600
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x120(%rcx), %rdi
callq *%rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x19e, 0x38(%rax)      # imm = 0x19E
leaq 0x219c1(%rip), %rdi     # 0x763c7
movq 0x2dbf3(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x8(%rbp), %rax
movss 0x1c9f0(%rip), %xmm0    # 0x7140c
movss %xmm0, 0xcc(%rax)
movq -0x8(%rbp), %rax
movss 0x1c9dc(%rip), %xmm0    # 0x7140c
movss %xmm0, 0xd0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xd4(%rax)
movq -0x8(%rbp), %rax
movss 0x1ba21(%rip), %xmm0    # 0x70474
movss %xmm0, 0xd8(%rax)
movq -0x8(%rbp), %rax
movss 0x1ba0d(%rip), %xmm0    # 0x70474
movss %xmm0, 0xdc(%rax)
movq -0x8(%rbp), %rax
movss 0x1c9a9(%rip), %xmm0    # 0x71424
movss %xmm0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq 0x2da4a(%rip), %rcx     # 0x824d8
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rax
movq 0x2e1b8(%rip), %rcx     # 0x82c58
movq %rcx, 0x210(%rax)
movss 0x1b7e5(%rip), %xmm0    # 0x70294
movq 0x2e2ea(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq 0x2db32(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/m_move.c
// Function: M_ChangeYaw
void M_ChangeYaw (edict_t *ent)
{
	float	ideal;
	float	current;
	float	move;
	float	speed;
	
	current = anglemod(ent->s.angles[YAW]);
	ideal = ent->ideal_yaw;

	if (current == ideal)
		return;

	move = ideal - current;
	speed = ent->yaw_speed;
	if (ideal > current)
	{
		if (move >= 180)
			move = move - 360;
	}
	else
	{
		if (move <= -180)
			move = move + 360;
	}
	if (move > 0)
	{
		if (move > speed)
			move = speed;
	}
	else
	{
		if (move < -speed)
			move = -speed;
	}
	
	ent->s.angles[YAW] = anglemod (current + move);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
callq 0x18b20
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x1fc(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x10(%rbp), %xmm0
ucomiss -0xc(%rbp), %xmm0
jne 0x55842
jp 0x55842
jmp 0x5592a
movss -0xc(%rbp), %xmm0
subss -0x10(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0x1f8(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x55897
movss -0x14(%rbp), %xmm0
movss 0x20b6a(%rip), %xmm1    # 0x763e4
ucomiss %xmm1, %xmm0
jb 0x55895
movss -0x14(%rbp), %xmm0
movss 0x1b498(%rip), %xmm1    # 0x70d24
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x558b9
movss 0x20b41(%rip), %xmm0    # 0x763e0
ucomiss -0x14(%rbp), %xmm0
jb 0x558b7
movss 0x1b477(%rip), %xmm0    # 0x70d24
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x558b9
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x558dd
movss -0x14(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x558db
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x55912
movss -0x14(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x55910
movss -0x18(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x14(%rbp)
jmp 0x55912
movss -0x10(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
callq 0x18b20
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1fc(%rax)
movq -0x10(%rbp), %rdi
callq 0x18370
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x207a7(%rip), %xmm1    # 0x76118
mulsd %xmm1, %xmm0
movsd 0x1d21b(%rip), %xmm1    # 0x72b98
mulsd %xmm1, %xmm0
movsd 0x20a67(%rip), %xmm1    # 0x763f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x18a40
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19770
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x19cc0
cmpl $0x0, %eax
je 0x55ab2
movq -0x10(%rbp), %rax
movss 0x14(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x1fc(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
movss 0x20999(%rip), %xmm1    # 0x763e8
ucomiss %xmm1, %xmm0
jbe 0x55a8c
movss 0x20990(%rip), %xmm0    # 0x763ec
ucomiss -0x34(%rbp), %xmm0
jbe 0x55a8c
movss -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x2c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq 0x2cb6d(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x193f0
movl $0x1, -0x4(%rbp)
jmp 0x55ad6
movq 0x2cb47(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x193f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/m_move.c
// Function: SV_CloseEnough
qboolean SV_CloseEnough (edict_t *ent, edict_t *goal, float dist)
{
	int		i;
	
	for (i=0 ; i<3 ; i++)
	{
		if (goal->absmin[i] > ent->absmax[i] + dist)
			return false;
		if (goal->absmax[i] < ent->absmin[i] - dist)
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x55fc5
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss 0xe4(%rax,%rcx,4), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss 0xf0(%rax,%rcx,4), %xmm1
addss -0x1c(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x55f83
movl $0x0, -0x4(%rbp)
jmp 0x55fcc
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss 0xf0(%rax,%rcx,4), %xmm1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss 0xe4(%rax,%rcx,4), %xmm0
subss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x55fb8
movl $0x0, -0x4(%rbp)
jmp 0x55fcc
jmp 0x55fba
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x55f48
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x1e8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2b8(%rax)
jne 0x56022
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x56022
jmp 0x5609a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x56050
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rsi
movss -0xc(%rbp), %xmm0
callq 0x19120
cmpl $0x0, %eax
je 0x56050
jmp 0x5609a
callq 0x19c80
andl $0x3, %eax
cmpl $0x1, %eax
je 0x5607c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movss 0x1fc(%rax), %xmm0
movss -0xc(%rbp), %xmm1
callq 0x18220
cmpl $0x0, %eax
jne 0x5609a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x56098
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movss -0xc(%rbp), %xmm0
callq 0x188b0
jmp 0x5609a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2b8(%rax)
jne 0x560e2
movq -0x10(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x560e2
movl $0x0, -0x4(%rbp)
jmp 0x5617d
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x20025(%rip), %xmm1    # 0x76118
mulsd %xmm1, %xmm0
movsd 0x1ca99(%rip), %xmm1    # 0x72b98
mulsd %xmm1, %xmm0
movsd 0x202e5(%rip), %xmm1    # 0x763f0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x18a40
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19770
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x1, %edx
callq 0x19cc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1100(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl $0xfffffffa, %esi       # imm = 0xFFFFFFFA
callq 0x18ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x56223
movq -0x18(%rbp), %rax
cmpq $0x0, 0x330(%rax)
je 0x56223
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x330(%rax), %rax
movq 0x2cc4f(%rip), %rcx     # 0x82e40
subq %rcx, %rax
movl $0x88, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpl $0x0, 0x318(%rax,%rcx,4)
je 0x56219
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5622b
movq $0x0, -0x8(%rbp)
jmp 0x5622b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)