LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movss 0x2fc(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4d284
jp 0x4d284
movq -0x8(%rbp), %rdi
callq 0x19d88
jmp 0x4d2ba
movq -0x8(%rbp), %rax
movq 0x357a1(%rip), %rcx     # 0x82a30
movq %rcx, 0x210(%rax)
movq 0x35b03(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x2fc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x270(%rax)
jne 0x4d523
movq 0x3510f(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x10(%rbp), %rcx
movq %rax, %rsi
leaq 0x289b0(%rip), %rdi     # 0x75ec4
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4d58d
movq 0x35876(%rip), %rdi     # 0x82da0
addq $0x48, %rdi
leaq 0x289b5(%rip), %rsi     # 0x75eea
callq 0x186f0
cmpl $0x0, %eax
jne 0x4d56d
movq -0x8(%rbp), %rax
movq 0x270(%rax), %rdi
leaq 0x2899f(%rip), %rsi     # 0x75ef0
callq 0x186f0
cmpl $0x0, %eax
jne 0x4d56d
movq -0x8(%rbp), %rax
leaq 0x28990(%rip), %rcx     # 0x75ef6
movq %rcx, 0x270(%rax)
movq -0x8(%rbp), %rax
movq 0x35748(%rip), %rcx     # 0x82cc0
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x3, %edi
movq 0x35040(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movl $0xa, %edi
movq 0x3502e(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x35021(%rip), %rax     # 0x82600
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x290(%rcx), %edi
callq *%rax
movq 0x35007(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq *%rax
movq 0x34fef(%rip), %rax     # 0x82600
movq 0xf8(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x19c, %rdi            # imm = 0x19C
callq *%rax
movq 0x34fd4(%rip), %rax     # 0x82600
movq 0xc8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x28c(%rcx), %edi
callq *%rax
movq 0x34fba(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq *%rax
movq -0x8(%rbp), %rax
cmpl $0x0, 0x280(%rax)
je 0x4d69c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
cvtsi2ssl 0x280(%rax), %xmm0
movq -0x8(%rbp), %rax
movl 0x280(%rax), %eax
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
xorl %eax, %eax
movl %eax, %edx
movl $0x1d, %ecx
callq 0x180c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x35041(%rip), %rcx     # 0x82708
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x19870
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x4d701
movq -0x8(%rbp), %rax
movl $0x20, 0x290(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x19950
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x8(%rbp), %rax
movss 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0x18(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0x19520
movq 0x34e31(%rip), %rax     # 0x82600
movq 0x98(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x18b60
movq 0x34e14(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4d811
jp 0x4d811
jmp 0x4d859
movq -0x8(%rbp), %rax
movss 0x19c(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x1c0(%rax)
movq -0x8(%rbp), %rax
movss 0x1a0(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x1c4(%rax)
movq -0x8(%rbp), %rax
movss 0x1a4(%rax), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x1c8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x35549(%rip), %rcx     # 0x82dc0
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4d8a4
jp 0x4d8a4
jmp 0x4d8e3
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x19870
movq -0x8(%rbp), %rdi
addq $0x19c, %rdi            # imm = 0x19C
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x18a80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4d91f
movl $0x0, -0x1c(%rbp)
jmp 0x4d943
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4d93a
movl $0x40, -0x1c(%rbp)
jmp 0x4d941
movl $0x8, -0x1c(%rbp)
jmp 0x4d943
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movq -0x8(%rbp), %rdx
addq $0x19c, %rdx            # imm = 0x19C
movq -0x8(%rbp), %rax
movl 0x280(%rax), %ecx
movq -0x8(%rbp), %rax
cvttss2si 0x190(%rax), %r8d
movl -0x1c(%rbp), %r9d
movl $0x21, (%rsp)
callq 0x18a50
movq 0x34c78(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x2e8(%rcx), %edx
movl $0x2, %esi
movss 0x22545(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x34f49(%rip), %rcx     # 0x82920
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x19870
leaq 0x28507(%rip), %rdi     # 0x75f04
movq 0x34bfc(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x280(%rax)
jne 0x4da2e
movq -0x8(%rbp), %rax
movl $0xf, 0x280(%rax)
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4da58
jp 0x4da58
movq -0x8(%rbp), %rax
movss 0x224a8(%rip), %xmm0    # 0x6fef8
movss %xmm0, 0x190(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x2fc(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4db82
jp 0x4db82
movq -0x8(%rbp), %rax
movss 0x22372(%rip), %xmm0    # 0x6feec
movss %xmm0, 0x2fc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
movq -0x8(%rbp), %rax
movq 0x34c85(%rip), %rcx     # 0x82820
movq %rcx, 0x210(%rax)
movq 0x351f7(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x2fc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_laser_on
void target_laser_on (edict_t *self)
{
	if (!self->activator)
		self->activator = self;
	self->spawnflags |= 0x80000001;
	self->svflags &= ~SVF_NOCLIENT;
	target_laser_think (self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2b0(%rax)
jne 0x4dfd9
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
orl $0x80000001, %ecx       # imm = 0x80000001
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rdi
callq 0x19df8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4e0a0
movq -0x8(%rbp), %rdi
callq 0x18d60
jmp 0x4e0a9
movq -0x8(%rbp), %rdi
callq 0x18ce0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x144(%rax), %xmm2
movss 0x19c(%rax), %xmm1
movss 0x27a54(%rip), %xmm0    # 0x75e3c
addss %xmm0, %xmm1
movq 0x349ad(%rip), %rcx     # 0x82da0
movss 0x4(%rcx), %xmm0
subss %xmm2, %xmm0
movss 0x21e90(%rip), %xmm2    # 0x70294
divss %xmm2, %xmm0
movss 0x1a4(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
movq 0x341d6(%rip), %rax     # 0x82600
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2a0(%rcx), %rcx
movl 0x32c(%rcx), %edi
addl $0x320, %edi            # imm = 0x320
leaq -0xa(%rbp), %rsi
callq *%rax
movq 0x3494e(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
subss 0x144(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4e496
movss 0x21e18(%rip), %xmm0    # 0x70294
movq 0x3491d(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
jmp 0x4e4fd
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4e4fb
movq -0x8(%rbp), %rax
cvttss2si 0x19c(%rax), %eax
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movss 0x1a0(%rax), %xmm0
movss %xmm0, 0x19c(%rax)
movsbl -0xb(%rbp), %eax
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1a0(%rax)
movq -0x8(%rbp), %rax
movss 0x2469d(%rip), %xmm0    # 0x72b88
mulss 0x1a4(%rax), %xmm0
movss %xmm0, 0x1a4(%rax)
jmp 0x4e4fd
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
jne 0x4e6a8
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdx
xorl %eax, %eax
addq $0x158, %rax            # imm = 0x158
movl %eax, %esi
callq 0x19660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4e56c
jmp 0x4e638
movq -0x20(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x28677(%rip), %rsi     # 0x76bf5
callq 0x18bf0
cmpl $0x0, %eax
je 0x4e624
movq 0x3406d(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rcx
movq %rax, %rdx
leaq 0x2796c(%rip), %rdi     # 0x75f35
movb $0x0, %al
callq *%rcx
movq 0x3402c(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %r8
movq %rax, %rcx
leaq 0x27922(%rip), %rdi     # 0x75f3f
movb $0x0, %al
callq *%r8
jmp 0x4e633
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2a0(%rax)
jmp 0x4e53e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
jne 0x4e6a6
movq 0x33fb3(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %r8
movq %rax, %rcx
leaq 0x278ce(%rip), %rdi     # 0x75f64
movb $0x0, %al
callq *%r8
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4e6c9
jmp 0x4e6a8
movq 0x346f1(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x144(%rax)
movq -0x8(%rbp), %rdi
callq 0x19de8
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x34209(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2ssl 0x290(%rax), %xmm1
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x144(%rax)
movss 0x216d4(%rip), %xmm0    # 0x70294
movq 0x341d9(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x250(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x158(%rax)
jne 0x4ec5b
movq 0x339df(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rax, %rdx
leaq 0x27355(%rip), %rdi     # 0x75fac
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x4ec76
movq -0x8(%rbp), %rax
movl $0x5, 0x290(%rax)
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4eca0
jp 0x4eca0
movq -0x8(%rbp), %rax
movss 0x21608(%rip), %xmm0    # 0x702a0
movss %xmm0, 0x190(%rax)
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movq 0x3382a(%rip), %rcx     # 0x824e8
movq %rcx, 0x210(%rax)
movq -0x8(%rbp), %rax
movq 0x33c00(%rip), %rcx     # 0x828d0
movq %rcx, 0x228(%rax)
leaq 0x272e3(%rip), %rdi     # 0x75fc1
movq 0x3391b(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq 0x33a4d(%rip), %rsi     # 0x82768
callq 0x18c60
cmpl $0x0, %eax
jne 0x4ed3d
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x19870
movq -0x8(%rbp), %rax
movl $0x1, 0x108(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
movq 0x338a0(%rip), %rax     # 0x82600
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x120(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x200(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4edd4
jp 0x4edd4
jmp 0x4edd9
jmp 0x4ee7a
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rsi
callq 0x19b50
movq -0x8(%rbp), %rax
movss 0x2f8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4ee39
movq -0x8(%rbp), %rax
movq 0x3404c(%rip), %rcx     # 0x82e58
movq %rcx, 0x210(%rax)
movq 0x33f86(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x2f8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
jmp 0x4ee7a
movq -0x8(%rbp), %rax
movq $0x0, 0x220(%rax)
movss 0x21444(%rip), %xmm0    # 0x70294
movq 0x33f49(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x335bd(%rip), %rcx     # 0x82430
movq %rcx, 0x210(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x4eefc
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4eefa
jmp 0x4ef97
jmp 0x4ef28
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4ef24
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4ef22
jmp 0x4ef97
jmp 0x4ef26
jmp 0x4ef97
jmp 0x4ef28
movq -0x8(%rbp), %rdi
addq $0x19c, %rdi            # imm = 0x19C
movq 0x3382e(%rip), %rsi     # 0x82768
callq 0x18c60
cmpl $0x0, %eax
jne 0x4ef7f
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq -0x2c(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x183e0
leaq -0x2c(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x186b0
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4ef7d
jmp 0x4ef97
jmp 0x4ef7f
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rdi
callq 0x195b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28c(%rax)
jne 0x4f028
leaq 0x22163(%rip), %rdi     # 0x71173
movq 0x335e9(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
jmp 0x4f082
movq -0x8(%rbp), %rax
cmpl $0x2, 0x28c(%rax)
jne 0x4f054
leaq 0x23c31(%rip), %rdi     # 0x72c6d
movq 0x335bd(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
jmp 0x4f080
movq -0x8(%rbp), %rax
cmpl $0x3, 0x28c(%rax)
jne 0x4f07e
leaq 0x26f69(%rip), %rdi     # 0x75fd1
movq 0x33591(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
jmp 0x4f080
jmp 0x4f082
movq -0x8(%rbp), %rax
movss 0x2f8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4f0ac
jp 0x4f0ac
movq -0x8(%rbp), %rax
movss 0x23db8(%rip), %xmm0    # 0x72e5c
movss %xmm0, 0x2f8(%rax)
movq -0x8(%rbp), %rax
movq 0x33dc9(%rip), %rcx     # 0x82e80
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4f113
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x8(%rbp), %rax
movq 0x33a5e(%rip), %rcx     # 0x82b68
movq %rcx, 0x228(%rax)
jmp 0x4f133
movq -0x8(%rbp), %rax
movl $0x1, 0x108(%rax)
movq -0x8(%rbp), %rax
movq 0x33bbc(%rip), %rcx     # 0x82ce8
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq 0x33626(%rip), %rsi     # 0x82768
callq 0x18c60
cmpl $0x0, %eax
jne 0x4f164
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x19c, %rsi            # imm = 0x19C
callq 0x19870
movq 0x33495(%rip), %rax     # 0x82600
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x120(%rcx), %rsi
callq *%rax
movq 0x33479(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f24c
movq -0x8(%rbp), %rdi
addq $0xcc, %rdi
movq -0x8(%rbp), %rsi
addq $0xfc, %rsi
leaq -0x14(%rbp), %rdx
movss 0x2396c(%rip), %xmm0    # 0x72b50
callq 0x199c0
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x140(%rax)
movq 0x333ea(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x19260
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq %rax, %rdx
leaq 0x26d9b(%rip), %rdi     # 0x75fe3
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rax
movss 0x23930(%rip), %xmm0    # 0x72b88
movss %xmm0, 0x2f8(%rax)
movq -0x8(%rbp), %rdi
callq 0x19110
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x33025(%rip), %rax     # 0x82668
cmpq $0x0, 0x40(%rax)
jne 0x4f67d
movq 0x32faf(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x10(%rbp), %rcx
movq %rax, %rsi
leaq 0x269c1(%rip), %rdi     # 0x76035
movb $0x0, %al
callq *%rcx
jmp 0x4f774
movq 0x32fe4(%rip), %rax     # 0x82668
movq 0x40(%rax), %rdi
callq 0x18180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x330(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x330(%rax)
jne 0x4f6ef
movq 0x32f50(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x32fa9(%rip), %rax     # 0x82668
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq %rax, %rdx
leaq 0x26972(%rip), %rdi     # 0x76058
movb $0x0, %al
callq *%rcx
jmp 0x4f774
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x4f740
movq 0x32efc(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq %rax, %rdx
leaq 0x26947(%rip), %rdi     # 0x76081
movb $0x0, %al
callq *%rcx
jmp 0x4f774
leaq 0x268ce(%rip), %rdi     # 0x76015
movq 0x32eb2(%rip), %rax     # 0x82600
callq *0x48(%rax)
leaq 0x268cd(%rip), %rdi     # 0x76025
movq 0x32ea1(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x3376b(%rip), %rcx     # 0x82ed8
movq %rcx, 0x228(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x4f7a6
jmp 0x4f8cd
movq -0x8(%rbp), %rax
movl 0x290(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x290(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
je 0x4f845
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4f840
movq 0x32e21(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x290(%rax), %edx
leaq 0x268a1(%rip), %rsi     # 0x76099
movb $0x0, %al
callq *%rcx
movq 0x32dfd(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x2340d(%rip), %rdi     # 0x72c27
movq 0x32ddf(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x28(%rbp), %rdi
movl %eax, %edx
movq -0x20(%rbp), %rax
xorl %esi, %esi
movss 0x206b4(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
jmp 0x4f8cd
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4f8b5
movq 0x32da2(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rdi
leaq 0x2683d(%rip), %rsi     # 0x760aa
movb $0x0, %al
callq *%rcx
movq 0x32d88(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x23398(%rip), %rdi     # 0x72c27
movq 0x32d6a(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x38(%rbp), %rdi
movl %eax, %edx
movq -0x30(%rbp), %rax
xorl %esi, %esi
movss 0x2063f(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rdi
callq 0x195b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x23294(%rip), %xmm0    # 0x72b88
movss %xmm0, 0x2f8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x4f917
movq -0x8(%rbp), %rax
movl $0x2, 0x290(%rax)
movq -0x8(%rbp), %rax
movq 0x3306e(%rip), %rcx     # 0x82990
movq %rcx, 0x228(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x272bf(%rip), %rsi     # 0x76c69
callq 0x18bf0
cmpl $0x0, %eax
jne 0x4f9e8
movq -0x8(%rbp), %rdi
addq $0x19c, %rdi            # imm = 0x19C
movq -0x8(%rbp), %rax
movss 0x20525(%rip), %xmm0    # 0x6fef0
mulss 0x190(%rax), %xmm0
movq -0x10(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
callq 0x18a80
jmp 0x4fb01
movq -0x10(%rbp), %rax
cmpl $0x0, 0x254(%rax)
jle 0x4faff
movq -0x8(%rbp), %rdi
addq $0x19c, %rdi            # imm = 0x19C
movq -0x8(%rbp), %rax
movss 0x204e0(%rip), %xmm0    # 0x6fef0
mulss 0x190(%rax), %xmm0
movq -0x10(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
callq 0x18a80
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x4fafd
movq -0x10(%rbp), %rax
movss 0x1c0(%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movss %xmm0, 0xed8(%rax)
movq -0x10(%rbp), %rax
movss 0x1c4(%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movss %xmm0, 0xedc(%rax)
movq -0x10(%rbp), %rax
movss 0x1c8(%rax), %xmm0
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movss %xmm0, 0xee0(%rax)
movq -0x10(%rbp), %rax
movss 0x24c(%rax), %xmm1
movq 0x33302(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4fafb
movq 0x332f1(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x21160(%rip), %xmm1    # 0x70c20
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x24c(%rax)
movq 0x32b25(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movl 0x5b4b7(%rip), %edx     # 0xaafa0
xorl %esi, %esi
movss 0x203f9(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
jmp 0x4fafd
jmp 0x4faff
jmp 0x4fb01
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4fb1c
movq -0x8(%rbp), %rdi
callq 0x19cd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18530
leaq 0x26572(%rip), %rdi     # 0x760be
movq 0x32aad(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, 0x5b444(%rip)     # 0xaafa0
movq -0x8(%rbp), %rax
movq 0x333d9(%rip), %rcx     # 0x82f40
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x4fb98
jp 0x4fb98
movq -0x8(%rbp), %rax
movss 0x20368(%rip), %xmm0    # 0x6fef8
movss %xmm0, 0x190(%rax)
movq 0x32a61(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x108(%rax)
jne 0x4fbf1
movq -0x8(%rbp), %rax
movl $0x1, 0x108(%rax)
jmp 0x4fbff
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
movq 0x329fa(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x4fc34
movq -0x8(%rbp), %rax
movq $0x0, 0x228(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x27c(%rax)
jne 0x4fc6a
jmp 0x4fda4
movq -0x8(%rbp), %rax
movss 0x144(%rax), %xmm0
movq 0x33123(%rip), %rax     # 0x82da0
ucomiss 0x4(%rax), %xmm0
jbe 0x4fc88
jmp 0x4fda4
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4fcbc
movss 0x2024a(%rip), %xmm0    # 0x6feec
movq 0x330f7(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x144(%rax)
jmp 0x4fcdc
movss 0x205d0(%rip), %xmm0    # 0x70294
movq 0x330d5(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x144(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4fd31
movq 0x330ab(%rip), %rax     # 0x82da0
movl (%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4fd2f
movq 0x328f5(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x2e8(%rcx), %edx
xorl %esi, %esi
movss 0x201c5(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
jmp 0x4fd31
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4fd4c
movl $0x20, -0x24(%rbp)
jmp 0x4fd53
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq -0x8(%rbp), %rax
movl 0x280(%rax), %r11d
movq -0x8(%rbp), %rax
movl 0x280(%rax), %r10d
movl -0x24(%rbp), %eax
movq 0x329e1(%rip), %r9      # 0x82768
movq %r9, %rcx
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movl $0x1f, 0x18(%rsp)
callq 0x192c0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18530
leaq 0x26303(%rip), %rdi     # 0x760cf
movq 0x3282d(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e8(%rax)
movq -0x8(%rbp), %rax
movq 0x3285b(%rip), %rcx     # 0x82648
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x280(%rax)
jne 0x4fe0f
movq -0x8(%rbp), %rax
movl $0x5, 0x280(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4fe31
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
jmp 0x4fe3f
movq -0x8(%rbp), %rax
movl $0x1, 0x108(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4fe63
movq -0x8(%rbp), %rax
movq 0x32fc4(%rip), %rcx     # 0x82e20
movq %rcx, 0x228(%rax)
movq 0x32796(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x327a5(%rip), %rax     # 0x82668
cmpq $0x0, 0x48(%rax)
jne 0x4ff03
movq 0x3272f(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x10(%rbp), %rcx
movq %rax, %rsi
leaq 0x261ed(%rip), %rdi     # 0x760e1
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4ff3e
movq -0x8(%rbp), %rdi
callq 0x18530
movq 0x32755(%rip), %rax     # 0x82668
movq 0x48(%rax), %rdi
callq 0x19820
cvtsi2ss %eax, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1e0(%rax)
movq -0x8(%rbp), %rax
movq 0x32c79(%rip), %rcx     # 0x82bb0
movq %rcx, 0x220(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x4ff7b
jmp 0x50025
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4ff92
jmp 0x50025
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4ffa6
jmp 0x50025
movq -0x8(%rbp), %rax
movss 0x19c(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x190(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1c0(%rax)
movq -0x8(%rbp), %rax
movss 0x1a0(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x190(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1c4(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2b8(%rax)
jne 0x4fffe
jmp 0x50025
movq -0x10(%rbp), %rax
movq $0x0, 0x2b8(%rax)
movq -0x8(%rbp), %rax
movss 0x1a4(%rax), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1c8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x50066
jp 0x50066
movq -0x8(%rbp), %rax
movss 0x20242(%rip), %xmm0    # 0x702a0
movss %xmm0, 0x190(%rax)
movq 0x325fb(%rip), %rax     # 0x82668
cmpl $0x0, 0x28(%rax)
jne 0x50081
movq 0x325ee(%rip), %rax     # 0x82668
movl $0xc8, 0x28(%rax)
movq -0x8(%rbp), %rax
movss 0x14(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x500a5
jp 0x500a5
movq -0x8(%rbp), %rax
movss 0x20c84(%rip), %xmm0    # 0x70d24
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0x18530
movq -0x8(%rbp), %rax
movq 0x32627(%rip), %rcx     # 0x826e0
movq %rcx, 0x220(%rax)
movq 0x325a1(%rip), %rax     # 0x82668
cvtsi2ssl 0x28(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1a4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop