LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x2d4c9(%rip), %rbx     # 0x69600
callq *0x138(%rbx)
cmpl $0x2, %eax
jg 0x3c15f
movq 0x10(%rbx), %rcx
leaq 0x1dc5e(%rip), %rdx     # 0x59dab
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 0x3c05a
testl %eax, %eax
je 0x3c1dc
movq 0x2d630(%rip), %rax     # 0x697b0
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x3c1ad
movl (%rsp), %edi
movl 0x4(%rsp), %r8d
xorl %edx, %edx
movq 0x2dc0f(%rip), %rsi     # 0x69da8
cmpl %edi, (%rsi,%rdx,8)
jne 0x3c1a5
cmpl %r8d, 0x4(%rsi,%rdx,8)
je 0x3c1e4
incq %rdx
cmpq %rdx, %rcx
jne 0x3c199
movq 0x10(%rbx), %r14
movl $0x2, %edi
callq *0x140(%rbx)
leaq 0x1dc11(%rip), %rdx     # 0x59dd4
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(%rdx), %edi
cmpl %ecx, %edi
jge 0x3c1ff
leal -0x1(%rcx), %edi
movq 0x8(%rsi,%rdx,8), %r8
movq %r8, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rdi
jne 0x3c1ee
decl %ecx
movl %ecx, (%rax)
movq 0x10(%rbx), %rcx
leaq 0x1dbbc(%rip), %rdx     # 0x59dca
jmp 0x3c14d
// File: /workspace/github_c_makefile_star2_O1/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 0x2d3d8(%rip), %r14     # 0x69600
leaq 0x1dbb6(%rip), %rdx     # 0x59de5
xorl %edi, %edi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%r14)
movq 0x2d56d(%rip), %r15     # 0x697b0
cmpl $0x0, (%r15)
jle 0x3c2b0
movq 0x2db58(%rip), %r12     # 0x69da8
leaq 0x14(%rsp), %r13
leaq 0x1db97(%rip), %rbx     # 0x59df3
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 0x3c268
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 0x3c25e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2dbd9(%rip), %rax     # 0x69eb0
movq (%rax), %rax
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x3c2fd
cmpb $0x0, (%rdx)
je 0x3c2fd
leaq 0x1db15(%rip), %rsi     # 0x59e04
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x19700
jmp 0x3c31b
movabsq $0x6766632e706974, %rax # imm = 0x6766632E706974
movq %rax, 0x15(%rsp)
movabsq $0x70697473696c2f2e, %rax # imm = 0x70697473696C2F2E
movq %rax, 0x10(%rsp)
movq 0x2d2de(%rip), %r14     # 0x69600
leaq 0x1daf8(%rip), %rdx     # 0x59e21
leaq 0x10(%rsp), %rbx
xorl %edi, %edi
movl $0x2, %esi
movq %rbx, %rcx
xorl %eax, %eax
callq *0x10(%r14)
leaq 0x1be82(%rip), %rsi     # 0x581c7
movq %rbx, %rdi
callq 0x19470
testq %rax, %rax
je 0x3c3f1
movq %rax, %rbx
movq 0x2da70(%rip), %rax     # 0x69dd0
movq (%rax), %rax
cvttss2si 0x20(%rax), %edx
leaq 0x1dad1(%rip), %rsi     # 0x59e40
movq %rbx, %rdi
xorl %eax, %eax
callq 0x18bf0
movq 0x2d430(%rip), %r15     # 0x697b0
cmpl $0x0, (%r15)
jle 0x3c3e7
movq 0x2da1b(%rip), %r12     # 0x69da8
leaq 0xc(%rsp), %r13
leaq 0x1dab9(%rip), %r14     # 0x59e52
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 0x3c3a5
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 0x3c39b
movq %rbx, %rdi
callq 0x185a0
jmp 0x3c40a
leaq 0x1da36(%rip), %rdx     # 0x59e2e
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_O1/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 0x2d1cc(%rip), %rbx     # 0x69600
callq *0x138(%rbx)
cmpl $0x2, %eax
jg 0x3c45d
movq 0x10(%rbx), %rcx
leaq 0x1da1e(%rip), %rdx     # 0x59e68
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 0x17950(%rip), %rsi     # 0x53dbf
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x18fe0
testl %eax, %eax
je 0x3c4d9
leaq 0x1730e(%rip), %rdi     # 0x53797
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 0x3c4ec
movl %edx, 0x5c(%rax)
leaq 0x1d9ea(%rip), %rsi     # 0x59ea5
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19700
movl $0x2, %edi
movq %rbx, %rsi
callq 0x19270
jmp 0x3c4ec
leaq 0x1d9a7(%rip), %rdx     # 0x59e87
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_O1/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 0x2d100(%rip), %r14     # 0x69600
movl $0x1, %edi
callq *0x140(%r14)
movq %rax, %rbx
leaq 0x1a403(%rip), %rsi     # 0x56919
movq %rax, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c5e4
leaq 0x1d995(%rip), %rsi     # 0x59ec2
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c601
leaq 0x1d984(%rip), %rsi     # 0x59ec8
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c60d
leaq 0x1d976(%rip), %rsi     # 0x59ed1
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c619
leaq 0x1d966(%rip), %rsi     # 0x59ed8
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c625
leaq 0x1a47d(%rip), %rsi     # 0x56a06
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c64c
leaq 0x1a4bc(%rip), %rsi     # 0x56a5c
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c631
leaq 0x1d929(%rip), %rsi     # 0x59ee0
movq %rbx, %rdi
callq 0x18690
testl %eax, %eax
je 0x3c631
movq 0x10(%r14), %r8
leaq 0x1d917(%rip), %rdx     # 0x59ee5
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 0x1d763(%rip), %rdx     # 0x59d52
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 0x198a0
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 0x19900
callq 0x188c0
movq 0x8(%r14), %rcx
leaq 0x1d721(%rip), %rdi     # 0x59d62
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_O1/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 0x2cf9a(%rip), %r14     # 0x69600
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_O1/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 0x3c6cf
cmpl $0x0, 0x4c(%rsi)
je 0x3c703
movl $0x0, 0x4c(%rsi)
retq
andl $0x4, %eax
leal 0x2(,%rax,4), %edx
movq 0x2cf20(%rip), %rax     # 0x69600
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_O1/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 0x2cf4a(%rip), %rax     # 0x69668
movq 0x30(%rax), %r14
testq %r14, %r14
je 0x3c74d
leaq 0x183be(%rip), %rsi     # 0x54aec
movq %r14, %rdi
callq 0x19990
testq %rax, %rax
je 0x3c77c
movq %rsp, %rdi
movl $0x3f, %edx
movq %r14, %rsi
callq 0x181c0
jmp 0x3c795
movq 0x2ceac(%rip), %rax     # 0x69600
movq 0x8(%rax), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x190a0
leaq 0x1d7cd(%rip), %rdi     # 0x59f38
movq %rax, %rsi
xorl %eax, %eax
movq %r14, %rcx
addq $0x48, %rsp
popq %rbx
popq %r14
jmpq *%rcx
leaq 0x18eac(%rip), %rdx     # 0x5562f
movq %rsp, %rdi
movl $0x40, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x18e10
movq 0x2ce64(%rip), %r14     # 0x69600
movq %rsp, %rdi
callq *0x48(%r14)
movl %eax, 0x2e8(%rbx)
movss 0x2f0(%rbx), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x3c7c5
jp 0x3c7c5
movl $0x3f800000, 0x2f0(%rbx) # imm = 0x3F800000
movss 0x2f4(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jne 0x3c7d4
jnp 0x3c7e1
ucomiss 0x1a425(%rip), %xmm1    # 0x56c00
jne 0x3c7f1
jnp 0x3c7e9
jmp 0x3c7f1
movss 0x1773f(%rip), %xmm0    # 0x53f28
movss %xmm0, 0x2f4(%rbx)
testb $0x1, 0x140(%rbx)
je 0x3c7fd
movl %eax, 0x4c(%rbx)
movq 0x2cbcc(%rip), %rax     # 0x693d0
movq %rax, 0x228(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d65e(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c874
jnp 0x3c881
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a60
cmpq $0x0, 0x130(%rbx)
je 0x3c89f
movq 0x2d45e(%rip), %rax     # 0x69cf0
movq %rax, 0x228(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2cd5a(%rip), %rax     # 0x69600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1d69f(%rip), %rdi     # 0x59f60
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
jmp 0x3c874
// File: /workspace/github_c_makefile_star2_O1/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 0x2cd21(%rip), %rax     # 0x69600
movl 0x2e8(%rdi), %edx
movss 0x1763b(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movl $0x2, %esi
movaps %xmm0, %xmm1
callq *0x20(%rax)
movq 0x2d49e(%rip), %rax     # 0x69da0
incl 0x134(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x198f0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/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 0x2d593(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3c93f
jnp 0x3c948
movq %rbx, %rdi
popq %rbx
jmp 0x19a60
movq 0x2d641(%rip), %rax     # 0x69f90
movq %rax, 0x228(%rbx)
movq 0x2cd0b(%rip), %rax     # 0x69668
cmpq $0x0, 0x30(%rax)
jne 0x3c96f
leaq 0x18804(%rip), %rcx     # 0x5516f
movq %rcx, 0x30(%rax)
movq 0x2cc8a(%rip), %rcx     # 0x69600
movq 0x30(%rax), %rdi
callq *0x48(%rcx)
movl %eax, 0x2e8(%rbx)
movl $0x1, 0xc8(%rbx)
movq 0x2d40c(%rip), %rdi     # 0x69da0
incl 0x130(%rdi)
addq $0x48, %rdi
leaq 0x1d5d5(%rip), %rsi     # 0x59f7a
callq 0x18690
testl %eax, %eax
je 0x3c9b0
popq %rbx
retq
movss 0x4(%rbx), %xmm0
ucomiss 0x1d560(%rip), %xmm0    # 0x59f1c
jne 0x3c9ae
jp 0x3c9ae
movss 0x8(%rbx), %xmm0
ucomiss 0x1d554(%rip), %xmm0    # 0x59f20
jne 0x3c9ae
jp 0x3c9ae
movss 0xc(%rbx), %xmm0
ucomiss 0x1d548(%rip), %xmm0    # 0x59f24
jne 0x3c9ae
jp 0x3c9ae
leaq 0x1d599(%rip), %rax     # 0x59f80
movq %rax, 0x130(%rbx)
jmp 0x3c9ae
// File: /workspace/github_c_makefile_star2_O1/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 0x2cbfe(%rip), %r15     # 0x69600
movl 0x2e8(%rdi), %edx
movss 0x17518(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movl $0x2, %esi
movaps %xmm0, %xmm1
callq *0x20(%r15)
movq 0x2d37a(%rip), %rax     # 0x69da0
movl 0x13c(%rax), %ecx
incl %ecx
movl %ecx, 0x13c(%rax)
cmpl 0x138(%rax), %ecx
jne 0x3ca4c
leaq 0x1f339(%rip), %rsi     # 0x5bd7c
movl $0x1, %edi
callq *0x30(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x198f0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/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 0x2d451(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3ca81
jnp 0x3ca8a
movq %rbx, %rdi
popq %rbx
jmp 0x19a60
movq 0x2cc3f(%rip), %rax     # 0x696d0
movq %rax, 0x228(%rbx)
movq 0x2cbc9(%rip), %rax     # 0x69668
cmpq $0x0, 0x30(%rax)
jne 0x3cab1
leaq 0x186c2(%rip), %rcx     # 0x5516f
movq %rcx, 0x30(%rax)
movq 0x2cb48(%rip), %rcx     # 0x69600
movq 0x30(%rax), %rdi
callq *0x48(%rcx)
movl %eax, 0x2e8(%rbx)
movl $0x1, 0xc8(%rbx)
movq 0x2d2ca(%rip), %rax     # 0x69da0
incl 0x138(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2cb0f(%rip), %r15     # 0x69600
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 0x198f0
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x2fc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3cba5
jnp 0x3cbc8
movq 0x2ce84(%rip), %rax     # 0x69a30
movq %rax, 0x210(%rdi)
movq 0x2d1e6(%rip), %rax     # 0x69da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
retq
jmp 0x19b08
// File: /workspace/github_c_makefile_star2_O1/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 0x2d1a9(%rip), %rax     # 0x69da0
movss 0xc8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3cd22
jp 0x3cd22
movq %rdi, %rbx
movq 0x2d2a5(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
ucomiss %xmm1, %xmm0
jne 0x3cc5e
jp 0x3cc5e
movq 0x2d32f(%rip), %rax     # 0x69f60
movq (%rax), %rax
movss 0x20(%rax), %xmm2
ucomiss %xmm1, %xmm2
jne 0x3cc57
jp 0x3cc57
movq 0x2c911(%rip), %rax     # 0x69558
movq (%rax), %rax
cmpl $0x0, 0x6fc(%rax)
jle 0x3cd22
ucomiss %xmm1, %xmm0
jne 0x3cc5e
jnp 0x3ccb9
movq 0x2c9b3(%rip), %rax     # 0x69618
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
btl $0xc, %eax
jb 0x3ccb9
movq 0x2c8de(%rip), %rax     # 0x69558
cmpq %rsi, (%rax)
je 0x3ccb9
leaq 0x4(%rsi), %r8
movl 0x258(%rsi), %eax
addl %eax, %eax
leal (%rax,%rax,4), %eax
movq 0x2cad3(%rip), %rcx     # 0x69768
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 0x3cd29
testq %rdx, %rdx
je 0x3ccf6
ucomiss %xmm1, %xmm0
jne 0x3ccc5
jnp 0x3ccf6
movq 0x58(%rdx), %rdx
testq %rdx, %rdx
je 0x3ccf6
addq $0x2c0, %rdx            # imm = 0x2C0
leaq 0x1d2c2(%rip), %rsi     # 0x59f9e
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x19700
movl $0x2, %edi
movq %r14, %rsi
callq 0x19270
movq 0x270(%rbx), %rdi
movl $0x2a, %esi
callq 0x18730
testq %rax, %rax
je 0x3cd1a
movq 0x2d02d(%rip), %rax     # 0x69d40
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_O1/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 0x3cd9e
movq 0x2d05b(%rip), %rdi     # 0x69da0
addq $0x48, %rdi
leaq 0x1d28a(%rip), %rsi     # 0x59fda
callq 0x18690
testl %eax, %eax
jne 0x3cd7e
movq 0x270(%rbx), %rdi
leaq 0x1d279(%rip), %rsi     # 0x59fe0
callq 0x18690
testl %eax, %eax
jne 0x3cd7e
leaq 0x1d26f(%rip), %rax     # 0x59fe6
movq %rax, 0x270(%rbx)
movq 0x2cf3b(%rip), %rax     # 0x69cc0
movq %rax, 0x228(%rbx)
movl $0x1, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2c85b(%rip), %rax     # 0x69600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1d1fb(%rip), %rdi     # 0x59fb4
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_splash
void use_target_splash (edict_t *self, edict_t *other, edict_t *activator)
{
	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (TE_SPLASH);
	gi.WriteByte (self->count);
	gi.WritePosition (self->s.origin);
	gi.WriteDir (self->movedir);
	gi.WriteByte (self->sounds);
	gi.multicast (self->s.origin, MULTICAST_PVS);

	if (self->dmg)
		T_RadiusDamage (self, activator, self->dmg, NULL, self->dmg+40, MOD_SPLASH);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x2c81b(%rip), %r12     # 0x69600
movl $0x3, %edi
callq *0xc8(%r12)
movl $0xa, %edi
callq *0xc8(%r12)
movl 0x290(%r14), %edi
callq *0xc8(%r12)
leaq 0x4(%r14), %r15
movq %r15, %rdi
callq *0xf0(%r12)
leaq 0x19c(%r14), %rdi
callq *0xf8(%r12)
movl 0x28c(%r14), %edi
callq *0xc8(%r12)
movq %r15, %rdi
movl $0x2, %esi
callq *0xb0(%r12)
movl 0x280(%r14), %eax
testl %eax, %eax
je 0x3ce7e
cvtsi2ss %eax, %xmm0
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x180c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c873(%rip), %rax     # 0x69708
movq %rax, 0x228(%rdi)
addq $0x10, %rdi
leaq 0x19c(%rbx), %rsi
callq 0x19630
cmpl $0x0, 0x290(%rbx)
jne 0x3cebf
movl $0x20, 0x290(%rbx)
movl $0x1, 0xc8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19710
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 0x2c6c6(%rip), %r15     # 0x69600
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 0x3cf68
jnp 0x3cf9b
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_O1/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 0x2ce18(%rip), %rax     # 0x69dc0
movq %rax, 0x228(%rdi)
movl $0x1, 0xc8(%rdi)
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3cfcb
jnp 0x3cfff
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
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_blaster
void use_target_blaster (edict_t *self, edict_t *other, edict_t *activator)
{
	int effect;

	if (self->spawnflags & 2)
		effect = 0;
	else if (self->spawnflags & 1)
		effect = EF_HYPERBLASTER;
	else
		effect = EF_BLASTER;

	fire_blaster (self, self->s.origin, self->movedir, self->dmg, self->speed, effect, MOD_TARGET_BLASTER);
	gi.sound (self, CHAN_VOICE, self->noise_index, 1, ATTN_NORM, 0);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x140(%rdi), %eax
movl 0x280(%rdi), %ecx
testb $0x1, %al
movl $0x8, %edx
movl $0x40, %esi
cmovel %edx, %esi
xorl %r9d, %r9d
testb $0x2, %al
cmovel %esi, %r9d
leaq 0x4(%rdi), %rsi
leaq 0x19c(%rdi), %rdx
cvttss2si 0x190(%rdi), %r8d
movl $0x21, (%rsp)
callq 0x189b0
movq 0x2c5ad(%rip), %rax     # 0x69600
movq 0x20(%rax), %rax
movl 0x2e8(%rbx), %edx
movss 0x16ec3(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x2, %esi
movaps %xmm0, %xmm1
addq $0x10, %rsp
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_blaster
void SP_target_blaster (edict_t *self)
{
	self->use = use_target_blaster;
	G_SetMovedir (self->s.angles, self->movedir);
	self->noise_index = gi.soundindex ("weapons/laser2.wav");

	if (!self->dmg)
		self->dmg = 15;
	if (!self->speed)
		self->speed = 1000;

	self->svflags = SVF_NOCLIENT;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2c89b(%rip), %rax     # 0x69920
movq %rax, 0x228(%rdi)
addq $0x10, %rdi
leaq 0x19c(%rbx), %rsi
callq 0x19630
movq 0x2c55d(%rip), %rax     # 0x69600
leaq 0x1cf4a(%rip), %rdi     # 0x59ff4
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x3d0c6
movl $0xf, 0x280(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3d0e2
jp 0x3d0e2
movl $0x447a0000, 0x190(%rbx) # imm = 0x447A0000
movl $0x1, 0xc8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_crosslevel_target
void SP_target_crosslevel_target (edict_t *self)
{
	if (! self->delay)
		self->delay = 1;
	self->svflags = SVF_NOCLIENT;

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

// Assembly:
movss 0x2fc(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3d16d
jp 0x3d16d
movl $0x3f800000, 0x2fc(%rdi) # imm = 0x3F800000
movl $0x1, 0xc8(%rdi)
movq 0x2c6a2(%rip), %rax     # 0x69820
movq %rax, 0x210(%rdi)
movq 0x2cc14(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x2fc(%rdi), %xmm0
movss %xmm0, 0x200(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_laser_use
void target_laser_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->activator = activator;
	if (self->spawnflags & 1)
		target_laser_off (self);
	else
		target_laser_on (self);
}

// Assembly:
movq %rdx, 0x2b0(%rdi)
movl 0x140(%rdi), %eax
testb $0x1, %al
je 0x18be0
andl $-0x2, %eax
movl %eax, 0x140(%rdi)
orb $0x1, 0xc8(%rdi)
movl $0x0, 0x200(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_lightramp_think
void target_lightramp_think (edict_t *self)
{
	char	style[2];

	style[0] = 'a' + self->movedir[0] + (level.time - self->timestamp) / FRAMETIME * self->movedir[2];
	style[1] = 0;
	gi.configstring (CS_LIGHTS+self->enemy->style, style);

	if ((level.time - self->timestamp) < self->speed)
	{
		self->nextthink = level.time + FRAMETIME;
	}
	else if (self->spawnflags & 1)
	{
		char	temp;

		temp = self->movedir[0];
		self->movedir[0] = self->movedir[1];
		self->movedir[1] = temp;
		self->movedir[2] *= -1;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x19c(%rdi), %xmm0
addss 0x1c851(%rip), %xmm0    # 0x59f28
movq 0x2c6c2(%rip), %r14     # 0x69da0
movss 0x4(%r14), %xmm1
subss 0x144(%rdi), %xmm1
divss 0x16b9c(%rip), %xmm1    # 0x54290
mulss 0x1a4(%rdi), %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %eax
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq 0x2beea(%rip), %rax     # 0x69600
movq 0x2a0(%rdi), %rcx
movl $0x320, %edi            # imm = 0x320
addl 0x32c(%rcx), %edi
callq *0x30(%rax)
movss 0x4(%r14), %xmm0
movaps %xmm0, %xmm1
subss 0x144(%rbx), %xmm1
movss 0x190(%rbx), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x3d75b
addss 0x16b3f(%rip), %xmm0    # 0x54290
movss %xmm0, 0x200(%rbx)
jmp 0x3d7a5
testb $0x1, 0x140(%rbx)
je 0x3d7a5
cvttss2si 0x19c(%rbx), %eax
movss 0x1a0(%rbx), %xmm0
movss %xmm0, 0x19c(%rbx)
movsbl %al, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1a0(%rbx)
movss 0x1a4(%rbx), %xmm0
xorps 0x19473(%rip), %xmm0    # 0x56c10
movss %xmm0, 0x1a4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_lightramp_use
void target_lightramp_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (!self->enemy)
	{
		edict_t		*e;

		// check all the targets
		e = NULL;
		while (1)
		{
			e = G_Find (e, FOFS(targetname), self->target);
			if (!e)
				break;
			if (strcmp(e->classname, "light") != 0)
			{
				gi.dprintf("%s at %s ", self->classname, vtos(self->s.origin));
				gi.dprintf("target %s (%s at %s) is not a light\n", self->target, e->classname, vtos(e->s.origin));
			}
			else
			{
				self->enemy = e;
			}
		}

		if (!self->enemy)
		{
			gi.dprintf("%s target %s not found at %s\n", self->classname, self->target, vtos(self->s.origin));
			G_FreeEdict (self);
			return;
		}
	}

	self->timestamp = level.time;
	target_lightramp_think (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2a0(%rdi)
jne 0x3d893
movq 0x150(%rbx), %rdx
xorl %edi, %edi
movl $0x158, %esi            # imm = 0x158
callq 0x19430
testq %rax, %rax
je 0x3d889
movq %rax, %r14
leaq 0x4(%rbx), %r15
movq 0x138(%r14), %rdi
leaq 0x1d473(%rip), %rsi     # 0x5ac6d
callq 0x18b20
testl %eax, %eax
je 0x3d862
movq 0x2bdf6(%rip), %r12     # 0x69600
movq 0x8(%r12), %rbp
movq 0x138(%rbx), %r13
movq %r15, %rdi
callq 0x190a0
leaq 0x1c800(%rip), %rdi     # 0x5a025
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%rbp
movq 0x8(%r12), %r12
movq 0x150(%rbx), %r13
movq 0x138(%r14), %rbp
leaq 0x4(%r14), %rdi
callq 0x190a0
leaq 0x1c7dd(%rip), %rdi     # 0x5a02f
movq %r13, %rsi
movq %rbp, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq *%r12
jmp 0x3d869
movq %r14, 0x2a0(%rbx)
movq 0x150(%rbx), %rdx
movq %r14, %rdi
movl $0x158, %esi            # imm = 0x158
callq 0x19430
movq %rax, %r14
testq %rax, %rax
jne 0x3d7ec
cmpq $0x0, 0x2a0(%rbx)
je 0x3d8bd
movq 0x2c506(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
movss %xmm0, 0x144(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19b60
movq 0x2bd3c(%rip), %rax     # 0x69600
movq 0x8(%rax), %r12
movq 0x138(%rbx), %r14
movq 0x150(%rbx), %r15
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1c76e(%rip), %rdi     # 0x5a054
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq *%r12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_lightramp
void SP_target_lightramp (edict_t *self)
{
	if (!self->message || strlen(self->message) != 2 || self->message[0] < 'a' || self->message[0] > 'z' || self->message[1] < 'a' || self->message[1] > 'z' || self->message[0] == self->message[1])
	{
		gi.dprintf("target_lightramp has bad ramp (%s) at %s\n", self->message, vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

	if (deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}

	if (!self->target)
	{
		gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

	self->svflags |= SVF_NOCLIENT;
	self->use = target_lightramp_use;
	self->think = target_lightramp_think;

	self->movedir[0] = self->message[0] - 'a';
	self->movedir[1] = self->message[1] - 'a';
	self->movedir[2] = (self->movedir[1] - self->movedir[0]) / (self->speed / FRAMETIME);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x130(%rdi), %r14
testq %r14, %r14
je 0x3d94d
movq %r14, %rdi
callq 0x18680
cmpq $0x2, %rax
jne 0x3d94d
movb (%r14), %al
leal -0x7b(%rax), %ecx
cmpb $-0x1a, %cl
jb 0x3d94d
movb 0x1(%r14), %cl
leal -0x7b(%rcx), %edx
cmpb $-0x1a, %dl
setae %dl
cmpb %cl, %al
setne %al
testb %dl, %al
jne 0x3d980
movq 0x2bcac(%rip), %rax     # 0x69600
movq 0x8(%rax), %r15
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1c70a(%rip), %rdi     # 0x5a072
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a60
movq 0x2c539(%rip), %rax     # 0x69ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3d973
jp 0x3d973
cmpq $0x0, 0x150(%rbx)
je 0x3da1e
orb $0x1, 0xc8(%rbx)
movq 0x2be8f(%rip), %rax     # 0x69840
movq %rax, 0x228(%rbx)
movq 0x2c591(%rip), %rax     # 0x69f50
movq %rax, 0x210(%rbx)
movsbl (%r14), %eax
leal -0x61(%rax), %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss %xmm0, 0x19c(%rbx)
movsbl 0x1(%r14), %ecx
leal -0x61(%rcx), %edx
xorps %xmm0, %xmm0
cvtsi2ss %edx, %xmm0
movss %xmm0, 0x1a0(%rbx)
subl %eax, %ecx
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
movss 0x190(%rbx), %xmm1
divss 0x16884(%rip), %xmm1    # 0x54290
divss %xmm1, %xmm0
movss %xmm0, 0x1a4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2bbdb(%rip), %rax     # 0x69600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1acfe(%rip), %rdi     # 0x5873e
jmp 0x3d968
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_earthquake_think
void target_earthquake_think (edict_t *self)
{
	int		i;
	edict_t	*e;

	if (self->last_move_time < level.time)
	{
		gi.positioned_sound (self->s.origin, self, CHAN_AUTO, self->noise_index, 1.0, ATTN_NONE, 0);
		self->last_move_time = level.time + 0.5;
	}

	for (i=1, e=g_edicts+i; i < globals.num_edicts; i++,e++)
	{
		if (!e->inuse)
			continue;
		if (!e->client)
			continue;
		if (!e->groundentity)
			continue;

		e->groundentity = NULL;
		e->velocity[0] += crandom()* 150;
		e->velocity[1] += crandom()* 150;
		e->velocity[2] = self->speed * (100.0 / e->mass);
	}

	if (level.time < self->timestamp)
		self->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2c346(%rip), %r14     # 0x69da0
movss 0x4(%r14), %xmm0
ucomiss 0x250(%rdi), %xmm0
jbe 0x3daa7
movq 0x2bb90(%rip), %rax     # 0x69600
leaq 0x4(%rbx), %rdi
movl 0x2e8(%rbx), %ecx
movss 0x164a6(%rip), %xmm0    # 0x53f28
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbx, %rsi
xorl %edx, %edx
callq *0x28(%rax)
movss 0x4(%r14), %xmm0
addss 0x17965(%rip), %xmm0    # 0x55404
movss %xmm0, 0x250(%rbx)
movq 0x2c05a(%rip), %r15     # 0x69b08
cmpl $0x2, 0x8c(%r15)
jl 0x3dbff
movq 0x2ba95(%rip), %rax     # 0x69558
movl $0x760, %r12d           # imm = 0x760
addq (%rax), %r12
movl $0x1, %ebp
movl $0x7fff, %r13d          # imm = 0x7FFF
cmpl $0x0, -0x258(%r12)
je 0x3dbe9
cmpq $0x0, -0x260(%r12)
je 0x3dbe9
cmpq $0x0, (%r12)
je 0x3dbe9
movq $0x0, (%r12)
callq 0x19a20
andl %r13d, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss 0x16769(%rip), %xmm1    # 0x54288
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x19081(%rip), %xmm1    # 0x56bb0
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtss2sd -0xf8(%r12), %xmm1
movsd 0x1c3e4(%rip), %xmm2    # 0x59f30
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xf8(%r12)
callq 0x19a20
andl %r13d, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1670f(%rip), %xmm0    # 0x54288
cvtss2sd %xmm0, %xmm0
addsd 0x1902b(%rip), %xmm0    # 0x56bb0
addsd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtss2sd -0xf4(%r12), %xmm1
mulsd 0x1c392(%rip), %xmm0    # 0x59f30
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xf4(%r12)
xorps %xmm0, %xmm0
cvtss2sd 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl -0xe0(%r12), %xmm1
movsd 0x1a678(%rip), %xmm2    # 0x58248
divsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
movss %xmm0, -0xf0(%r12)
incl %ebp
addq $0x4a8, %r12            # imm = 0x4A8
cmpl 0x8c(%r15), %ebp
jl 0x3dad7
movss 0x4(%r14), %xmm0
movss 0x144(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x3dc22
addss 0x16676(%rip), %xmm0    # 0x54290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_earthquake_use
void target_earthquake_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->timestamp = level.time + self->count;
	self->nextthink = level.time + FRAMETIME;
	self->activator = activator;
	self->last_move_time = 0;
}

// Assembly:
movq 0x2c168(%rip), %rax     # 0x69da0
cvtsi2ssl 0x290(%rdi), %xmm0
movss 0x4(%rax), %xmm1
addss %xmm1, %xmm0
addss 0x1663f(%rip), %xmm1    # 0x54290
movss %xmm0, 0x144(%rdi)
movss %xmm1, 0x200(%rdi)
movq %rdx, 0x2b0(%rdi)
movl $0x0, 0x250(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_earthquake
void SP_target_earthquake (edict_t *self)
{
	if (!self->targetname)
		gi.dprintf("untargeted %s at %s\n", self->classname, vtos(self->s.origin));

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

	if (!self->speed)
		self->speed = 200;

	self->svflags |= SVF_NOCLIENT;
	self->think = target_earthquake_think;
	self->use = target_earthquake_use;

	self->noise_index = gi.soundindex ("world/quake.wav");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x158(%rdi)
jne 0x3dcb2
movq 0x2b974(%rip), %rax     # 0x69600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1c3f5(%rip), %rdi     # 0x5a09c
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
cmpl $0x0, 0x290(%rbx)
jne 0x3dcc5
movl $0x5, 0x290(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3dce1
jp 0x3dce1
movl $0x43480000, 0x190(%rbx) # imm = 0x43480000
orb $0x1, 0xc8(%rbx)
movq 0x2b7f9(%rip), %rax     # 0x694e8
movq %rax, 0x210(%rbx)
movq 0x2bbd3(%rip), %rax     # 0x698d0
movq %rax, 0x228(%rbx)
movq 0x2b8f5(%rip), %rax     # 0x69600
leaq 0x1c39f(%rip), %rdi     # 0x5a0b1
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: InitTrigger
void InitTrigger (edict_t *self)
{
	if (!VectorCompare (self->s.angles, vec3_origin))
		G_SetMovedir (self->s.angles, self->movedir);

	self->solid = SOLID_TRIGGER;
	self->movetype = MOVETYPE_NONE;
	gi.setmodel (self, self->model);
	self->svflags = SVF_NOCLIENT;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x2ba32(%rip), %rsi     # 0x69768
movq %r14, %rdi
callq 0x18b70
testl %eax, %eax
jne 0x3dd51
leaq 0x19c(%rbx), %rsi
movq %r14, %rdi
callq 0x19630
movl $0x1, %ebp
movl %ebp, 0x108(%rbx)
movl $0x0, 0x118(%rbx)
movq 0x2b893(%rip), %rax     # 0x69600
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
callq *0x58(%rax)
movl %ebp, 0xc8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: multi_trigger
void multi_trigger (edict_t *ent)
{
	if (ent->nextthink)
		return;		// already been triggered

	G_UseTargets (ent, ent->activator);

	if (ent->wait > 0)	
	{
		ent->think = multi_wait;
		ent->nextthink = level.time + ent->wait;
	}
	else
	{	// we can't just remove (self) here, because this is a touch function
		// called while looping through area links...
		ent->touch = NULL;
		ent->nextthink = level.time + FRAMETIME;
		ent->think = G_FreeEdict;
	}
}

// Assembly:
movss 0x200(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3dda2
jnp 0x3dda3
retq
pushq %rbx
movq %rdi, %rbx
movq 0x2b0(%rdi), %rsi
callq 0x198f0
movss 0x2f8(%rbx), %xmm0
ucomiss 0x16b9e(%rip), %xmm0    # 0x54960
jbe 0x3dde8
movq 0x2c08d(%rip), %rax     # 0x69e58
movq %rax, 0x210(%rbx)
movq 0x2bfc7(%rip), %rax     # 0x69da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
jmp 0x3de1d
movq $0x0, 0x220(%rbx)
movq 0x2bfa6(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
addss 0x16489(%rip), %xmm0    # 0x54290
movss %xmm0, 0x200(%rbx)
movq 0x2b61a(%rip), %rax     # 0x69430
movq %rax, 0x210(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: Touch_Multi
void Touch_Multi (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if(other->client)
	{
		if (self->spawnflags & 2)
			return;
	}
	else if (other->svflags & SVF_MONSTER)
	{
		if (!(self->spawnflags & 1))
			return;
	}
	else
		return;

	if (!VectorCompare(self->movedir, vec3_origin))
	{
		vec3_t	forward;

		AngleVectors(other->s.angles, forward, NULL, NULL);
		if (_DotProduct(forward, self->movedir) < 0)
			return;
	}

	self->activator = other;
	multi_trigger (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x58(%rsi)
je 0x3de4e
testb $0x2, 0x140(%rbx)
je 0x3de61
jmp 0x3deb2
testb $0x4, 0xc8(%r14)
je 0x3deb2
testb $0x1, 0x140(%rbx)
je 0x3deb2
leaq 0x19c(%rbx), %r15
movq 0x2b8f9(%rip), %rsi     # 0x69768
movq %r15, %rdi
callq 0x18b70
testl %eax, %eax
jne 0x3dea3
leaq 0x10(%r14), %rdi
leaq 0xc(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x183a0
movq %r12, %rdi
movq %r15, %rsi
callq 0x18650
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x3deb2
movq %r14, 0x2b0(%rbx)
movq %rbx, %rdi
callq 0x19390
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq