LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2a148(%rip), %rsi     # 0x7414f
callq 0x196a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4a036
movq 0x385e2(%rip), %rax     # 0x82600
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rsi
leaq 0x26e94(%rip), %rdi     # 0x70ec1
movb $0x0, %al
callq *%rcx
jmp 0x4a116
movl $0x4a8, -0xc(%rbp)      # imm = 0x4A8
movq -0x20(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x19960
movq 0x3862d(%rip), %rax     # 0x82688
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x19960
movq -0x20(%rbp), %rdi
callq 0x19ba0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x38a78(%rip), %rcx     # 0x82b08
cmpl 0x8c(%rcx), %eax
jge 0x4a0ef
movq 0x384b9(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x4a0c0
jmp 0x4a0e4
movq -0x20(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x19960
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x181f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4a086
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rcx
leaq -0xc(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x19960
movq -0x20(%rbp), %rdi
callq 0x18600
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x381ed(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4acf0
jp 0x4acf0
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4ad42
movq -0x8(%rbp), %rdi
callq 0x18550
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
leaq 0x25224(%rip), %rcx     # 0x6ff48
movq %rcx, 0x138(%rax)
movq -0x8(%rbp), %rcx
movq 0x37ac2(%rip), %rax     # 0x827f8
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x186d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3815d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4ad80
jp 0x4ad80
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4add2
movq -0x8(%rbp), %rdi
callq 0x18550
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
leaq 0x251a2(%rip), %rcx     # 0x6ff56
movq %rcx, 0x138(%rax)
movq -0x8(%rbp), %rcx
movq 0x37a9a(%rip), %rax     # 0x82860
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x186d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x220(%rbp), %rdi
movq 0x380af(%rip), %rax     # 0x82eb0
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0x182c0
leaq -0x220(%rbp), %rdi
leaq 0x2a456(%rip), %rsi     # 0x75271
callq 0x19880
leaq -0x220(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x19880
leaq -0x220(%rbp), %rdi
leaq 0x27166(%rip), %rsi     # 0x71fa4
callq 0x19880
leaq -0x220(%rbp), %rdi
leaq 0x2a426(%rip), %rsi     # 0x75277
callq 0x196a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rdi
callq 0x186e0
movq -0x228(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x19960
movq -0x18(%rbp), %rdi
callq 0x18600
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x138(%rax)
jne 0x4b1a2
leaq 0x2a1e3(%rip), %rdi     # 0x75374
movq 0x37468(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x8(%rcx)
jmp 0x4b28d
movl $0x0, -0x1c(%rbp)
movq 0x37c90(%rip), %rax     # 0x82e40
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movq 0x37b82(%rip), %rcx     # 0x82d40
cmpl 0x61c(%rcx), %eax
jge 0x4b21b
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4b1d2
jmp 0x4b202
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x4b200
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19040
jmp 0x4b28d
jmp 0x4b202
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x18(%rbp)
jmp 0x4b1b4
movq 0x37b3e(%rip), %rax     # 0x82d60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4b26c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x4b25c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x4b28d
jmp 0x4b25e
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0x4b226
movq 0x3738d(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rsi
leaq 0x2a109(%rip), %rdi     # 0x75392
movb $0x0, %al
callq *%rcx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x186e0
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq 0x3733e(%rip), %rax     # 0x82600
movq 0x108(%rax), %rax
movl -0x20(%rbp), %edi
movl $0x2fe, %esi            # imm = 0x2FE
callq *%rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4b37e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x4b352
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4b352
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6e, %eax
jne 0x4b33e
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0xa, (%rax)
jmp 0x4b350
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x5c, (%rax)
jmp 0x4b36e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x4b370
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b2e6
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x37027(%rip), %rdi     # 0x82668
xorl %esi, %esi
movl $0x60, %edx
callq 0x188f0
leaq -0x8(%rbp), %rdi
callq 0x19360
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
jne 0x4b671
jmp 0x4b723
cmpq $0x0, -0x8(%rbp)
jne 0x4b68b
leaq 0x29d9b(%rip), %rdi     # 0x7541a
movq 0x36f7a(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x38(%rcx)
leaq -0x220(%rbp), %rdi
movq -0x228(%rbp), %rsi
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x181e0
leaq -0x8(%rbp), %rdi
callq 0x19360
movq %rax, -0x228(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4b6cd
leaq 0x29d59(%rip), %rdi     # 0x7541a
movq 0x36f38(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x38(%rcx)
movq -0x228(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
jne 0x4b6ef
leaq 0x29d61(%rip), %rdi     # 0x75444
movq 0x36f16(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x38(%rcx)
movl $0x1, -0x14(%rbp)
movsbl -0x220(%rbp), %eax
cmpl $0x5f, %eax
jne 0x4b707
jmp 0x4b64d
leaq -0x220(%rbp), %rdi
movq -0x228(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x189b0
jmp 0x4b64d
cmpl $0x0, -0x14(%rbp)
jne 0x4b739
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x4a8, %edx            # imm = 0x4A8
callq 0x188f0
movq -0x8(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm1, %xmm1
movss 0x24b2e(%rip), %xmm2    # 0x70478
movaps %xmm1, %xmm0
callq 0x19740
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x68(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, -0x5c(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x68(%rbp), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x68(%rbp), %rax
addss 0x8(%rax), %xmm0
movss %xmm0, -0x54(%rbp)
movq 0x36c5f(%rip), %rax     # 0x82600
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movq -0x8(%rbp), %rdx
addq $0xcc, %rdx
movq -0x8(%rbp), %rcx
addq $0xd8, %rcx
leaq -0x5c(%rbp), %r8
movq -0x8(%rbp), %r9
leaq -0xb0(%rbp), %rdi
movl $0x3, (%rsp)
callq *%rax
leaq -0x50(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x48, %edx
callq 0x18dc0
cmpl $0x0, -0x4c(%rbp)
je 0x4b9f8
jmp 0x4ba22
movss -0x44(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x3c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x188f0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x4bf76
cmpl $0x4, -0x14(%rbp)
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4bf82
jmp 0x4c016
movslq -0x14(%rbp), %rax
movb $0x0, -0x1c(%rbp,%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x2a(%rbp)
jl 0x4bfac
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x4bfb5
jmp 0x4bfe5
movslq -0x14(%rbp), %rax
movzbl -0x1c(%rbp,%rax), %eax
imull $0xa, %eax, %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movb %al, %cl
movslq -0x14(%rbp), %rax
movb %cl, -0x1c(%rbp,%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4bf8b
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4bffa
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x4bffc
jmp 0x4c016
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4bf5b
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x36783(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jge 0x4c074
movl -0x18(%rbp), %eax
movslq -0x14(%rbp), %rdx
movq 0x36d69(%rip), %rcx     # 0x82da8
andl (%rcx,%rdx,8), %eax
movslq -0x14(%rbp), %rdx
movq 0x36d5b(%rip), %rcx     # 0x82da8
cmpl 0x4(%rcx,%rdx,8), %eax
jne 0x4c067
movq 0x36d76(%rip), %rax     # 0x82dd0
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4c09b
jmp 0x4c069
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c023
movq 0x36d55(%rip), %rax     # 0x82dd0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x36541(%rip), %rax     # 0x82600
callq *0x138(%rax)
cmpl $0x3, %eax
jge 0x4c0eb
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29bb4(%rip), %rdx     # 0x75c8e
movq 0x3651f(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
jmp 0x4c1b5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x366b4(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jge 0x4c121
movslq -0x4(%rbp), %rcx
movq 0x36c9d(%rip), %rax     # 0x82da8
cmpl $-0x1, 0x4(%rax,%rcx,8)
jne 0x4c114
jmp 0x4c121
jmp 0x4c116
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4c0f2
movl -0x4(%rbp), %eax
movq 0x36685(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jne 0x4c171
movq 0x3667a(%rip), %rax     # 0x827b0
cmpl $0x400, (%rax)          # imm = 0x400
jne 0x4c15c
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29b59(%rip), %rdx     # 0x75ca7
movq 0x364ab(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
jmp 0x4c1b5
movq 0x3664d(%rip), %rax     # 0x827b0
movl (%rax), %ecx
addl $0x1, %ecx
movq 0x36641(%rip), %rax     # 0x827b0
movl %ecx, (%rax)
movl $0x2, %edi
movq 0x36483(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, %rdi
movslq -0x4(%rbp), %rax
movq 0x36c17(%rip), %rsi     # 0x82da8
shlq $0x3, %rax
addq %rax, %rsi
callq 0x4c1c0
cmpl $0x0, %eax
jne 0x4c1b5
movslq -0x4(%rbp), %rcx
movq 0x36bfb(%rip), %rax     # 0x82da8
movl $0xffffffff, 0x4(%rax,%rcx,8) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0xa4(%rbp)
cmpl $0x4, -0xa4(%rbp)
jge 0x4c215
movslq -0xa4(%rbp), %rax
movb $0x0, -0xac(%rbp,%rax)
movslq -0xa4(%rbp), %rax
movb $0x0, -0xb0(%rbp,%rax)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x4c1dd
movl $0x0, -0xa4(%rbp)
cmpl $0x4, -0xa4(%rbp)
jge 0x4c357
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x4c244
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x4c274
movq 0x363b5(%rip), %rax     # 0x82600
movq 0x10(%rax), %r8
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29bb3(%rip), %rdx     # 0x75e16
movb $0x0, %al
callq *%r8
movl $0x0, -0x4(%rbp)
jmp 0x4c377
movl $0x0, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0xb1(%rbp)
jl 0x4c2a5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x4c2b1
jmp 0x4c2de
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movl -0xa8(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0xa8(%rbp)
cltq
movb %cl, -0xa0(%rbp,%rax)
jmp 0x4c27e
movslq -0xa8(%rbp), %rax
movb $0x0, -0xa0(%rbp,%rax)
leaq -0xa0(%rbp), %rdi
callq 0x19820
movb %al, %cl
movslq -0xa4(%rbp), %rax
movb %cl, -0xac(%rbp,%rax)
movslq -0xa4(%rbp), %rax
movzbl -0xac(%rbp,%rax), %eax
cmpl $0x0, %eax
je 0x4c32c
movslq -0xa4(%rbp), %rax
movb $-0x1, -0xb0(%rbp,%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x4c337
jmp 0x4c357
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x4c21f
movq -0x18(%rbp), %rax
movl -0xb0(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl -0xac(%rbp), %ecx
movl %ecx, 0x4(%rax)
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_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x36261(%rip), %rax     # 0x82600
callq *0x138(%rax)
cmpl $0x3, %eax
jge 0x4c3cb
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29905(%rip), %rdx     # 0x75cbf
movq 0x3623f(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
jmp 0x4c4f5
movl $0x2, %edi
movq 0x36229(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, %rdi
leaq -0x8(%rbp), %rsi
callq 0x4c1c0
cmpl $0x0, %eax
jne 0x4c3f3
jmp 0x4c4f5
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x363ac(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jge 0x4c4b8
movslq -0xc(%rbp), %rcx
movq 0x36991(%rip), %rax     # 0x82da8
movl (%rax,%rcx,8), %eax
cmpl -0x8(%rbp), %eax
jne 0x4c4a8
movslq -0xc(%rbp), %rcx
movq 0x3697a(%rip), %rax     # 0x82da8
movl 0x4(%rax,%rcx,8), %eax
cmpl -0x4(%rbp), %eax
jne 0x4c4a8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq 0x36366(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jge 0x4c475
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
movslq -0x10(%rbp), %rdx
movq 0x36946(%rip), %rax     # 0x82da8
movq (%rax,%rdx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4c440
movq 0x36334(%rip), %rax     # 0x827b0
movl (%rax), %ecx
addl $-0x1, %ecx
movq 0x36328(%rip), %rax     # 0x827b0
movl %ecx, (%rax)
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29844(%rip), %rdx     # 0x75cde
movq 0x3615f(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
jmp 0x4c4f5
jmp 0x4c4aa
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4c3fa
movq 0x36141(%rip), %rax     # 0x82600
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x2, %edi
movq 0x3612d(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq -0x18(%rbp), %r8
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x297f8(%rip), %rdx     # 0x75ce8
movb $0x0, %al
callq *%r8
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x297e1(%rip), %rdx     # 0x75cf9
movq 0x360e1(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x3627b(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jge 0x4c5c2
movl $0x0, -0x8(%rbp)
movslq -0x8(%rbp), %rax
cmpq $0x4, %rax
jae 0x4c57f
movslq -0x4(%rbp), %rcx
movq 0x3684f(%rip), %rax     # 0x82da8
movl 0x4(%rax,%rcx,8), %eax
movl -0x8(%rbp), %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %cl
movslq -0x8(%rbp), %rax
movb %cl, -0xc(%rbp,%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4c544
movq 0x3607a(%rip), %rax     # 0x82600
movq 0x10(%rax), %r10
movzbl -0xc(%rbp), %ecx
movzbl -0xb(%rbp), %r8d
movzbl -0xa(%rbp), %r9d
movzbl -0x9(%rbp), %eax
xorl %edx, %edx
movl %edx, %edi
movl $0x2, %esi
leaq 0x2975b(%rip), %rdx     # 0x75d07
movl %eax, (%rsp)
movb $0x0, %al
callq *%r10
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4c52b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x368ce(%rip), %rax     # 0x82eb0
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x4c627
movq 0x368bd(%rip), %rax     # 0x82eb0
movq (%rax), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4c627
leaq -0x90(%rbp), %rdi
movq 0x368a0(%rip), %rax     # 0x82eb0
movq (%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x296fa(%rip), %rsi     # 0x75d18
movb $0x0, %al
callq 0x19940
jmp 0x4c63c
leaq -0x90(%rbp), %rdi
leaq 0x296f3(%rip), %rsi     # 0x75d28
movb $0x0, %al
callq 0x19940
movq 0x35fbd(%rip), %rax     # 0x82600
movq 0x10(%rax), %r8
leaq -0x90(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x296d7(%rip), %rdx     # 0x75d35
movb $0x0, %al
callq *%r8
leaq -0x90(%rbp), %rdi
leaq 0x27ade(%rip), %rsi     # 0x7414f
callq 0x196a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4c6ad
movq 0x35f78(%rip), %rax     # 0x82600
movq 0x10(%rax), %r8
leaq -0x90(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x2969f(%rip), %rdx     # 0x75d42
movb $0x0, %al
callq *%r8
jmp 0x4c794
movq -0x8(%rbp), %rdi
movq 0x36718(%rip), %rax     # 0x82dd0
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x2968d(%rip), %rsi     # 0x75d54
movb $0x0, %al
callq 0x18cf0
movl $0x0, -0x98(%rbp)
movl -0x98(%rbp), %eax
movq 0x360cb(%rip), %rcx     # 0x827b0
cmpl (%rcx), %eax
jge 0x4c78b
movl $0x0, -0x9c(%rbp)
movslq -0x9c(%rbp), %rax
cmpq $0x4, %rax
jae 0x4c747
movslq -0x98(%rbp), %rcx
movq 0x36696(%rip), %rax     # 0x82da8
movl 0x4(%rax,%rcx,8), %eax
movl -0x9c(%rbp), %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %cl
movslq -0x9c(%rbp), %rax
movb %cl, -0x94(%rbp,%rax)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x4c6f7
movq -0x8(%rbp), %rdi
movzbl -0x94(%rbp), %edx
movzbl -0x93(%rbp), %ecx
movzbl -0x92(%rbp), %r8d
movzbl -0x91(%rbp), %r9d
leaq 0x295f6(%rip), %rsi     # 0x75d66
movb $0x0, %al
callq 0x18cf0
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0x4c6d8
movq -0x8(%rbp), %rdi
callq 0x18600
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x35e3e(%rip), %rax     # 0x82600
callq *0x138(%rax)
cmpl $0x3, %eax
jge 0x4c7ee
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x2959f(%rip), %rdx     # 0x75d7c
movq 0x35e1c(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
jmp 0x4c897
movl $0x2, %edi
movq 0x35e06(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, %rdi
leaq 0x235a5(%rip), %rsi     # 0x6fdaf
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x19180
cmpl $0x0, %eax
jne 0x4c838
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29571(%rip), %rdx     # 0x75d9b
movq 0x35dcf(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x10(%rcx)
jmp 0x4c897
leaq 0x22f48(%rip), %rdi     # 0x6f787
callq 0x18a90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4c897
cmpq $0x0, -0x8(%rbp)
jbe 0x4c897
cmpq $0x4b0, -0x8(%rbp)      # imm = 0x4B0
jae 0x4c897
movq -0x8(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x5c(%rax)
leaq -0x210(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2953a(%rip), %rsi     # 0x75db9
movb $0x0, %al
callq 0x19940
leaq -0x210(%rbp), %rsi
movl $0x2, %edi
callq 0x19470
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movq 0x35d4c(%rip), %rax     # 0x82600
callq *0x140(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2600c(%rip), %rsi     # 0x728d5
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c8dd
callq 0x18930
jmp 0x4c9d3
movq -0x8(%rbp), %rdi
leaq 0x294ee(%rip), %rsi     # 0x75dd6
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c8fc
callq 0x19b00
jmp 0x4c9d1
movq -0x8(%rbp), %rdi
leaq 0x294d5(%rip), %rsi     # 0x75ddc
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c91b
callq 0x18b90
jmp 0x4c9cf
movq -0x8(%rbp), %rdi
leaq 0x294bf(%rip), %rsi     # 0x75de5
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c93a
callq 0x18880
jmp 0x4c9cd
movq -0x8(%rbp), %rdi
leaq 0x294a7(%rip), %rsi     # 0x75dec
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c956
callq 0x19b60
jmp 0x4c9cb
movq -0x8(%rbp), %rdi
leaq 0x2606e(%rip), %rsi     # 0x729cf
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c972
callq 0x18590
jmp 0x4c9c9
movq -0x8(%rbp), %rdi
leaq 0x260a8(%rip), %rsi     # 0x72a25
callq 0x186f0
cmpl $0x0, %eax
je 0x4c99c
movq -0x8(%rbp), %rdi
leaq 0x29462(%rip), %rsi     # 0x75df4
callq 0x186f0
cmpl $0x0, %eax
jne 0x4c9a3
callq 0x18800
jmp 0x4c9c7
movq 0x35c56(%rip), %rax     # 0x82600
movq 0x10(%rax), %r8
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edi
movl $0x2, %esi
leaq 0x29437(%rip), %rdx     # 0x75df9
movb $0x0, %al
callq *%r8
jmp 0x4c9c9
jmp 0x4c9cb
jmp 0x4c9cd
jmp 0x4c9cf
jmp 0x4c9d1
jmp 0x4c9d3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, %edi
movq 0x35c00(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x35bf3(%rip), %rax     # 0x82600
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x32c(%rcx), %edi
callq *%rax
movq 0x35bd9(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq *%rax
movq 0x35bc1(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x4cad0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x4cabd
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
jmp 0x4cace
movq -0x8(%rbp), %rax
movl 0x2e8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
jmp 0x4cb35
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4caeb
movl $0x12, -0x1c(%rbp)
jmp 0x4caf2
movl $0x2, -0x1c(%rbp)
movq 0x35b07(%rip), %rax     # 0x82600
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rcx
movl 0x2e8(%rcx), %ecx
movq -0x8(%rbp), %r8
movss 0x2f0(%r8), %xmm0
movq -0x8(%rbp), %r8
movss 0x2f4(%r8), %xmm1
xorps %xmm2, %xmm2
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq 0x35b15(%rip), %rax     # 0x82668
cmpq $0x0, 0x30(%rax)
jne 0x4cb8d
movq 0x35a9f(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x58(%rbp), %rcx
movq %rax, %rsi
leaq 0x292c4(%rip), %rdi     # 0x75e48
movb $0x0, %al
callq *%rcx
jmp 0x4cccf
movq 0x35ad4(%rip), %rax     # 0x82668
movq 0x30(%rax), %rdi
leaq 0x23f63(%rip), %rsi     # 0x70b02
callq 0x19bf0
cmpq $0x0, %rax
jne 0x4cbce
leaq -0x50(%rbp), %rdi
movq 0x35ab3(%rip), %rax     # 0x82668
movq 0x30(%rax), %rcx
movl $0x40, %esi
leaq 0x24a0e(%rip), %rdx     # 0x715d3
movb $0x0, %al
callq 0x18f90
jmp 0x4cbe7
leaq -0x50(%rbp), %rdi
movq 0x35a8f(%rip), %rax     # 0x82668
movq 0x30(%rax), %rsi
movl $0x3f, %edx
callq 0x181e0
movq 0x35a12(%rip), %rax     # 0x82600
movq 0x48(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movss 0x2f0(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4cc2e
jp 0x4cc2e
movq -0x8(%rbp), %rax
movss 0x232c6(%rip), %xmm0    # 0x6feec
movss %xmm0, 0x2f0(%rax)
movq -0x8(%rbp), %rax
movss 0x2f4(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4cc5a
jp 0x4cc5a
movq -0x8(%rbp), %rax
movss 0x2329c(%rip), %xmm0    # 0x6feec
movss %xmm0, 0x2f4(%rax)
jmp 0x4cc86
movq -0x8(%rbp), %rax
movss 0x2f4(%rax), %xmm0
movss 0x25f1a(%rip), %xmm1    # 0x72b88
ucomiss %xmm1, %xmm0
jne 0x4cc84
jp 0x4cc84
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2f4(%rax)
jmp 0x4cc86
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4cca9
movq -0x8(%rbp), %rax
movl 0x2e8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movq 0x3571c(%rip), %rcx     # 0x823d0
movq %rcx, 0x228(%rax)
movq 0x3593e(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: Use_Target_Help
void Use_Target_Help (edict_t *ent, edict_t *other, edict_t *activator)
{
	if (ent->spawnflags & 1)
		strncpy (game.helpmessage1, ent->message, sizeof(game.helpmessage2)-1);
	else
		strncpy (game.helpmessage2, ent->message, sizeof(game.helpmessage1)-1);

	game.helpchanged++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4cd24
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rsi
movq 0x36028(%rip), %rdi     # 0x82d40
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x181e0
jmp 0x4cd47
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rsi
movq 0x3600a(%rip), %rdi     # 0x82d40
addq $0x200, %rdi            # imm = 0x200
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x181e0
movq 0x35ff2(%rip), %rax     # 0x82d40
movl 0x400(%rax), %ecx
addl $0x1, %ecx
movq 0x35fe2(%rip), %rax     # 0x82d40
movl %ecx, 0x400(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3613d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4cd97
jp 0x4cd97
jmp 0x4cda2
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4ce0e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jne 0x4cdfc
movq 0x35849(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rax, %rdx
leaq 0x29083(%rip), %rdi     # 0x75e70
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4ce0e
movq -0x8(%rbp), %rax
movq 0x35ee9(%rip), %rcx     # 0x82cf0
movq %rcx, 0x228(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x357c5(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x2e8(%rcx), %edx
movl $0x2, %esi
movss 0x23092(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
movq 0x35f37(%rip), %rax     # 0x82da0
movl 0x134(%rax), %ecx
addl $0x1, %ecx
movq 0x35f27(%rip), %rax     # 0x82da0
movl %ecx, 0x134(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19b50
movq -0x8(%rbp), %rdi
callq 0x19cd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3600d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4cec7
jp 0x4cec7
jmp 0x4ced5
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4cfcc
movq -0x8(%rbp), %rax
movq 0x360b0(%rip), %rcx     # 0x82f90
movq %rcx, 0x228(%rax)
movq 0x3577a(%rip), %rax     # 0x82668
cmpq $0x0, 0x30(%rax)
jne 0x4cf07
movq 0x3576c(%rip), %rax     # 0x82668
leaq 0x24270(%rip), %rcx     # 0x71173
movq %rcx, 0x30(%rax)
movq 0x356f2(%rip), %rax     # 0x82600
movq 0x48(%rax), %rax
movq 0x3574f(%rip), %rcx     # 0x82668
movq 0x30(%rcx), %rdi
callq *%rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
movq 0x35e60(%rip), %rax     # 0x82da0
movl 0x130(%rax), %ecx
addl $0x1, %ecx
movq 0x35e50(%rip), %rax     # 0x82da0
movl %ecx, 0x130(%rax)
movq 0x35e43(%rip), %rdi     # 0x82da0
addq $0x48, %rdi
leaq 0x28f22(%rip), %rsi     # 0x75e8a
callq 0x186f0
cmpl $0x0, %eax
jne 0x4cfcc
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movss 0x28ead(%rip), %xmm1    # 0x75e30
ucomiss %xmm1, %xmm0
jne 0x4cfcc
jp 0x4cfcc
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0x28e99(%rip), %xmm1    # 0x75e34
ucomiss %xmm1, %xmm0
jne 0x4cfcc
jp 0x4cfcc
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movss 0x28e85(%rip), %xmm1    # 0x75e38
ucomiss %xmm1, %xmm0
jne 0x4cfcc
jp 0x4cfcc
movq -0x8(%rbp), %rax
leaq 0x28ecb(%rip), %rcx     # 0x75e90
movq %rcx, 0x130(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x35605(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x2e8(%rcx), %edx
movl $0x2, %esi
movss 0x22ed2(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
movq 0x35d77(%rip), %rax     # 0x82da0
movl 0x13c(%rax), %ecx
addl $0x1, %ecx
movq 0x35d67(%rip), %rax     # 0x82da0
movl %ecx, 0x13c(%rax)
movq 0x35d5a(%rip), %rax     # 0x82da0
movl 0x13c(%rax), %eax
movq 0x35d4d(%rip), %rcx     # 0x82da0
cmpl 0x138(%rcx), %eax
jne 0x4d071
movl $0x1, %edi
leaq 0x2ac49(%rip), %rsi     # 0x77cb0
movq 0x35592(%rip), %rax     # 0x82600
callq *0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19b50
movq -0x8(%rbp), %rdi
callq 0x19cd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x35e1d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4d0b7
jp 0x4d0b7
jmp 0x4d0c5
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4d146
movq -0x8(%rbp), %rax
movq 0x35600(%rip), %rcx     # 0x826d0
movq %rcx, 0x228(%rax)
movq 0x3558a(%rip), %rax     # 0x82668
cmpq $0x0, 0x30(%rax)
jne 0x4d0f7
movq 0x3557c(%rip), %rax     # 0x82668
leaq 0x24080(%rip), %rcx     # 0x71173
movq %rcx, 0x30(%rax)
movq 0x35502(%rip), %rax     # 0x82600
movq 0x48(%rax), %rax
movq 0x3555f(%rip), %rcx     # 0x82668
movq 0x30(%rcx), %rdi
callq *%rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
movq 0x35c70(%rip), %rax     # 0x82da0
movl 0x138(%rax), %ecx
addl $0x1, %ecx
movq 0x35c60(%rip), %rax     # 0x82da0
movl %ecx, 0x138(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3, %edi
movq 0x35498(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movl $0x5, %edi
movq 0x35486(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x35479(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq *%rax
movq 0x35461(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x1, %esi
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rsi
movq -0x8(%rbp), %rax
cvtsi2ssl 0x280(%rax), %xmm0
movq -0x8(%rbp), %rax
movl 0x280(%rax), %eax
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
xorl %eax, %eax
movl %eax, %edx
movl $0x19, %ecx
callq 0x180c0
movq -0x8(%rbp), %rax
movss 0x2fc(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2fc(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rsi
callq 0x19b50
movss -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2fc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)