LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadEdict
void ReadEdict(FILE* f, edict_t* ent)
{
	field_t* field;
	size_t	count;

	count = fread(ent, sizeof(*ent), 1, f);
	if (count)
		; // don't worry, be happy

	for (field = fields; field->name; field++)
	{
		ReadField(f, field, (byte*)ent);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4a8, %esi            # imm = 0x4A8
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x183f0
movq 0x2ebba(%rip), %r15     # 0x68a40
cmpq $0x0, (%r15)
je 0x39ea5
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x198b0
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x39e8c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadLevelLocals
void ReadLevelLocals(FILE* f)
{
	field_t* field;
	size_t	count;

	count = fread(&level, sizeof(level), 1, f);
	if (count)
		; // don't worry, be happy

	for (field = levelfields; field->name; field++)
	{
		ReadField(f, field, (byte*)&level);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2eee6(%rip), %rdi     # 0x68da0
movl $0x158, %esi            # imm = 0x158
movl $0x1, %edx
movq %rbx, %rcx
callq 0x183f0
movq 0x2e825(%rip), %r14     # 0x686f8
cmpq $0x0, (%r14)
je 0x39ef9
movq 0x2eec0(%rip), %r15     # 0x68da0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x198b0
cmpq $0x0, 0x18(%r14)
leaq 0x18(%r14), %r14
jne 0x39ee0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: WriteLevel
void WriteLevel(char* filename)
{
	int		i;
	edict_t* ent;
	FILE* f;
	void	(*base)(void);	/* Pointer to function with no arguments */

	f = fopen(filename, "wb");
	if (!f)
	{
		gi.error("Couldn't open %s", filename);
		return;
	}

	// write out edict size for checking
	i = sizeof(edict_t);
	fwrite(&i, sizeof(i), 1, f);

	// write out a function pointer for checking
	base = InitGame;
	fwrite(&base, sizeof(base), 1, f);

	// write out level_locals_t
	WriteLevelLocals(f);

	// write out all the entities
	for (i = 0; i < globals.num_edicts; i++)
	{
		ent = &g_edicts[i];
		if (!ent->inuse)
			continue;
		fwrite(&i, sizeof(i), 1, f);
		WriteEdict(f, ent);
	}
	i = -1;
	fwrite(&i, sizeof(i), 1, f);

	fclose(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x1d3aa(%rip), %rsi     # 0x572c0
callq 0x19470
testq %rax, %rax
je 0x3a01e
movq %rax, %rbx
leaq 0x4(%rsp), %r14
movl $0x4a8, (%r14)          # imm = 0x4A8
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x19710
movq 0x2e739(%rip), %rax     # 0x68688
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x19710
movq %rbx, %rdi
callq 0x19930
movl $0x0, (%r14)
movq 0x2eb89(%rip), %r12     # 0x68b08
movl 0x8c(%r12), %eax
testl %eax, %eax
jle 0x39fec
movq 0x2e5c6(%rip), %r13     # 0x68558
movq (%r13), %r15
xorl %ecx, %ecx
leaq 0x4(%rsp), %r14
movslq %ecx, %rdx
imulq $0x4a8, %rdx, %rdx      # imm = 0x4A8
cmpl $0x0, 0x60(%r15,%rdx)
je 0x39fe2
addq %rdx, %r15
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x19710
movq %rbx, %rdi
movq %r15, %rsi
callq 0x181d0
movq (%r13), %r15
movl 0x4(%rsp), %ecx
movl 0x8c(%r12), %eax
incl %ecx
movl %ecx, 0x4(%rsp)
cmpl %eax, %ecx
jl 0x39f9d
leaq 0x4(%rsp), %rdi
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x19710
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x185a0
movq 0x2e5db(%rip), %rax     # 0x68600
movq 0x38(%rax), %rcx
leaq 0x19ecd(%rip), %rdi     # 0x53efd
movq %r14, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: SP_info_flag_red
void SP_info_flag_red(edict_t *self)
{
	if (!deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}
	SP_misc_teleporter_dest (self);
	self->s.effects |= EF_COLOR_SHELL;
	self->s.renderfx |= RF_SHELL_RED;
	self->classname = "info_flag_red";
	redflag = self;
	putonfloor(self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2e641(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3a891
jnp 0x3a8c8
movq %rbx, %rdi
callq 0x18510
movabsq $0x40000000100, %rax    # imm = 0x40000000100
orq %rax, 0x40(%rbx)
leaq 0x186a2(%rip), %rax     # 0x52f50
movq %rax, 0x138(%rbx)
movq 0x2df3c(%rip), %rax     # 0x687f8
movq %rbx, (%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x18670
movq %rbx, %rdi
popq %rbx
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: SP_info_flag_blue
void SP_info_flag_blue(edict_t *self)
{
	if (!deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}
	SP_misc_teleporter_dest (self);
	self->s.effects |= EF_COLOR_SHELL;
	self->s.renderfx |= RF_SHELL_BLUE;
	self->classname = "info_flag_blue";
	blueflag = self;
	putonfloor(self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2e5e4(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3a8ee
jnp 0x3a925
movq %rbx, %rdi
callq 0x18510
movabsq $0x100000000100, %rax   # imm = 0x100000000100
orq %rax, 0x40(%rbx)
leaq 0x18653(%rip), %rax     # 0x52f5e
movq %rax, 0x138(%rbx)
movq 0x2df47(%rip), %rax     # 0x68860
movq %rbx, (%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x18670
movq %rbx, %rdi
popq %rbx
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: WriteEntFile
void WriteEntFile (char *mapname, char *entities)
{
	FILE	*fp;
	char	name[MAX_INFO_STRING];

	strcpy (name, gamedir->string);
	strcat (name, "/ent/");
	strcat (name, mapname);
	strcat (name, ".ent");

	fp = fopen (name, "wt");
	fwrite(entities, 1, strlen(entities), fp);
	fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2e569(%rip), %rax     # 0x68eb0
movq (%rax), %rax
movq 0x8(%rax), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x182a0
movq %r15, %rdi
callq 0x18680
movl $0x746e652f, (%rsp,%rax) # imm = 0x746E652F
movw $0x2f, 0x4(%rsp,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x19640
movq %r15, %rdi
callq 0x18680
movl $0x746e652e, (%rsp,%rax) # imm = 0x746E652E
movb $0x0, 0x4(%rsp,%rax)
leaq 0x1dbe2(%rip), %rsi     # 0x58577
movq %r15, %rdi
callq 0x19470
movq %rax, %r14
movq %rbx, %rdi
callq 0x18680
movl $0x1, %esi
movq %rbx, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x19710
movq %r14, %rdi
callq 0x185a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: ED_CallSpawn
void ED_CallSpawn (edict_t *ent)
{
	spawn_t	*s;
	gitem_t	*item;
	int		i;

	if (!ent->classname)
	{
		gi.dprintf ("ED_CallSpawn: NULL classname\n");
		return;
	}

	// check item spawn functions
	for (i=0,item=itemlist ; i<game.num_items ; i++,item++)
	{
		if (!item->classname)
			continue;
		if (!strcmp(item->classname, ent->classname))
		{	// found it
			SpawnItem (ent, item);
			return;
		}
	}

	// check normal spawn functions
	for (s=spawns ; s->name ; s++)
	{
		if (!strcmp(s->name, ent->classname))
		{	// found it
			s->spawn (ent);
			return;
		}
	}
	gi.dprintf ("%s doesn't have a spawn function\n", ent->classname);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x138(%rdi), %rbx
testq %rbx, %rbx
je 0x3ac8a
movq %rdi, %r14
movq 0x2e13a(%rip), %rax     # 0x68d40
movl 0x61c(%rax), %ebp
testl %ebp, %ebp
jle 0x3ac36
movq 0x2e229(%rip), %r15     # 0x68e40
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3ac2b
movq %rbx, %rsi
callq 0x18b20
testl %eax, %eax
je 0x3acaa
addq $0x88, %r15
decl %ebp
jne 0x3ac17
movq 0x2e123(%rip), %rax     # 0x68d60
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3ac67
addq $0x10, %rax
movq %rax, %r15
movq %rbx, %rsi
callq 0x18b20
testl %eax, %eax
je 0x3acbf
movq %r15, %rax
movq (%r15), %rdi
addq $0x10, %rax
testq %rdi, %rdi
jne 0x3ac49
movq 0x2d992(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x1da19(%rip), %rdi     # 0x58692
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
movq 0x2d96f(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x1d9d8(%rip), %rdi     # 0x58674
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18ec0
movq %r14, %rdi
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *-0x8(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: ED_NewString
char *ED_NewString (char *string)
{
	char	*newb, *new_p;
	int		i;
	int		len;
	
	len = (int)strlen(string) + 1;

	newb = gi.TagMalloc (len, TAG_LEVEL);

	new_p = newb;

	for (i=0 ; i< len ; i++)
	{
		if (string[i] == '\\' && i < len-1)
		{
			i++;
			if (string[i] == 'n')
				*new_p++ = '\n';
			else
				*new_p++ = '\\';
		}
		else
			*new_p++ = string[i];
	}
	
	return newb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x18680
movq %rax, %r14
leal 0x1(%rax), %edi
movq 0x2d915(%rip), %rax     # 0x68600
movl $0x2fe, %esi            # imm = 0x2FE
callq *0x108(%rax)
testl %r14d, %r14d
js 0x3ad42
xorl %esi, %esi
movl $0xa, %ecx
movq %rax, %rdx
movslq %esi, %r8
movb (%rbx,%r8), %dil
cmpb $0x5c, %dil
setne %r9b
cmpl %r14d, %r8d
setge %r10b
orb %r9b, %r10b
jne 0x3ad32
cmpb $0x6e, 0x1(%rbx,%r8)
leaq 0x1(%r8), %rsi
movl $0x5c, %edi
cmovel %ecx, %edi
movb %dil, (%rdx)
incq %rdx
leal 0x1(%rsi), %edi
cmpl %r14d, %esi
movl %edi, %esi
jl 0x3ad05
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: ED_ParseEdict
char *ED_ParseEdict (char *data, edict_t *ent)
{
	qboolean	init;
	char		keyname[MAX_INFO_STRING];
	char		*com_token;

	init = false;
	memset (&st, 0, sizeof(st));

// go through all the dictionary pairs
	while (1)
	{	
	// parse key
		com_token = COM_Parse (&data);
		if (com_token[0] == '}')
			break;
		if (!data)
			gi.error ("ED_ParseEntity: EOF without closing brace");

		strncpy (keyname, com_token, sizeof(keyname)-1);
		
	// parse value	
		com_token = COM_Parse (&data);
		if (!data)
			gi.error ("ED_ParseEntity: EOF without closing brace");

		if (com_token[0] == '}')
			gi.error ("ED_ParseEntity: closing brace without data");

		init = true;	

	// keynames with a leading underscore are used for utility comments,
	// and are immediately discarded by quake
		if (keyname[0] == '_')
			continue;

		ED_ParseField (keyname, com_token, ent);
	}

	if (!init)
		memset (ent, 0, sizeof(*ent));

	return data;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
xorps %xmm0, %xmm0
movq 0x2d76b(%rip), %rcx     # 0x68668
movups %xmm0, (%rcx)
movups %xmm0, 0x10(%rcx)
movups %xmm0, 0x20(%rcx)
movups %xmm0, 0x30(%rcx)
movups %xmm0, 0x40(%rcx)
movups %xmm0, 0x50(%rcx)
movq %rax, %rdi
callq 0x19190
cmpb $0x7d, (%rax)
jne 0x3af35
movl $0x4a8, %edx            # imm = 0x4A8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x18880
jmp 0x3afc5
movq %rax, %rbp
movq 0x2d6c1(%rip), %r13     # 0x68600
leaq 0x1d7d4(%rip), %r14     # 0x5871a
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq $0x0, 0x8(%rsp)
jne 0x3af61
movq %r14, %rdi
xorl %eax, %eax
callq *0x38(%r13)
movl $0x1ff, %edx            # imm = 0x1FF
movq %r15, %rdi
movq %rbp, %rsi
callq 0x181c0
movq %r12, %rdi
callq 0x19190
movq %rax, %rbp
cmpq $0x0, 0x8(%rsp)
jne 0x3af8d
movq %r14, %rdi
xorl %eax, %eax
callq *0x38(%r13)
cmpb $0x7d, (%rbp)
jne 0x3afa0
leaq 0x1d7aa(%rip), %rdi     # 0x58744
xorl %eax, %eax
callq *0x38(%r13)
cmpb $0x5f, 0x10(%rsp)
je 0x3afb5
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x18920
movq %r12, %rdi
callq 0x19190
movq %rax, %rbp
cmpb $0x7d, (%rax)
jne 0x3af50
movq 0x8(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_spawn.c
// Function: G_FindTeams
void G_FindTeams (void)
{
	edict_t	*e, *e2, *chain;
	int		i, j;
	int		c, c2;

	c = 0;
	c2 = 0;
	for (i=1, e=g_edicts+i ; i < globals.num_edicts ; i++,e++)
	{
		if (!e->inuse)
			continue;
		if (!e->team)
			continue;
		if (e->flags & FL_TEAMSLAVE)
			continue;
		chain = e;
		e->teammaster = e;
		c++;
		c2++;
		for (j=i+1, e2=e+1 ; j < globals.num_edicts ; j++,e2++)
		{
			if (!e2->inuse)
				continue;
			if (!e2->team)
				continue;
			if (e2->flags & FL_TEAMSLAVE)
				continue;
			if (!strcmp(e->team, e2->team))
			{
				c2++;
				chain->teamchain = e2;
				e2->teammaster = e;
				chain = e2;
				e2->flags |= FL_TEAMSLAVE;
			}
		}
	}

	gi.dprintf ("%i teams with %i entities\n", c, c2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x2db17(%rip), %rax     # 0x68b08
movl 0x8c(%rax), %ecx
xorl %esi, %esi
movl $0x0, %edx
cmpl $0x2, %ecx
jl 0x3b10f
movq 0x2d54a(%rip), %rax     # 0x68558
movq (%rax), %rdi
leal -0x2(%rcx), %r15d
movl $0x1, %r13d
xorl %edx, %edx
xorl %esi, %esi
movq %rcx, 0x20(%rsp)
movq %rdi, %rbp
addq $0x4a8, %rdi            # imm = 0x4A8
cmpl $0x0, 0x508(%rbp)
je 0x3b100
movq 0x610(%rbp), %r14
testq %r14, %r14
je 0x3b100
testb $0x4, 0x5c5(%rbp)
jne 0x3b100
movq %rdi, 0x778(%rbp)
incl %esi
incl %edx
leal 0x1(%r13), %eax
cmpl %ecx, %eax
jge 0x3b100
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
addq $0x950, %rbp            # imm = 0x950
movl %r15d, %r12d
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
cmpl $0x0, 0x60(%rbp)
je 0x3b0e2
movq 0x168(%rbp), %rsi
testq %rsi, %rsi
je 0x3b0e2
movl 0x11c(%rbp), %ebx
btl $0xa, %ebx
jb 0x3b0e2
movq %r14, %rdi
callq 0x18b20
testl %eax, %eax
jne 0x3b0e2
incl 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rbp, 0x2c8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x2d0(%rbp)
orl $0x400, %ebx            # imm = 0x400
movl %ebx, 0x11c(%rbp)
movq %rbp, 0x18(%rsp)
addq $0x4a8, %rbp            # imm = 0x4A8
decl %r12d
jne 0x3b08b
movl 0x8(%rsp), %edx
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdi
incl %r13d
decl %r15d
cmpl %ecx, %r13d
jne 0x3b024
movq 0x2d4ea(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x1d64e(%rip), %rdi     # 0x5876f
xorl %eax, %eax
addq $0x28, %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_spawn.c
// Function: putonfloor
void putonfloor (edict_t *ent)
{
	trace_t		tr;
	vec3_t		dest;
	float		*v;

	v = tv(0,0,-128);
	VectorAdd (ent->s.origin, v, dest);

	tr = gi.trace (ent->s.origin, ent->mins, ent->maxs, dest, ent, MASK_SOLID);
	if (tr.startsolid)
	{
		// If we start solid, don't move us
		return;
	}

	VectorCopy (tr.endpos, ent->s.origin);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movss 0x18317(%rip), %xmm2    # 0x5345c
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x19510
leaq 0x4(%rbx), %rsi
movsd 0x4(%rbx), %xmm0
movsd (%rax), %xmm1
addps %xmm0, %xmm1
leaq 0x10(%rsp), %r8
movlps %xmm1, (%r8)
movss 0xc(%rbx), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%r8)
movq 0x2d480(%rip), %rax     # 0x68600
leaq 0xcc(%rbx), %rdx
leaq 0xd8(%rbx), %rcx
movl $0x3, (%rsp)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %r9
callq *0x60(%rax)
cmpl $0x0, 0x4(%r14)
jne 0x3b1bf
movsd 0x2c(%rsp), %xmm0
movss 0x34(%rsp), %xmm1
movlps %xmm0, 0x4(%rbx)
movss %xmm1, 0xc(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_svcmds.c
// Function: SV_FilterPacket
qboolean SV_FilterPacket (char *from)
{
	int		i;
	unsigned	in;
	byte m[4] = { 0 };
	char *p;

	i = 0;
	p = from;
	while (*p && i < 4) {
		m[i] = 0;
		while (*p >= '0' && *p <= '9') {
			m[i] = m[i]*10 + (*p - '0');
			p++;
		}
		if (!*p || *p == ':')
			break;
		i++, p++;
	}
	
	memcpy(&in, m, sizeof in);

	for (i=0 ; i<numipfilters ; i++)
		if ( (in & ipfilters[i].mask) == ipfilters[i].compare)
			return (int)filterban->value;

	return (int)!filterban->value;
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpb $0x0, (%rdi)
je 0x3b64a
xorl %eax, %eax
movb $0x0, -0x4(%rsp,%rax)
movb (%rdi), %cl
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x3b622
xorl %edx, %edx
movzbl %dl, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
addb %cl, %dl
addb $-0x30, %dl
movb %dl, -0x4(%rsp,%rax)
movb 0x1(%rdi), %cl
incq %rdi
leal -0x30(%rcx), %esi
cmpb $0xa, %sil
jb 0x3b602
testb %cl, %cl
je 0x3b644
movzbl %cl, %ecx
cmpl $0x3a, %ecx
je 0x3b644
cmpb $0x0, 0x1(%rdi)
je 0x3b644
leaq 0x1(%rax), %rcx
incq %rdi
cmpq $0x3, %rax
movq %rcx, %rax
jb 0x3b5f1
movl -0x4(%rsp), %eax
jmp 0x3b64c
xorl %eax, %eax
movq 0x2d15d(%rip), %rcx     # 0x687b0
movslq (%rcx), %rcx
testq %rcx, %rcx
jle 0x3b677
xorl %edx, %edx
movq 0x2d744(%rip), %rsi     # 0x68da8
movl (%rsi,%rdx,8), %edi
andl %eax, %edi
cmpl 0x4(%rsi,%rdx,8), %edi
je 0x3b692
incq %rdx
cmpq %rdx, %rcx
jne 0x3b664
movq 0x2d752(%rip), %rax     # 0x68dd0
movq (%rax), %rax
xorps %xmm0, %xmm0
cmpeqss 0x20(%rax), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
retq
movq 0x2d737(%rip), %rax     # 0x68dd0
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_svcmds.c
// Function: SVCmd_AddIP_f
void SVCmd_AddIP_f (void)
{
	int		i;
	
	if (gi.argc() < 3) {
		gi.cprintf(NULL, PRINT_HIGH, "Usage:  addip <ip-mask>\n");
		return;
	}

	for (i=0 ; i<numipfilters ; i++)
		if (ipfilters[i].compare == 0xffffffff)
			break;		// free spot
	if (i == numipfilters)
	{
		if (numipfilters == MAX_IPFILTERS)
		{
			gi.cprintf (NULL, PRINT_HIGH, "IP filter list is full\n");
			return;
		}
		numipfilters++;
	}
	
	if (!StringToFilter (gi.argv(2), &ipfilters[i]))
		ipfilters[i].compare = 0xffffffff;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x2cf53(%rip), %rbx     # 0x68600
callq *0x138(%rbx)
cmpl $0x3, %eax
jge 0x3b6c5
movq 0x10(%rbx), %rcx
leaq 0x1d8cb(%rip), %rdx     # 0x58f8e
jmp 0x3b709
movq 0x2d0e4(%rip), %rax     # 0x687b0
movl (%rax), %ecx
xorl %r14d, %r14d
testl %ecx, %ecx
jle 0x3b6f1
movq 0x2d6cc(%rip), %rdx     # 0x68da8
cmpl $-0x1, 0x4(%rdx,%r14,8)
je 0x3b6f1
incq %r14
cmpq %r14, %rcx
jne 0x3b6dc
movl %ecx, %r14d
jmp 0x3b6f6
cmpl %ecx, %r14d
jne 0x3b71f
cmpl $0x400, %ecx            # imm = 0x400
jne 0x3b71b
movq 0x10(%rbx), %rcx
leaq 0x1d89e(%rip), %rdx     # 0x58fa7
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
incl %ecx
movl %ecx, (%rax)
movl $0x2, %edi
callq *0x140(%rbx)
movl %r14d, %ebx
shlq $0x3, %rbx
addq 0x2d670(%rip), %rbx     # 0x68da8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3b756
testl %eax, %eax
jne 0x3b74e
movl $0xffffffff, 0x4(%rbx)  # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_svcmds.c
// Function: StringToFilter
static qboolean StringToFilter (char *s, ipfilter_t *f)
{
	char	num[128];
	int		i, j;
	byte	b[4];
	byte	m[4];
	
	for (i=0 ; i<4 ; i++)
	{
		b[i] = 0;
		m[i] = 0;
	}
	
	for (i=0 ; i<4 ; i++)
	{
		if (*s < '0' || *s > '9')
		{
			gi.cprintf(NULL, PRINT_HIGH, "Bad filter address: %s\n", s);
			return false;
		}
		
		j = 0;
		while (*s >= '0' && *s <= '9')
		{
			num[j++] = *s++;
		}
		num[j] = 0;
		b[i] = atoi(num);
		if (b[i] != 0)
			m[i] = 255;

		if (!*s)
			break;
		s++;
	}
	
	memcpy(&f->mask, m, sizeof f->mask);
	memcpy(&f->compare, b, sizeof f->compare);

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movl %r12d, 0xc(%rsp)
movl %r12d, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movb (%rbx), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jb 0x3b7f1
xorl %r13d, %r13d
movb %al, 0x10(%rsp,%r13)
movb 0x1(%rbx,%r13), %al
incq %r13
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0x3b78b
movl %r13d, %eax
movb $0x0, 0x10(%rsp,%rax)
movq %r15, %rdi
callq 0x195e0
movb %al, 0xc(%rsp,%r12)
testb %al, %al
je 0x3b7bf
movb $-0x1, 0x8(%rsp,%r12)
cmpb $0x0, (%rbx,%r13)
je 0x3b7da
leaq 0x1(%r12), %rax
addq %r13, %rbx
incq %rbx
cmpq $0x3, %r12
movq %rax, %r12
jb 0x3b77e
movl 0x8(%rsp), %eax
movl %eax, (%r14)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%r14)
movl $0x1, %r14d
jmp 0x3b812
movq 0x2ce08(%rip), %r8      # 0x68600
leaq 0x1d917(%rip), %rdx     # 0x59116
xorl %r14d, %r14d
xorl %edi, %edi
movl $0x2, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq *0x10(%r8)
movl %r14d, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_svcmds.c
// Function: SVCmd_RemoveIP_f
void SVCmd_RemoveIP_f (void)
{
	ipfilter_t	f;
	int			i, j;

	if (gi.argc() < 3) {
		gi.cprintf(NULL, PRINT_HIGH, "Usage:  sv removeip <ip-mask>\n");
		return;
	}

	if (!StringToFilter (gi.argv(2), &f))
		return;

	for (i=0 ; i<numipfilters ; i++)
		if (ipfilters[i].mask == f.mask
		&& ipfilters[i].compare == f.compare)
		{
			for (j=i+1 ; j<numipfilters ; j++)
				ipfilters[j-1] = ipfilters[j];
			numipfilters--;
			gi.cprintf (NULL, PRINT_HIGH, "Removed.\n");
			return;
		}
	gi.cprintf (NULL, PRINT_HIGH, "Didn't find %s.\n", gi.argv(2));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x2cdcf(%rip), %rbx     # 0x68600
callq *0x138(%rbx)
cmpl $0x2, %eax
jg 0x3b859
movq 0x10(%rbx), %rcx
leaq 0x1d778(%rip), %rdx     # 0x58fbf
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movl $0x2, %edi
callq *0x140(%rbx)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3b756
testl %eax, %eax
je 0x3b8d6
movq 0x2cf36(%rip), %rax     # 0x687b0
movslq (%rax), %rsi
testq %rsi, %rsi
jle 0x3b8a7
movl (%rsp), %edi
movl 0x4(%rsp), %r8d
xorl %ecx, %ecx
movq 0x2d515(%rip), %rdx     # 0x68da8
cmpl %edi, (%rdx,%rcx,8)
jne 0x3b89f
cmpl %r8d, 0x4(%rdx,%rcx,8)
je 0x3b8de
incq %rcx
cmpq %rcx, %rsi
jne 0x3b893
movq 0x10(%rbx), %r14
movl $0x2, %edi
callq *0x140(%rbx)
leaq 0x1d72b(%rip), %rdx     # 0x58fe8
xorl %edi, %edi
movl $0x2, %esi
movq %rax, %rcx
xorl %eax, %eax
movq %r14, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%r8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leal 0x1(%rcx), %r8d
leal -0x1(%rsi), %edi
cmpl %esi, %r8d
jge 0x3b8fd
movl %edi, %esi
movq 0x8(%rdx,%rcx,8), %r8
movq %r8, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rsi
jne 0x3b8ec
movl %edi, (%rax)
movq 0x10(%rbx), %rcx
leaq 0x1d6d4(%rip), %rdx     # 0x58fde
jmp 0x3b847
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_svcmds.c
// Function: SVCmd_ListIP_f
void SVCmd_ListIP_f(void)
{
	int		i, j;
	byte	b[4];

	gi.cprintf(NULL, PRINT_HIGH, "Filter list:\n");
	for (i = 0; i < numipfilters; i++)
	{
		for (j = 0; j < sizeof b; j++)
		{
			b[j] = (ipfilters[i].compare >> (j * 8)) & 0xff;
		}
		gi.cprintf(NULL, PRINT_HIGH, "%3i.%3i.%3i.%3i\n", b[0], b[1], b[2], b[3]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x2ccdc(%rip), %r14     # 0x68600
leaq 0x1d6ce(%rip), %rdx     # 0x58ff9
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%r14)
movq 0x2ce71(%rip), %r15     # 0x687b0
cmpl $0x0, (%r15)
jle 0x3b9ac
movq 0x2d45c(%rip), %r12     # 0x68da8
leaq 0x14(%rsp), %r13
leaq 0x1d6af(%rip), %rbx     # 0x59007
xorl %ebp, %ebp
movl 0x4(%r12,%rbp,8), %eax
movq %r13, %rdx
xorl %ecx, %ecx
movl %eax, %esi
shrl %cl, %esi
movb %sil, (%rdx)
addq $0x8, %rcx
incq %rdx
cmpq $0x20, %rcx
jne 0x3b964
movzbl 0x14(%rsp), %ecx
movzbl 0x15(%rsp), %r8d
movzbl 0x16(%rsp), %r9d
movzbl 0x17(%rsp), %eax
movl %eax, (%rsp)
xorl %edi, %edi
movl $0x2, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq *0x10(%r14)
incq %rbp
movslq (%r15), %rax
cmpq %rax, %rbp
jl 0x3b95a
addq $0x18, %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_svcmds.c
// Function: SVCmd_WriteIP_f
void SVCmd_WriteIP_f (void)
{
	FILE* f;
	char	name[MAX_OSPATH];
	byte	b[4];
	int		i, j;

	if (gamedir->string && gamedir->string[0])
		sprintf(name, "./%s/listip.cfg", gamedir->string);
	else
		sprintf(name, "./listip.cfg");

	gi.cprintf(NULL, PRINT_HIGH, "Writing %s.\n", name);

	f = fopen(name, "wb");
	if (!f)
	{
		gi.cprintf(NULL, PRINT_HIGH, "Couldn't open %s\n", name);
		return;
	}

	fprintf(f, "set filterban %d\n", (int)filterban->value);

	for (i = 0; i < numipfilters; i++)
	{
		for (j = 0; j < sizeof b; j++)
		{
			b[j] = (ipfilters[i].compare >> (j * 8)) & 0xff;
		}
		fprintf(f, "sv addip %u.%u.%u.%u\n", b[0], b[1], b[2], b[3]);
	}

	fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0x2d4dd(%rip), %rax     # 0x68eb0
movq (%rax), %rax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x3b9f9
cmpb $0x0, (%rdx)
je 0x3b9f9
leaq 0x1d62d(%rip), %rsi     # 0x59018
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x196f0
jmp 0x3ba17
movabsq $0x6766632e706974, %rax # imm = 0x6766632E706974
movq %rax, 0x15(%rsp)
movabsq $0x70697473696c2f2e, %rax # imm = 0x70697473696C2F2E
movq %rax, 0x10(%rsp)
movq 0x2cbe2(%rip), %r14     # 0x68600
leaq 0x1d610(%rip), %rdx     # 0x59035
leaq 0x10(%rsp), %rbx
xorl %edi, %edi
movl $0x2, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq *0x10(%r14)
leaq 0x1b87f(%rip), %rsi     # 0x572c0
movq %rbx, %rdi
callq 0x19470
testq %rax, %rax
je 0x3baed
movq %rax, %rbx
movq 0x2d374(%rip), %rax     # 0x68dd0
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x1d5e9(%rip), %rsi     # 0x59054
movq %rbx, %rdi
xorl %eax, %eax
callq 0x18bf0
movq 0x2cd34(%rip), %r15     # 0x687b0
cmpl $0x0, (%r15)
jle 0x3bae3
movq 0x2d31f(%rip), %r12     # 0x68da8
leaq 0xc(%rsp), %r13
leaq 0x1d5d1(%rip), %r14     # 0x59066
xorl %ebp, %ebp
movl 0x4(%r12,%rbp,8), %eax
movq %r13, %rdx
xorl %ecx, %ecx
movl %eax, %esi
shrl %cl, %esi
movb %sil, (%rdx)
addq $0x8, %rcx
incq %rdx
cmpq $0x20, %rcx
jne 0x3baa1
movzbl 0xc(%rsp), %edx
movzbl 0xd(%rsp), %ecx
movzbl 0xe(%rsp), %r8d
movzbl 0xf(%rsp), %r9d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x18bf0
incq %rbp
movslq (%r15), %rax
cmpq %rax, %rbp
jl 0x3ba97
movq %rbx, %rdi
callq 0x185a0
jmp 0x3bb06
leaq 0x1d54e(%rip), %rdx     # 0x59042
leaq 0x10(%rsp), %rcx
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%r14)
addq $0x98, %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_svcmds.c
// Function: SVCmd_QuadTime_f
void SVCmd_QuadTime_f(void)
{
        unsigned long i=0;
        gitem_t * target = NULL;

        if (gi.argc() < 3) {
                gi.cprintf(NULL, PRINT_HIGH, "Usage:  sv quadtime <seconds>\n");
                return;
        }

        if (!sscanf(gi.argv(2), "%lu", &i))
        {
	        gi.cprintf(NULL, PRINT_HIGH, "Usage: sv quadtime <seconds>\n");

                return;
        }

        target = FindItem("Quad Damage");
        if (target && i > 0 && i < 1200) {
                target->quantity = i;
		char buffer[MAX_INFO_STRING];
		sprintf(buffer, "Quad respawn updated to %lu\n", i);
		ctf_BSafePrint(PRINT_HIGH, buffer);
        }
}

// Assembly:
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq $0x0, 0x8(%rsp)
movq 0x2cad0(%rip), %rbx     # 0x68600
callq *0x138(%rbx)
cmpl $0x2, %eax
jg 0x3bb59
movq 0x10(%rbx), %rcx
leaq 0x1d536(%rip), %rdx     # 0x5907c
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
jmpq *%rcx
movl $0x2, %edi
callq *0x140(%rbx)
leaq 0x17254(%rip), %rsi     # 0x52dbf
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x18fe0
testl %eax, %eax
je 0x3bbd5
leaq 0x16c12(%rip), %rdi     # 0x52797
callq 0x189e0
testq %rax, %rax
setne %cl
movq 0x8(%rsp), %rdx
leaq -0x1(%rdx), %rsi
cmpq $0x4af, %rsi            # imm = 0x4AF
setb %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x3bbe8
movl %edx, 0x5c(%rax)
leaq 0x1d502(%rip), %rsi     # 0x590b9
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x196f0
movl $0x2, %edi
movq %rbx, %rsi
callq 0x19270
jmp 0x3bbe8
leaq 0x1d4bf(%rip), %rdx     # 0x5909b
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%rbx)
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_svcmds.c
// Function: ServerCommand
void	ServerCommand (void)
{
	char	*cmd;

	cmd = gi.argv(1);
	if (Q_stricmp (cmd, "test") == 0)
		Svcmd_Test_f ();
	else if (Q_stricmp (cmd, "addip") == 0)
		SVCmd_AddIP_f ();
	else if (Q_stricmp (cmd, "removeip") == 0)
		SVCmd_RemoveIP_f ();
	else if (Q_stricmp (cmd, "listip") == 0)
		SVCmd_ListIP_f ();
	else if (Q_stricmp (cmd, "writeip") == 0)
		SVCmd_WriteIP_f ();
	else if (Q_stricmp (cmd, "quadtime") == 0)
		SVCmd_QuadTime_f ();
	else if ((Q_stricmp (cmd, "next") == 0) || (Q_stricmp (cmd, "skip") == 0))
		Svcmd_NextLevel_f ();
	else
		gi.cprintf (NULL, PRINT_HIGH, "Unknown server command \"%s\"\n", cmd);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x2ca04(%rip), %r14     # 0x68600
movl $0x1, %edi
callq *0x140(%r14)
movq %rax, %rbx
leaq 0x19d27(%rip), %rsi     # 0x55939
movq %rax, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bce0
leaq 0x1d4ad(%rip), %rsi     # 0x590d6
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bcfd
leaq 0x1d49c(%rip), %rsi     # 0x590dc
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bd09
leaq 0x1d48e(%rip), %rsi     # 0x590e5
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bd15
leaq 0x1d47e(%rip), %rsi     # 0x590ec
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bd21
leaq 0x19da1(%rip), %rsi     # 0x55a26
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bd48
leaq 0x19de0(%rip), %rsi     # 0x55a7c
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bd2d
leaq 0x1d441(%rip), %rsi     # 0x590f4
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3bd2d
movq 0x10(%r14), %r8
leaq 0x1d42f(%rip), %rdx     # 0x590f9
xorl %edi, %edi
movl $0x2, %esi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%r8
movq 0x10(%r14), %rcx
leaq 0x1d27b(%rip), %rdx     # 0x58f66
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19890
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18ac0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18810
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x198f0
callq 0x188c0
movq 0x8(%r14), %rcx
leaq 0x1d239(%rip), %rdi     # 0x58f76
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18550
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: Use_Target_Tent
void Use_Target_Tent (edict_t *ent, edict_t *other, edict_t *activator)
{
	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (ent->style);
	gi.WritePosition (ent->s.origin);
	gi.multicast (ent->s.origin, MULTICAST_PVS);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2c89e(%rip), %r14     # 0x68600
movl $0x3, %edi
callq *0xc8(%r14)
movl 0x32c(%rbx), %edi
callq *0xc8(%r14)
addq $0x4, %rbx
movq %rbx, %rdi
callq *0xf0(%r14)
movq 0xb0(%r14), %rax
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: Use_Target_Speaker
void Use_Target_Speaker (edict_t *ent, edict_t *other, edict_t *activator)
{
	int		chan;

	if (ent->spawnflags & 3)
	{	// looping sound toggles
		if (ent->s.sound)
			ent->s.sound = 0;	// turn it off
		else
			ent->s.sound = ent->noise_index;	// start it
	}
	else
	{	// normal sound
		if (ent->spawnflags & 4)
			chan = CHAN_VOICE|CHAN_RELIABLE;
		else
			chan = CHAN_VOICE;
		// use a positioned_sound, because this entity won't normally be
		// sent to any clients because it is invisible
		gi.positioned_sound (ent->s.origin, ent, chan, ent->noise_index, ent->volume, ent->attenuation, 0);
	}
}

// Assembly:
movq %rdi, %rsi
movl 0x140(%rdi), %eax
testb $0x3, %al
je 0x3bdcb
cmpl $0x0, 0x4c(%rsi)
je 0x3bdff
movl $0x0, 0x4c(%rsi)
retq
andl $0x4, %eax
leal 0x2(,%rax,4), %edx
movq 0x2c824(%rip), %rax     # 0x68600
movq 0x28(%rax), %rax
leaq 0x4(%rsi), %rdi
movl 0x2e8(%rsi), %ecx
movss 0x2f0(%rsi), %xmm0
movss 0x2f4(%rsi), %xmm1
xorps %xmm2, %xmm2
jmpq *%rax
movl 0x2e8(%rsi), %eax
movl %eax, 0x4c(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_speaker
void SP_target_speaker (edict_t *ent)
{
	char	buffer[MAX_QPATH];

	if(!st.noise)
	{
		gi.dprintf("target_speaker with no noise set at %s\n", vtos(ent->s.origin));
		return;
	}
	if (!strstr (st.noise, ".wav"))
		Com_sprintf (buffer, sizeof(buffer), "%s.wav", st.noise);
	else
		strncpy (buffer, st.noise, sizeof buffer - 1);
	ent->noise_index = gi.soundindex (buffer);

	if (!ent->volume)
		ent->volume = 1.0;

	if (!ent->attenuation)
		ent->attenuation = 1.0;
	else if (ent->attenuation == -1)	// use -1 so 0 defaults to 1
		ent->attenuation = 0;

	// check for prestarted looping sound
	if (ent->spawnflags & 1)
		ent->s.sound = ent->noise_index;

	ent->use = Use_Target_Speaker;

	// must link the entity so we get areas and clusters so
	// the server can determine who to send updates to
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x2c84e(%rip), %rax     # 0x68668
movq 0x30(%rax), %r14
testq %r14, %r14
je 0x3be49
leaq 0x17cf2(%rip), %rsi     # 0x53b1c
movq %r14, %rdi
callq 0x19980
testq %rax, %rax
je 0x3be78
movq %rsp, %rdi
movl $0x3f, %edx
movq %r14, %rsi
callq 0x181c0
jmp 0x3be91
movq 0x2c7b0(%rip), %rax     # 0x68600
movq 0x8(%rax), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x190a0
leaq 0x1d2e1(%rip), %rdi     # 0x59148
movq %rax, %rsi
xorl %eax, %eax
movq %r14, %rcx
addq $0x48, %rsp
popq %rbx
popq %r14
jmpq *%rcx
leaq 0x187d0(%rip), %rdx     # 0x5464f
movq %rsp, %rdi
movl $0x40, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x18e10
movq 0x2c768(%rip), %r14     # 0x68600
movq %rsp, %rdi
callq *0x48(%r14)
movl %eax, 0x2e8(%rbx)
movss 0x2f0(%rbx), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x3bec1
jp 0x3bec1
movl $0x3f800000, 0x2f0(%rbx) # imm = 0x3F800000
movss 0x2f4(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jne 0x3bed0
jnp 0x3bedd
ucomiss 0x19d7d(%rip), %xmm1    # 0x55c54
jne 0x3beed
jnp 0x3bee5
jmp 0x3beed
movss 0x17043(%rip), %xmm0    # 0x52f28
movss %xmm0, 0x2f4(%rbx)
testb $0x1, 0x140(%rbx)
je 0x3bef9
movl %eax, 0x4c(%rbx)
movq 0x2c4d0(%rip), %rax     # 0x683d0
movq %rax, 0x228(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_help
void SP_target_help(edict_t *ent)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (ent);
		return;
	}

	if (!ent->message)
	{
		gi.dprintf ("%s with no message at %s\n", ent->classname, vtos(ent->s.origin));
		G_FreeEdict (ent);
		return;
	}
	ent->use = Use_Target_Help;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2cf62(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3bf70
jnp 0x3bf7d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
cmpq $0x0, 0x130(%rbx)
je 0x3bf9b
movq 0x2cd62(%rip), %rax     # 0x68cf0
movq %rax, 0x228(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2c65e(%rip), %rax     # 0x68600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1d1b3(%rip), %rdi     # 0x59170
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
jmp 0x3bf70
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_secret
void use_target_secret (edict_t *ent, edict_t *other, edict_t *activator)
{
	gi.sound (ent, CHAN_VOICE, ent->noise_index, 1, ATTN_NORM, 0);

	level.found_secrets++;

	G_UseTargets (ent, activator);
	G_FreeEdict (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x2c625(%rip), %rax     # 0x68600
movl 0x2e8(%rdi), %edx
movss 0x16f3f(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movl $0x2, %esi
movaps %xmm0, %xmm1
callq *0x20(%rax)
movq 0x2cda2(%rip), %rax     # 0x68da0
incl 0x134(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x198e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_secret
void SP_target_secret (edict_t *ent)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (ent);
		return;
	}

	ent->use = use_target_secret;
	if (!st.noise)
		st.noise = "misc/secret.wav";
	ent->noise_index = gi.soundindex (st.noise);
	ent->svflags = SVF_NOCLIENT;
	level.total_secrets++;
	// map bug hack
	if (!Q_stricmp(level.mapname, "mine3") && ent->s.origin[0] == 280 && ent->s.origin[1] == -2048 && ent->s.origin[2] == -624)
		ent->message = "You have found a secret area.";
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2ce97(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c03b
jnp 0x3c044
movq %rbx, %rdi
popq %rbx
jmp 0x19a50
movq 0x2cf45(%rip), %rax     # 0x68f90
movq %rax, 0x228(%rbx)
movq 0x2c60f(%rip), %rax     # 0x68668
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x3c06d
leaq 0x18102(%rip), %rdi     # 0x5416b
movq %rdi, 0x30(%rax)
movq 0x2c58c(%rip), %rax     # 0x68600
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movl $0x1, 0xc8(%rbx)
movq 0x2cd12(%rip), %rdi     # 0x68da0
incl 0x130(%rdi)
addq $0x48, %rdi
leaq 0x1d0eb(%rip), %rsi     # 0x5918a
callq 0x18690
testl %eax, %eax
je 0x3c0aa
popq %rbx
retq
movss 0x4(%rbx), %xmm0
ucomiss 0x1d07a(%rip), %xmm0    # 0x59130
jne 0x3c0a8
jp 0x3c0a8
movss 0x8(%rbx), %xmm0
ucomiss 0x1d06e(%rip), %xmm0    # 0x59134
jne 0x3c0a8
jp 0x3c0a8
movss 0xc(%rbx), %xmm0
ucomiss 0x1d062(%rip), %xmm0    # 0x59138
jne 0x3c0a8
jp 0x3c0a8
leaq 0x1d0af(%rip), %rax     # 0x59190
movq %rax, 0x130(%rbx)
jmp 0x3c0a8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_goal
void use_target_goal (edict_t *ent, edict_t *other, edict_t *activator)
{
	gi.sound (ent, CHAN_VOICE, ent->noise_index, 1, ATTN_NORM, 0);

	level.found_goals++;

	if (level.found_goals == level.total_goals)
		gi.configstring (CS_CDTRACK, "0");

	G_UseTargets (ent, activator);
	G_FreeEdict (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq 0x2c504(%rip), %r15     # 0x68600
movl 0x2e8(%rdi), %edx
movss 0x16e1e(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movl $0x2, %esi
movaps %xmm0, %xmm1
callq *0x20(%r15)
movq 0x2cc80(%rip), %rax     # 0x68da0
movl 0x13c(%rax), %ecx
incl %ecx
movl %ecx, 0x13c(%rax)
cmpl 0x138(%rax), %ecx
jne 0x3c146
leaq 0x1efaf(%rip), %rsi     # 0x5b0ec
movl $0x1, %edi
callq *0x30(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x198e0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_goal
void SP_target_goal (edict_t *ent)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (ent);
		return;
	}

	ent->use = use_target_goal;
	if (!st.noise)
		st.noise = "misc/secret.wav";
	ent->noise_index = gi.soundindex (st.noise);
	ent->svflags = SVF_NOCLIENT;
	level.total_goals++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2cd57(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c17b
jnp 0x3c184
movq %rbx, %rdi
popq %rbx
jmp 0x19a50
movq 0x2c545(%rip), %rax     # 0x686d0
movq %rax, 0x228(%rbx)
movq 0x2c4cf(%rip), %rax     # 0x68668
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x3c1ad
leaq 0x17fc2(%rip), %rdi     # 0x5416b
movq %rdi, 0x30(%rax)
movq 0x2c44c(%rip), %rax     # 0x68600
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movl $0x1, 0xc8(%rbx)
movq 0x2cbd2(%rip), %rax     # 0x68da0
incl 0x138(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_explosion_explode
void target_explosion_explode (edict_t *self)
{
	float		save;

	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (TE_EXPLOSION1);
	gi.WritePosition (self->s.origin);
	gi.multicast (self->s.origin, MULTICAST_PHS);

	T_RadiusDamage (self, self->activator, self->dmg, NULL, self->dmg+40, MOD_EXPLOSIVE);

	save = self->delay;
	self->delay = 0;
	G_UseTargets (self, self->activator);
	self->delay = save;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x2c417(%rip), %r15     # 0x68600
movl $0x3, %edi
callq *0xc8(%r15)
movl $0x5, %edi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
movq %r14, %rdi
movl $0x1, %esi
callq *0xb0(%r15)
movq 0x2b0(%rbx), %rsi
movl 0x280(%rbx), %eax
cvtsi2ss %eax, %xmm0
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
movq %rbx, %rdi
xorl %edx, %edx
movl $0x19, %ecx
callq 0x180c0
movss 0x2fc(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0x0, 0x2fc(%rbx)
movq 0x2b0(%rbx), %rsi
movq %rbx, %rdi
callq 0x198e0
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x2fc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_explosion
void use_target_explosion (edict_t *self, edict_t *other, edict_t *activator)
{
	self->activator = activator;

	if (!self->delay)
	{
		target_explosion_explode (self);
		return;
	}

	self->think = target_explosion_explode;
	self->nextthink = level.time + self->delay;
}

// Assembly:
movq %rdx, 0x2b0(%rdi)
movss 0x2fc(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c29d
jnp 0x3c2c0
movq 0x2c78c(%rip), %rax     # 0x68a30
movq %rax, 0x210(%rdi)
movq 0x2caee(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
retq
jmp 0x19af8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_changelevel
void use_target_changelevel (edict_t *self, edict_t *other, edict_t *activator)
{
	char message[MAX_INFO_STRING];

	if (level.intermissiontime)
		return;		// already activated

	if (!deathmatch->value && !coop->value)
	{
		if (g_edicts[1].health <= 0)
			return;
	}

	// if noexit, do a ton of damage to other
	if (deathmatch->value && !( (int)dmflags->value & DF_ALLOW_EXIT) && other != world)
	{
		T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, 10 * other->max_health, 1000, 0, MOD_EXIT);
		return;
	}

	// if multiplayer, let everyone know who hit the exit
	if (deathmatch->value)
	{
		if (activator && activator->client)
		{
			sprintf(message, "%s exited the level.\n", activator->client->pers.netname);
			ctf_BSafePrint(PRINT_HIGH, message);
		}
	}

	// if going to a new unit, clear cross triggers
	if (strstr(self->map, "*"))	
		game.serverflags &= ~(SFL_CROSS_TRIGGER_MASK);

	BeginIntermission (self);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq 0x2cab1(%rip), %rax     # 0x68da0
movss 0xc8(%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x3c410
jp 0x3c410
movq %rdi, %rbx
movq 0x2cbad(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm1
ucomiss %xmm0, %xmm1
jne 0x3c322
jnp 0x3c380
movq 0x2c2ef(%rip), %rax     # 0x68618
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
btl $0xc, %eax
jb 0x3c3ae
movq 0x2c21a(%rip), %rax     # 0x68558
cmpq %rsi, (%rax)
je 0x3c3ae
leaq 0x4(%rsi), %r8
movl 0x258(%rsi), %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
movq 0x2c40f(%rip), %rcx     # 0x68768
movq %rsi, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x1c
pushq $0x0
pushq $0x3e8                  # imm = 0x3E8
pushq %rax
callq 0x190f0
addq $0x228, %rsp            # imm = 0x228
jmp 0x3c417
movq 0x2cbd9(%rip), %rax     # 0x68f60
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c3e4
jp 0x3c3e4
movq 0x2c1b8(%rip), %rax     # 0x68558
movq (%rax), %rax
cmpl $0x0, 0x6fc(%rax)
jg 0x3c3e4
jmp 0x3c410
testq %rdx, %rdx
je 0x3c3e4
movq 0x58(%rdx), %rdx
testq %rdx, %rdx
je 0x3c3e4
addq $0x2c0, %rdx            # imm = 0x2C0
leaq 0x1cde4(%rip), %rsi     # 0x591ae
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x196f0
movl $0x2, %edi
movq %r14, %rsi
callq 0x19270
movq 0x270(%rbx), %rdi
movl $0x2a, %esi
callq 0x18730
testq %rax, %rax
je 0x3c408
movq 0x2c93f(%rip), %rax     # 0x68d40
movb $0x0, 0x618(%rax)
movq %rbx, %rdi
callq 0x18e50
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_changelevel
void SP_target_changelevel (edict_t *ent)
{
	if (!ent->map)
	{
		gi.dprintf("target_changelevel with no map at %s\n", vtos(ent->s.origin));
		G_FreeEdict (ent);
		return;
	}

	// ugly hack because *SOMEBODY* screwed up their map
   if((Q_stricmp(level.mapname, "fact1") == 0) && (Q_stricmp(ent->map, "fact3") == 0))
	   ent->map = "fact3$secret1";

	ent->use = use_target_changelevel;
	ent->svflags = SVF_NOCLIENT;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x270(%rdi)
je 0x3c48c
movq 0x2c96d(%rip), %rdi     # 0x68da0
addq $0x48, %rdi
leaq 0x1cdac(%rip), %rsi     # 0x591ea
callq 0x18690
testl %eax, %eax
jne 0x3c46c
movq 0x270(%rbx), %rdi
leaq 0x1cd9b(%rip), %rsi     # 0x591f0
callq 0x18690
testl %eax, %eax
jne 0x3c46c
leaq 0x1cd91(%rip), %rax     # 0x591f6
movq %rax, 0x270(%rbx)
movq 0x2c84d(%rip), %rax     # 0x68cc0
movq %rax, 0x228(%rbx)
movl $0x1, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2c16d(%rip), %rax     # 0x68600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1cd1d(%rip), %rdi     # 0x591c4
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_splash
void SP_target_splash (edict_t *self)
{
	self->use = use_target_splash;
	G_SetMovedir (self->s.angles, self->movedir);

	if (!self->count)
		self->count = 32;

	self->svflags = SVF_NOCLIENT;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2c185(%rip), %rax     # 0x68708
movq %rax, 0x228(%rdi)
addq $0x10, %rdi
leaq 0x19c(%rbx), %rsi
callq 0x19630
cmpl $0x0, 0x290(%rbx)
jne 0x3c5ad
movl $0x20, 0x290(%rbx)
movl $0x1, 0xc8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_spawner
void use_target_spawner (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t	*ent;

	ent = G_Spawn();
	ent->classname = self->target;
	VectorCopy (self->s.origin, ent->s.origin);
	VectorCopy (self->s.angles, ent->s.angles);
	ED_CallSpawn (ent);
	gi.unlinkentity (ent);
	KillBox (ent);
	gi.linkentity (ent);
	if (self->speed)
		VectorCopy (self->movedir, ent->velocity);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x19700
movq %rax, %r14
movq 0x150(%rbx), %rax
movq %rax, 0x138(%r14)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x4(%r14)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%r14)
movss 0xc(%rbx), %xmm0
movss %xmm0, 0xc(%r14)
movss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%r14)
movss 0x14(%rbx), %xmm0
movss %xmm0, 0x14(%r14)
movss 0x18(%rbx), %xmm0
movss %xmm0, 0x18(%r14)
movq %r14, %rdi
callq 0x19310
movq 0x2bfd8(%rip), %r15     # 0x68600
movq %r14, %rdi
callq *0x98(%r15)
movq %r14, %rdi
callq 0x18a90
movq %r14, %rdi
callq *0x90(%r15)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c656
jnp 0x3c689
movss 0x19c(%rbx), %xmm0
movss %xmm0, 0x1c0(%r14)
movss 0x1a0(%rbx), %xmm0
movss %xmm0, 0x1c4(%r14)
movss 0x1a4(%rbx), %xmm0
movss %xmm0, 0x1c8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_spawner
void SP_target_spawner (edict_t *self)
{
	self->use = use_target_spawner;
	self->svflags = SVF_NOCLIENT;
	if (self->speed)
	{
		G_SetMovedir (self->s.angles, self->movedir);
		VectorScale (self->movedir, self->speed, self->movedir);
	}
}

// Assembly:
movq 0x2c72a(%rip), %rax     # 0x68dc0
movq %rax, 0x228(%rdi)
movl $0x1, 0xc8(%rdi)
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c6b9
jnp 0x3c6ed
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
leaq 0x19c(%rbx), %r14
movq %r14, %rsi
callq 0x19630
movss 0x190(%rbx), %xmm0
movq %r14, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x189d0
retq