LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_multiple
void SP_trigger_multiple (edict_t *ent)
{
	if (ent->sounds == 1)
		ent->noise_index = gi.soundindex ("misc/secret.wav");
	else if (ent->sounds == 2)
		ent->noise_index = gi.soundindex ("misc/talk.wav");
	else if (ent->sounds == 3)
		ent->noise_index = gi.soundindex ("misc/trigger1.wav");
	
	if (!ent->wait)
		ent->wait = 0.2f;
	ent->touch = Touch_Multi;
	ent->movetype = MOVETYPE_NONE;
	ent->svflags |= SVF_NOCLIENT;


	if (ent->spawnflags & 4)
	{
		ent->solid = SOLID_NOT;
		ent->use = trigger_enable;
	}
	else
	{
		ent->solid = SOLID_TRIGGER;
		ent->use = Use_Multi;
	}

	if (!VectorCompare(ent->s.angles, vec3_origin))
		G_SetMovedir (ent->s.angles, ent->movedir);

	gi.setmodel (ent, ent->model);
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28c(%rdi), %eax
decl %eax
cmpl $0x2, %eax
ja 0x3df17
movl %eax, %eax
leaq 0x1c308(%rip), %rcx     # 0x5a208
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
movq 0x2b6f2(%rip), %rax     # 0x69600
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movss 0x2f8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3df33
jp 0x3df33
movl $0x3e4ccccd, 0x2f8(%rbx) # imm = 0x3E4CCCCD
movq 0x2bf46(%rip), %rax     # 0x69e80
movq %rax, 0x220(%rbx)
movl $0x0, 0x118(%rbx)
orb $0x1, 0xc8(%rbx)
movl 0x140(%rbx), %ecx
andl $0x4, %ecx
movl %ecx, %eax
shrl $0x2, %eax
xorl $0x1, %eax
testl %ecx, %ecx
jne 0x3df70
movq 0x2bd7a(%rip), %rcx     # 0x69ce8
jmp 0x3df77
movq 0x2bbf1(%rip), %rcx     # 0x69b68
movl %eax, 0x108(%rbx)
movq %rcx, 0x228(%rbx)
leaq 0x10(%rbx), %r14
movq 0x2b7d9(%rip), %rsi     # 0x69768
movq %r14, %rdi
callq 0x18b70
testl %eax, %eax
jne 0x3dfaa
leaq 0x19c(%rbx), %rsi
movq %r14, %rdi
callq 0x19630
movq 0x2b64f(%rip), %r14     # 0x69600
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
callq *0x58(%r14)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_once
void SP_trigger_once(edict_t *ent)
{
	// make old maps work because I messed up on flag assignments here
	// triggered was on bit 1 when it should have been on bit 4
	if (ent->spawnflags & 1)
	{
		vec3_t	v;

		VectorMA (ent->mins, 0.5, ent->size, v);
		ent->spawnflags &= ~1;
		ent->spawnflags |= 4;
		gi.dprintf("fixed TRIGGERED flag on %s at %s\n", ent->classname, vtos(v));
	}

	ent->wait = -1;
	SP_trigger_multiple (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testb $0x1, 0x140(%rdi)
je 0x3e04a
leaq 0xcc(%rbx), %rdi
leaq 0xfc(%rbx), %rsi
movss 0x17405(%rip), %xmm0    # 0x55404
leaq 0xc(%rsp), %r14
movq %r14, %rdx
callq 0x19770
movl 0x140(%rbx), %eax
andl $-0x6, %eax
orl $0x4, %eax
movl %eax, 0x140(%rbx)
movq 0x2b5db(%rip), %rax     # 0x69600
movq 0x8(%rax), %r12
movq 0x138(%rbx), %r15
movq %r14, %rdi
callq 0x190a0
leaq 0x1c09f(%rip), %rdi     # 0x5a0de
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r12
movl $0xbf800000, 0x2f8(%rbx) # imm = 0xBF800000
movq %rbx, %rdi
callq 0x18f80
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_key
void SP_trigger_key (edict_t *self)
{
	if (!st.item)
	{
		gi.dprintf("no key item for trigger_key at %s\n", vtos(self->s.origin));
		return;
	}
	self->item = FindItemByClassname (st.item);

	if (!self->item)
	{
		gi.dprintf("item %s not found for trigger_key at %s\n", st.item, vtos(self->s.origin));
		return;
	}

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

	gi.soundindex ("misc/keytry.wav");
	gi.soundindex ("misc/keyuse.wav");

	self->use = trigger_key_use;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2b38d(%rip), %r14     # 0x69668
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x3e334
callq 0x18170
movq %rax, 0x330(%rbx)
testq %rax, %rax
je 0x3e361
cmpq $0x0, 0x150(%rbx)
je 0x3e385
movq 0x2b2f6(%rip), %r14     # 0x69600
leaq 0x1bdff(%rip), %rdi     # 0x5a110
callq *0x48(%r14)
leaq 0x1be04(%rip), %rdi     # 0x5a120
callq *0x48(%r14)
movq 0x2bbb1(%rip), %rax     # 0x69ed8
movq %rax, 0x228(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b2c5(%rip), %rax     # 0x69600
movq 0x8(%rax), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x190a0
leaq 0x1bdde(%rip), %rdi     # 0x5a130
movq %rax, %rsi
xorl %eax, %eax
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
movq 0x2b298(%rip), %rax     # 0x69600
movq 0x8(%rax), %r15
movq 0x40(%r14), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x190a0
leaq 0x1bdd0(%rip), %rdi     # 0x5a153
jmp 0x3e3aa
movq 0x2b274(%rip), %rax     # 0x69600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x190a0
leaq 0x1bdd2(%rip), %rdi     # 0x5a17c
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: trigger_counter_use
void trigger_counter_use(edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->count == 0)
		return;
	
	self->count--;

	if (self->count)
	{
		if (! (self->spawnflags & 1))
		{
			gi.centerprintf(activator, "%i more to go...", self->count);
			gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
		}
		return;
	}
	
	if (! (self->spawnflags & 1))
	{
		gi.centerprintf(activator, "Sequence completed!");
		gi.sound (activator, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
	}
	self->activator = activator;
	multi_trigger (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x290(%rdi), %edx
testl %edx, %edx
je 0x3e433
movq %rdi, %r14
decl %edx
movl %edx, 0x290(%rdi)
movl 0x140(%rdi), %eax
je 0x3e43f
testb $0x1, %al
jne 0x3e433
movq 0x2b211(%rip), %r14     # 0x69600
leaq 0x1bd9e(%rip), %rsi     # 0x5a194
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r14)
movq 0x20(%r14), %r15
leaq 0x1888d(%rip), %rdi     # 0x56c97
callq *0x48(%r14)
movss 0x15b12(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %al
jne 0x3e481
movq 0x2b1b6(%rip), %r15     # 0x69600
leaq 0x1bd54(%rip), %rsi     # 0x5a1a5
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r15)
movq 0x20(%r15), %r12
leaq 0x18832(%rip), %rdi     # 0x56c97
callq *0x48(%r15)
movss 0x15ab7(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r12
movq %rbx, 0x2b0(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19390
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_counter
void SP_trigger_counter (edict_t *self)
{
	self->wait = -1;
	if (!self->count)
		self->count = 2;

	self->use = trigger_counter_use;
}

// Assembly:
movl $0xbf800000, 0x2f8(%rdi) # imm = 0xBF800000
cmpl $0x0, 0x290(%rdi)
jne 0x3e4b8
movl $0x2, 0x290(%rdi)
movq 0x2b4d1(%rip), %rax     # 0x69990
movq %rax, 0x228(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: trigger_push_touch
void trigger_push_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (strcmp(other->classname, "grenade") == 0)
	{
		VectorScale (self->movedir, self->speed * 10, other->velocity);
	}
	else if (other->health > 0)
	{
		VectorScale (self->movedir, self->speed * 10, other->velocity);

		if (other->client)
		{
			// don't take falling damage immediately from this
			VectorCopy (other->velocity, other->client->oldvelocity);
			if (other->fly_sound_debounce_time < level.time)
			{
				other->fly_sound_debounce_time = level.time + 1.5;
				gi.sound (other, CHAN_AUTO, windsound, 1, ATTN_NORM, 0);
			}
		}
	}
	if (self->spawnflags & PUSH_ONCE)
		G_FreeEdict (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x138(%rsi), %rdi
leaq 0x1c7df(%rip), %rsi     # 0x5ace1
callq 0x18b20
testl %eax, %eax
je 0x3e5cc
cmpl $0x0, 0x254(%r14)
jle 0x3e5f2
leaq 0x19c(%rbx), %rdi
movss 0x190(%rbx), %xmm0
mulss 0x159e0(%rip), %xmm0    # 0x53f14
leaq 0x1c0(%r14), %rsi
callq 0x189d0
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x3e5f2
movss 0x1c0(%r14), %xmm0
movss %xmm0, 0xed8(%rax)
movss 0x1c4(%r14), %xmm0
movss %xmm0, 0xedc(%rax)
movss 0x1c8(%r14), %xmm0
movss %xmm0, 0xee0(%rax)
movq 0x2b819(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
ucomiss 0x24c(%r14), %xmm0
jbe 0x3e5f2
addss 0x1666a(%rip), %xmm0    # 0x54c08
movss %xmm0, 0x24c(%r14)
movq 0x2b052(%rip), %rax     # 0x69600
movl 0x5381c(%rip), %edx     # 0x91dd0
movss 0x1596c(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %r14, %rdi
xorl %esi, %esi
movaps %xmm0, %xmm1
callq *0x20(%rax)
jmp 0x3e5f2
leaq 0x19c(%rbx), %rdi
movss 0x190(%rbx), %xmm0
mulss 0x15931(%rip), %xmm0    # 0x53f14
addq $0x1c0, %r14            # imm = 0x1C0
movq %r14, %rsi
callq 0x189d0
testb $0x1, 0x140(%rbx)
jne 0x3e603
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a60
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_push
void SP_trigger_push (edict_t *self)
{
	InitTrigger (self);
	windsound = gi.soundindex ("misc/windfly.wav");
	self->touch = trigger_push_touch;
	if (!self->speed)
		self->speed = 1000;
	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x184f0
movq 0x2afdb(%rip), %rax     # 0x69600
leaq 0x1bb8d(%rip), %rdi     # 0x5a1b9
movq %rax, %r14
callq *0x48(%rax)
movl %eax, 0x53798(%rip)     # 0x91dd0
movq 0x2b901(%rip), %rax     # 0x69f40
movq %rax, 0x220(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3e662
jp 0x3e662
movl $0x447a0000, 0x190(%rbx) # imm = 0x447A0000
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: hurt_use
void hurt_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->solid == SOLID_NOT)
		self->solid = SOLID_TRIGGER;
	else
		self->solid = SOLID_NOT;
	gi.linkentity (self);

	if (!(self->spawnflags & 2))
		self->use = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x0, 0x108(%rdi)
sete %al
movl %eax, 0x108(%rdi)
movq 0x2af6e(%rip), %rax     # 0x69600
callq *0x90(%rax)
testb $0x2, 0x140(%rbx)
jne 0x3e6ac
movq $0x0, 0x228(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: hurt_touch
void hurt_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	int		dflags;

	if (!other->takedamage)
		return;

	if (self->timestamp > level.time)
		return;

	if (self->spawnflags & 16)
		self->timestamp = level.time + 1;
	else
		self->timestamp = level.time + FRAMETIME;

	if (!(self->spawnflags & 4))
	{
		if ((level.framenum % 10) == 0)
			gi.sound (other, CHAN_AUTO, self->noise_index, 1, ATTN_NORM, 0);
	}

	if (self->spawnflags & 8)
		dflags = DAMAGE_NO_PROTECTION;
	else
		dflags = 0;
	T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, self->dmg, self->dmg, dflags, MOD_TRIGGER_HURT);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x27c(%rsi)
je 0x3e6d7
movq %rdi, %rbx
movss 0x144(%rdi), %xmm1
movq 0x2b6d3(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x3e6e0
addq $0x8, %rsp
jmp 0x3e77a
movq %rsi, %r14
movl 0x140(%rbx), %ecx
xorl %edx, %edx
testb $0x10, %cl
sete %dl
leaq 0x1b9cc(%rip), %rsi     # 0x5a0c4
addss (%rsi,%rdx,4), %xmm0
movss %xmm0, 0x144(%rbx)
testb $0x4, %cl
jne 0x3e740
imull $0xcccccccd, (%rax), %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx       # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x3e740
movq 0x2aedc(%rip), %rax     # 0x69600
movl 0x2e8(%rbx), %edx
movss 0x157f6(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %r14, %rdi
xorl %esi, %esi
movaps %xmm0, %xmm1
callq *0x20(%rax)
movl 0x140(%rbx), %eax
movl 0x280(%rbx), %r10d
shll $0x2, %eax
andl $0x20, %eax
leaq 0x4(%r14), %r8
movq 0x2b00a(%rip), %rcx     # 0x69768
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x1f
pushq %rax
pushq %r10
pushq %r10
callq 0x190f0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_hurt
void SP_trigger_hurt (edict_t *self)
{
	InitTrigger (self);

	self->noise_index = gi.soundindex ("world/electro.wav");
	self->touch = hurt_touch;

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

	if (self->spawnflags & 1)
		self->solid = SOLID_NOT;
	else
		self->solid = SOLID_TRIGGER;

	if (self->spawnflags & 2)
		self->use = hurt_use;

	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x184f0
movq 0x2ae6f(%rip), %rax     # 0x69600
leaq 0x1ba32(%rip), %rdi     # 0x5a1ca
movq %rax, %r14
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movq 0x2ae9d(%rip), %rax     # 0x69648
movq %rax, 0x220(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x3e7c5
movl $0x5, 0x280(%rbx)
movl 0x140(%rbx), %eax
movl %eax, %ecx
notl %ecx
andl $0x1, %ecx
movl %ecx, 0x108(%rbx)
testb $0x2, %al
je 0x3e7ea
movq 0x2b63d(%rip), %rax     # 0x69e20
movq %rax, 0x228(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_gravity
void SP_trigger_gravity (edict_t *self)
{
	if (st.gravity == 0)
	{
		gi.dprintf("trigger_gravity without gravity set at %s\n", vtos(self->s.origin));
		G_FreeEdict  (self);
		return;
	}

	InitTrigger (self);
	self->gravity = atoi(st.gravity);
	self->touch = trigger_gravity_touch;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2ae4c(%rip), %r14     # 0x69668
cmpq $0x0, 0x48(%r14)
je 0x3e856
movq %rbx, %rdi
callq 0x184f0
movq 0x48(%r14), %rdi
callq 0x195e0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1e0(%rbx)
movq 0x2b369(%rip), %rax     # 0x69bb0
movq %rax, 0x220(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2ada3(%rip), %rax     # 0x69600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x1b96b(%rip), %rdi     # 0x5a1dc
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_trigger.c
// Function: trigger_monsterjump_touch
void trigger_monsterjump_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (other->flags & (FL_FLY | FL_SWIM) )
		return;
	if (other->svflags & SVF_DEADMONSTER)
		return;
	if ( !(other->svflags & SVF_MONSTER))
		return;

// set XY even if not on ground, so the jump will clear lips
	other->velocity[0] = self->movedir[0] * self->speed;
	other->velocity[1] = self->movedir[1] * self->speed;
	
	if (!other->groundentity)
		return;
	
	other->groundentity = NULL;
	other->velocity[2] = self->movedir[2];
}

// Assembly:
testb $0x3, 0x11c(%rsi)
je 0x3e892
retq
movl 0xc8(%rsi), %eax
andl $0x6, %eax
cmpl $0x4, %eax
jne 0x3e891
movss 0x19c(%rdi), %xmm0
mulss 0x190(%rdi), %xmm0
movss %xmm0, 0x1c0(%rsi)
movss 0x1a0(%rdi), %xmm0
mulss 0x190(%rdi), %xmm0
movss %xmm0, 0x1c4(%rsi)
cmpq $0x0, 0x2b8(%rsi)
je 0x3e891
movq $0x0, 0x2b8(%rsi)
movss 0x1a4(%rdi), %xmm0
movss %xmm0, 0x1c8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: SP_trigger_monsterjump
void SP_trigger_monsterjump (edict_t *self)
{
	if (!self->speed)
		self->speed = 200;
	if (!st.height)
		st.height = 200;
	if (self->s.angles[YAW] == 0)
		self->s.angles[YAW] = 360;
	InitTrigger (self);
	self->touch = trigger_monsterjump_touch;
	self->movedir[2] = st.height;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3e919
jp 0x3e919
movl $0x43480000, 0x190(%rbx) # imm = 0x43480000
movq 0x2ad48(%rip), %r14     # 0x69668
cmpl $0x0, 0x28(%r14)
jne 0x3e92f
movl $0xc8, 0x28(%r14)
movss 0x14(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jne 0x3e942
jp 0x3e942
movl $0x43b40000, 0x14(%rbx) # imm = 0x43B40000
movq %rbx, %rdi
callq 0x184f0
movq 0x2ad8f(%rip), %rax     # 0x696e0
movq %rax, 0x220(%rbx)
xorps %xmm0, %xmm0
cvtsi2ssl 0x28(%r14), %xmm0
movss %xmm0, 0x1a4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_Find
edict_t *G_Find (edict_t *from, int fieldofs, char *match)
{
	char	*s;

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

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

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x4a8(%rdi), %rbx
testq %rdi, %rdi
movq 0x2ab62(%rip), %r15     # 0x69558
movq (%r15), %rax
cmoveq %rax, %rbx
movq 0x2b104(%rip), %r12     # 0x69b08
movslq 0x8c(%r12), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rax, %rcx
cmpq %rcx, %rbx
jae 0x3ea5a
movq %rdx, %r14
movslq %esi, %r13
cmpl $0x0, 0x60(%rbx)
je 0x3ea3c
movq (%rbx,%r13), %rdi
testq %rdi, %rdi
je 0x3ea3c
movq %r14, %rsi
callq 0x18690
testl %eax, %eax
je 0x3ea5c
addq $0x4a8, %rbx            # imm = 0x4A8
movslq 0x8c(%r12), %rax
imulq $0x4a8, %rax, %rax      # imm = 0x4A8
addq (%r15), %rax
cmpq %rax, %rbx
jb 0x3ea21
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: findradius
edict_t *findradius (edict_t *from, vec3_t org, float rad)
{
	vec3_t	eorg;
	int		j;

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

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, (%rsp)
leaq 0x4a8(%rdi), %rbx
testq %rdi, %rdi
movq 0x2aacc(%rip), %r12     # 0x69558
movq (%r12), %rax
cmoveq %rax, %rbx
movq 0x2b06d(%rip), %r13     # 0x69b08
movslq 0x8c(%r13), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rax, %rcx
cmpq %rcx, %rbx
jae 0x3eb3f
movq %rsi, %r14
movss 0x16944(%rip), %xmm2    # 0x55404
leaq 0x4(%rsp), %r15
cmpl $0x0, 0x60(%rbx)
je 0x3eb21
cmpl $0x0, 0x108(%rbx)
je 0x3eb21
xorl %eax, %eax
movss 0xcc(%rbx,%rax,4), %xmm0
addss 0xd8(%rbx,%rax,4), %xmm0
movss (%r14,%rax,4), %xmm1
mulss %xmm2, %xmm0
addss 0x4(%rbx,%rax,4), %xmm0
subss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ead6
movq %r15, %rdi
callq 0x192e0
movss 0x168e9(%rip), %xmm2    # 0x55404
ucomiss (%rsp), %xmm0
jbe 0x3eb41
addq $0x4a8, %rbx            # imm = 0x4A8
movslq 0x8c(%r13), %rax
imulq $0x4a8, %rax, %rax      # imm = 0x4A8
addq (%r12), %rax
cmpq %rax, %rbx
jb 0x3eac5
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: findallradius
edict_t *findallradius (edict_t *from, vec3_t org, float rad)
{
	vec3_t	eorg;
	int		j;

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

	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, (%rsp)
leaq 0x4a8(%rdi), %rbx
testq %rdi, %rdi
movq 0x2a9e3(%rip), %r12     # 0x69558
movq (%r12), %rax
cmoveq %rax, %rbx
movq 0x2af84(%rip), %r13     # 0x69b08
movslq 0x8c(%r13), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rax, %rcx
cmpq %rcx, %rbx
jae 0x3ec1f
movq %rsi, %r14
movss 0x1685b(%rip), %xmm2    # 0x55404
leaq 0x4(%rsp), %r15
cmpl $0x0, 0x60(%rbx)
je 0x3ec01
xorl %eax, %eax
movss 0xcc(%rbx,%rax,4), %xmm0
addss 0xd8(%rbx,%rax,4), %xmm0
movss (%r14,%rax,4), %xmm1
mulss %xmm2, %xmm0
addss 0x4(%rbx,%rax,4), %xmm0
subss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ebb6
movq %r15, %rdi
callq 0x192e0
movss 0x16809(%rip), %xmm2    # 0x55404
ucomiss (%rsp), %xmm0
jbe 0x3ec21
addq $0x4a8, %rbx            # imm = 0x4A8
movslq 0x8c(%r13), %rax
imulq $0x4a8, %rax, %rax      # imm = 0x4A8
addq (%r12), %rax
cmpq %rax, %rbx
jb 0x3ebae
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_PickTarget
edict_t *G_PickTarget (char *targetname)
{
	edict_t	*ent = NULL;
	int		num_choices = 0;
	edict_t	*choice[MAXCHOICES];

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

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

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

	return choice[rand() % num_choices];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
testq %rdi, %rdi
je 0x3ec85
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %eax, %eax
movq %rax, %rdi
movl $0x158, %esi            # imm = 0x158
movq %rbx, %rdx
callq 0x19430
testq %rax, %rax
je 0x3ec6e
movq %rax, (%rsp,%r14,8)
incq %r14
cmpq $0x8, %r14
jne 0x3ec46
movl $0x8, %r14d
testl %r14d, %r14d
je 0x3ec9d
callq 0x19a20
cltd
idivl %r14d
movslq %edx, %rax
movq (%rsp,%rax,8), %r14
jmp 0x3ecb6
movq 0x2a974(%rip), %rcx     # 0x69600
leaq 0x1b5ad(%rip), %rdi     # 0x5a240
xorl %r14d, %r14d
xorl %eax, %eax
callq *0x8(%rcx)
jmp 0x3ecb6
movq 0x2a95c(%rip), %rcx     # 0x69600
leaq 0x1b5bf(%rip), %rdi     # 0x5a26a
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq *0x8(%rcx)
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_FreeEdict
void G_FreeEdict (edict_t *ed)
{
	gi.unlinkentity (ed);		// unlink from world

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

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2a6b9(%rip), %rax     # 0x69600
callq *0x98(%rax)
movq 0x2a604(%rip), %rax     # 0x69558
movq %rbx, %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
movabsq $-0x20a4f089731d3543, %rax # imm = 0xDF5B0F768CE2CABD
imulq %rcx, %rax
cvtsi2ss %rax, %xmm0
movq 0x2a5b8(%rip), %rax     # 0x69530
movq (%rax), %rax
movss 0x20(%rax), %xmm1
addss 0x14f70(%rip), %xmm1    # 0x53ef8
ucomiss %xmm0, %xmm1
jae 0x3efc5
movl $0x4a8, %edx            # imm = 0x4A8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x18880
leaq 0x1b3b2(%rip), %rax     # 0x5a355
movq %rax, 0x138(%rbx)
movq 0x2adef(%rip), %rax     # 0x69da0
movss 0x4(%rax), %xmm0
movss %xmm0, 0x128(%rbx)
movl $0x0, 0x60(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_Spawn
edict_t *G_Spawn (void)
{
	int			i;
	edict_t		*e;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x2a582(%rip), %r14     # 0x69558
movq 0x2a553(%rip), %rax     # 0x69530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
cvttss2si %xmm0, %eax
cltq
imulq $0x4a8, %rax, %r12      # imm = 0x4A8
addq (%r14), %r12
addss 0x14f2b(%rip), %xmm0    # 0x53f28
cvttss2si %xmm0, %edx
movq 0x2ab00(%rip), %r15     # 0x69b08
movl 0x8c(%r15), %eax
leaq 0x4a8(%r12), %rbx
movl %eax, %ecx
subl %edx, %ecx
jle 0x3f074
movq 0x2ad7c(%rip), %rdx     # 0x69da0
movss 0x4(%rdx), %xmm0
movss 0x15427(%rip), %xmm1    # 0x54458
movss 0x163cb(%rip), %xmm2    # 0x55404
cmpl $0x0, 0x60(%rbx)
jne 0x3f060
movss 0x128(%rbx), %xmm3
ucomiss %xmm3, %xmm1
ja 0x3f0e7
movaps %xmm0, %xmm4
subss %xmm3, %xmm4
ucomiss %xmm2, %xmm4
ja 0x3f0e7
addq $0x4a8, %rbx            # imm = 0x4A8
decl %ecx
jne 0x3f039
leaq -0x4a8(%rbx), %r12
jmp 0x3f076
movl %edx, %eax
movq 0x2acc3(%rip), %rcx     # 0x69d40
cmpl 0x614(%rcx), %eax
jne 0x3f098
movq 0x2a574(%rip), %rcx     # 0x69600
leaq 0x1b2a9(%rip), %rdi     # 0x5a33c
xorl %eax, %eax
callq *0x38(%rcx)
incl 0x8c(%r15)
movl $0x1, 0x508(%r12)
leaq 0x1b282(%rip), %rax     # 0x5a334
movq %rax, 0x5e0(%r12)
movl $0x3f800000, 0x688(%r12) # imm = 0x3F800000
movq %rbx, %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0x8ce2cabd, %eax, %eax # imm = 0x8CE2CABD
movl %eax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq -0x4a8(%rbx), %r12
jmp 0x3f09f
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: vtos
char	*vtos (vec3_t v)
{
	static	int		index;
	static	char	str[8][32];
	char	*s;

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

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

	return s;
}

// Assembly:
pushq %rbx
movl 0x52d1a(%rip), %eax     # 0x91e40
leal 0x1(%rax), %ecx
shlq $0x5, %rax
andl $0x7, %ecx
movl %ecx, 0x52d0a(%rip)     # 0x91e40
cvttss2si (%rdi), %ecx
leaq 0x52d0f(%rip), %rbx     # 0x91e50
cvttss2si 0x4(%rdi), %r8d
addq %rax, %rbx
cvttss2si 0x8(%rdi), %r9d
leaq 0x1b1d2(%rip), %rdx     # 0x5a329
movq %rbx, %rdi
movl $0x20, %esi
xorl %eax, %eax
callq 0x18e10
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_SetMovedir
void G_SetMovedir (vec3_t angles, vec3_t movedir)
{
	if (VectorCompare (angles, VEC_UP))
	{
		VectorCopy (MOVEDIR_UP, movedir);
	}
	else if (VectorCompare (angles, VEC_DOWN))
	{
		VectorCopy (MOVEDIR_DOWN, movedir);
	}
	else
	{
		AngleVectors (angles, movedir, NULL, NULL);
	}

	VectorClear (angles);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2aa54(%rip), %rsi     # 0x69bd0
callq 0x18b70
testl %eax, %eax
je 0x3f18e
movq 0x2a3ac(%rip), %rax     # 0x69538
jmp 0x3f1a8
movq 0x2addb(%rip), %rsi     # 0x69f70
movq %rbx, %rdi
callq 0x18b70
testl %eax, %eax
je 0x3f1dd
movq 0x2a238(%rip), %rax     # 0x693e0
movss (%rax), %xmm0
movss %xmm0, (%r14)
movss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%r14)
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%r14)
movl $0x0, 0x8(%rbx)
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x183a0
jmp 0x3f1c7
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: vectoyaw
float vectoyaw (vec3_t vec)
{
	float	yaw;
	
	if (/*vec[YAW] == 0 &&*/ vec[PITCH] == 0) 
	{
		yaw = 0;
		if (vec[YAW] > 0)
			yaw = 90;
		else if (vec[YAW] < 0)
			yaw = -90;
	} 
	else
	{
		yaw = (int) (atan2(vec[YAW], vec[PITCH]) * 180 / M_PI);
		if (yaw < 0)
			yaw += 360;
	}

	return yaw;
}

// Assembly:
pushq %rax
movss (%rdi), %xmm2
movss 0x4(%rdi), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
jne 0x3f211
jp 0x3f211
ucomiss %xmm0, %xmm1
jbe 0x3f24d
movss 0x1b005(%rip), %xmm0    # 0x5a214
jmp 0x3f25a
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
callq 0x190b0
mulsd 0x1aff4(%rip), %xmm0    # 0x5a220
divsd 0x1aff4(%rip), %xmm0    # 0x5a228
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
testl %eax, %eax
jns 0x3f25a
addss 0x15ad9(%rip), %xmm0    # 0x54d24
jmp 0x3f25a
ucomiss %xmm1, %xmm0
jbe 0x3f25a
movss 0x1afbe(%rip), %xmm0    # 0x5a218
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: vectoangles
void vectoangles (vec3_t value1, vec3_t angles)
{
	float	forward;
	float	yaw, pitch;
	
	if (value1[1] == 0 && value1[0] == 0)
	{
		yaw = 0;
		if (value1[2] > 0)
			pitch = 90;
		else
			pitch = 270;
	}
	else
	{
		if (value1[0])
			yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
		else if (value1[1] > 0)
			yaw = 90;
		else
			yaw = -90;
		if (yaw < 0)
			yaw += 360;

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

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movss 0x4(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3f2a3
jp 0x3f2a3
movss (%r14), %xmm2
ucomiss %xmm1, %xmm2
jne 0x3f2a3
jp 0x3f2a3
movss 0x8(%r14), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
leaq 0x1af9f(%rip), %rcx     # 0x5a238
movss (%rcx,%rax,4), %xmm0
jmp 0x3f37a
movss (%r14), %xmm2
ucomiss %xmm1, %xmm2
jne 0x3f2af
jnp 0x3f2d8
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
callq 0x190b0
mulsd 0x1af59(%rip), %xmm0    # 0x5a220
divsd 0x1af59(%rip), %xmm0    # 0x5a228
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
jmp 0x3f2ec
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
leaq 0x1af49(%rip), %rcx     # 0x5a230
movss (%rcx,%rax,4), %xmm0
movss 0x15a30(%rip), %xmm1    # 0x54d24
addss %xmm0, %xmm1
xorps %xmm2, %xmm2
movaps %xmm0, %xmm3
cmpltss %xmm2, %xmm3
andps %xmm3, %xmm1
andnps %xmm0, %xmm3
orps %xmm1, %xmm3
movaps %xmm3, (%rsp)
movss (%r14), %xmm0
movss 0x4(%r14), %xmm1
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
ucomiss %xmm2, %xmm0
jb 0x3f332
sqrtss %xmm0, %xmm0
jmp 0x3f337
callq 0x18e80
xorps %xmm2, %xmm2
cvtss2sd 0x8(%r14), %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movaps %xmm2, %xmm0
callq 0x190b0
mulsd 0x1aec9(%rip), %xmm0    # 0x5a220
divsd 0x1aec9(%rip), %xmm0    # 0x5a228
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
testl %eax, %eax
jns 0x3f376
addss 0x159ae(%rip), %xmm0    # 0x54d24
movaps (%rsp), %xmm1
xorps 0x1788f(%rip), %xmm0    # 0x56c10
movss %xmm0, (%rbx)
movss %xmm1, 0x4(%rbx)
movl $0x0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: G_InitEdict
void G_InitEdict (edict_t *e)
{
	e->inuse = true;
	e->classname = "noclass";
	e->gravity = 1.0;
	e->s.number = e - g_edicts;
}

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

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

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

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

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

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

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

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

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

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

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

	return true;		// all clear
}

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

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

	}
	gi.dprintf(elsemessage);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
movq 0x2a76c(%rip), %r15     # 0x69d40
cmpl $0x0, 0x610(%r15)
jle 0x3f63c
movl %edi, %ebp
movl $0x4a8, %r12d           # imm = 0x4A8
movq 0x29f6b(%rip), %r13     # 0x69558
xorl %r14d, %r14d
movq (%r13), %rdi
cmpl $0x0, 0x60(%rdi,%r12)
je 0x3f626
movq 0x58(%rdi,%r12), %rax
addq %r12, %rdi
cmpl %ebp, 0x1100(%rax)
jne 0x3f612
movq (%rsp), %rsi
jmp 0x3f61a
testq %rbx, %rbx
je 0x3f626
movq %rbx, %rsi
xorl %eax, %eax
movq 0x29fdd(%rip), %rcx     # 0x69600
callq *0x18(%rcx)
incq %r14
movslq 0x610(%r15), %rax
addq $0x4a8, %r12            # imm = 0x4A8
cmpq %rax, %r14
jl 0x3f5f0
movq 0x29fbd(%rip), %rax     # 0x69600
movq 0x8(%rax), %rcx
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_utils.c
// Function: Team_cprint
void Team_cprint (int color, char *message, char *elsemessage)
{
    int i;
    edict_t         *cl_ent;

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

	}
	gi.dprintf(elsemessage);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x2a6c5(%rip), %rax     # 0x69d40
cmpl $0x0, 0x610(%rax)
jle 0x3f702
movl %edi, %ebp
movl $0x4a8, %r13d           # imm = 0x4A8
xorl %r14d, %r14d
movq 0x29ec2(%rip), %r12     # 0x69558
movq (%r12), %rbx
leaq (%rbx,%r13), %r15
movq %r15, %rdi
movl $0xfffffffc, %esi       # imm = 0xFFFFFFFC
callq 0x18ce0
testl %eax, %eax
je 0x3f6e5
movq 0x58(%rbx,%r13), %rax
cmpl %ebp, 0x1100(%rax)
jne 0x3f6cb
movl $0x2, %esi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
jmp 0x3f6e0
cmpq $0x0, 0x8(%rsp)
je 0x3f6e5
movl $0x2, %esi
movq %r15, %rdi
movq 0x8(%rsp), %rdx
callq 0x18da0
incq %r14
movq 0x2a651(%rip), %rax     # 0x69d40
movslq 0x610(%rax), %rax
addq $0x4a8, %r13            # imm = 0x4A8
cmpq %rax, %r14
jl 0x3f696
movq 0x29ef7(%rip), %rax     # 0x69600
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: blaster_touch
void blaster_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	int		mod;

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

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

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

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

	G_FreeEdict (self);
}

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x110(%rdi)
je 0x40714
movq %rdi, %rbx
testq %rcx, %rcx
je 0x406f5
testb $0x4, 0x10(%rcx)
jne 0x4071c
cmpl $0x0, 0x27c(%rsi)
je 0x4072b
movq %rsi, 0x2a0(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x407af
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a60
testb $0x1, 0x140(%rbx)
jne 0x4074b
movq 0x28ec5(%rip), %rax     # 0x69600
movq 0x20(%rax), %r14
leaq 0x16eb7(%rip), %rdi     # 0x575fd
callq *0x48(%rax)
jmp 0x4078b
callq 0x19a20
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
divss 0x13b27(%rip), %xmm0    # 0x54288
ucomiss 0x14c9c(%rip), %xmm0    # 0x55404
movq 0x28e91(%rip), %rax     # 0x69600
movq 0x20(%rax), %r14
movq 0x48(%rax), %rax
jbe 0x40782
leaq 0x19d10(%rip), %rdi     # 0x5a490
jmp 0x40789
leaq 0x19d1c(%rip), %rdi     # 0x5a4a5
callq *%rax
movss 0x13795(%rip), %xmm0    # 0x53f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x2, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/QwazyWabbitWOS[P]lmctf60/g_weapon.c
// Function: fire_rocket
void fire_rocket (edict_t *self, vec3_t start, vec3_t dir, int damage, int speed, float damage_radius, int radius_damage)
{
	edict_t	*rocket;

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

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

	gi.linkentity (rocket);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, (%rsp)
movss %xmm0, 0x4(%rsp)
movl %r8d, %r13d
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r15
callq 0x19710
movq %rax, %r14
movss (%rbp), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x4(%rbp), %xmm0
movss %xmm0, 0x8(%rax)
movss 0x8(%rbp), %xmm0
movss %xmm0, 0xc(%rax)
movss (%rbx), %xmm0
movss %xmm0, 0x19c(%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x1a0(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x1a4(%rax)
leaq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x190d0
xorps %xmm0, %xmm0
cvtsi2ss %r13d, %xmm0
leaq 0x1c0(%r14), %rsi
movq %rbx, %rdi
callq 0x189d0
movl $0x8, 0x118(%r14)
movabsq $0x600000300000002, %rax # imm = 0x600000300000002
movq %rax, 0x108(%r14)
orb $0x10, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xcc(%r14)
movq $0x0, 0xdc(%r14)
movq 0x286fc(%rip), %rbp     # 0x69600
leaq 0x19504(%rip), %rdi     # 0x5a40f
callq *0x40(%rbp)
movl %eax, 0x28(%r14)
movq %r15, 0x110(%r14)
movq 0x28b00(%rip), %rax     # 0x69a20
movq %rax, 0x220(%r14)
movq 0x28e72(%rip), %rcx     # 0x69da0
movl $0x1f40, %eax           # imm = 0x1F40
xorl %edx, %edx
idivl %r13d
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss 0x4(%rcx), %xmm0
movss %xmm0, 0x200(%r14)
movq 0x284dc(%rip), %rax     # 0x69430
movq %rax, 0x210(%r14)
movl %r12d, 0x280(%r14)
movl (%rsp), %eax
movl %eax, 0x284(%r14)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x288(%r14)
leaq 0x194ac(%rip), %rdi     # 0x5a42e
movq %rbp, %r12
callq *0x48(%rbp)
movl %eax, 0x4c(%r14)
leaq 0x19ed6(%rip), %rax     # 0x5ae69
movq %rax, 0x138(%r14)
cmpq $0x0, 0x58(%r15)
je 0x40fb0
movq %r14, %rdi
addq $0x4, %rdi
movq %rbx, %rsi
callq 0x40464
movq %r14, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x90(%rax)