LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_secret
void use_target_secret (edict_t *ent, edict_t *other, edict_t *activator)
{
	gi.sound (ent, CHAN_VOICE, ent->noise_index, 1, ATTN_NORM, 0);

	level.found_secrets++;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x2d8c0(%rip), %rax     # 0x66600
movl 0x2e8(%rdi), %edx
pushq $0x2
popq %rsi
movss 0x161d7(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movaps %xmm0, %xmm1
callq *0x20(%rax)
movq 0x2e03f(%rip), %rax     # 0x66da0
incl 0x134(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19ac0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_secret
void SP_target_secret (edict_t *ent)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (ent);
		return;
	}

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2e134(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x38d9e
jnp 0x38da7
movq %rbx, %rdi
popq %rbx
jmp 0x19c50
movq 0x2e1e2(%rip), %rax     # 0x66f90
movq %rax, 0x228(%rbx)
movq 0x2d8ac(%rip), %rax     # 0x66668
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x38dd0
leaq 0x1739f(%rip), %rdi     # 0x5016b
movq %rdi, 0x30(%rax)
movq 0x2d829(%rip), %rax     # 0x66600
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movl $0x1, 0xc8(%rbx)
movq 0x2dfaf(%rip), %rdi     # 0x66da0
incl 0x130(%rdi)
addq $0x48, %rdi
leaq 0x1c368(%rip), %rsi     # 0x5516a
callq 0x186d0
testl %eax, %eax
je 0x38e0d
popq %rbx
retq
movss 0x4(%rbx), %xmm0
ucomiss 0x1c2f7(%rip), %xmm0    # 0x55110
jne 0x38e0b
jp 0x38e0b
movss 0x8(%rbx), %xmm0
ucomiss 0x1c2eb(%rip), %xmm0    # 0x55114
jne 0x38e0b
jp 0x38e0b
movss 0xc(%rbx), %xmm0
ucomiss 0x1c2df(%rip), %xmm0    # 0x55118
jne 0x38e0b
jp 0x38e0b
leaq 0x1c32c(%rip), %rax     # 0x55170
movq %rax, 0x130(%rbx)
jmp 0x38e0b
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_goal
void use_target_goal (edict_t *ent, edict_t *other, edict_t *activator)
{
	gi.sound (ent, CHAN_VOICE, ent->noise_index, 1, ATTN_NORM, 0);

	level.found_goals++;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq 0x2d7a1(%rip), %r15     # 0x66600
movl 0x2e8(%rdi), %edx
pushq $0x2
popq %rsi
movss 0x160b8(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movaps %xmm0, %xmm1
callq *0x20(%r15)
movq 0x2df1f(%rip), %rax     # 0x66da0
movl 0x13c(%rax), %ecx
incl %ecx
movl %ecx, 0x13c(%rax)
cmpl 0x138(%rax), %ecx
jne 0x38ea5
leaq 0x1e20e(%rip), %rsi     # 0x570ac
pushq $0x1
popq %rdi
callq *0x30(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19ac0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_goal
void SP_target_goal (edict_t *ent)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (ent);
		return;
	}

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2dff8(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x38eda
jnp 0x38ee3
movq %rbx, %rdi
popq %rbx
jmp 0x19c50
movq 0x2d7e6(%rip), %rax     # 0x666d0
movq %rax, 0x228(%rbx)
movq 0x2d770(%rip), %rax     # 0x66668
movq 0x30(%rax), %rdi
testq %rdi, %rdi
jne 0x38f0c
leaq 0x17263(%rip), %rdi     # 0x5016b
movq %rdi, 0x30(%rax)
movq 0x2d6ed(%rip), %rax     # 0x66600
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movl $0x1, 0xc8(%rbx)
movq 0x2de73(%rip), %rax     # 0x66da0
incl 0x138(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_explosion_explode
void target_explosion_explode (edict_t *self)
{
	float		save;

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

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

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

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

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

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

// Assembly:
movq %rdx, 0x2b0(%rdi)
movss 0x2fc(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x38ff1
jnp 0x39014
movq 0x2da38(%rip), %rax     # 0x66a30
movq %rax, 0x210(%rdi)
movq 0x2dd9a(%rip), %rax     # 0x66da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
retq
jmp 0x19d00
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_changelevel
void use_target_changelevel (edict_t *self, edict_t *other, edict_t *activator)
{
	char message[MAX_INFO_STRING];

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

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

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

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

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

	BeginIntermission (self);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq 0x2dd5d(%rip), %rax     # 0x66da0
movss 0xc8(%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x3915c
jp 0x3915c
movq %rdi, %rbx
movq 0x2de59(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm1
ucomiss %xmm0, %xmm1
jne 0x39076
jnp 0x390d0
movq 0x2d59b(%rip), %rax     # 0x66618
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
btl $0xc, %eax
jb 0x390fe
movq 0x2d4c6(%rip), %rax     # 0x66558
cmpq %rsi, (%rax)
je 0x390fe
leaq 0x4(%rsi), %r8
imull $0xa, 0x258(%rsi), %eax
movq 0x2d6bf(%rip), %rcx     # 0x66768
movq %rsi, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x1c
pushq $0x0
pushq $0x3e8                  # imm = 0x3E8
pushq %rax
callq 0x19260
addq $0x228, %rsp            # imm = 0x228
jmp 0x39163
movq 0x2de89(%rip), %rax     # 0x66f60
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x39132
jp 0x39132
movq 0x2d468(%rip), %rax     # 0x66558
movq (%rax), %rax
cmpl $0x0, 0x6fc(%rax)
jg 0x39132
jmp 0x3915c
testq %rdx, %rdx
je 0x39132
movq 0x58(%rdx), %rdx
testq %rdx, %rdx
je 0x39132
addq $0x2c0, %rdx            # imm = 0x2C0
leaq 0x1c074(%rip), %rsi     # 0x5518e
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x198c0
pushq $0x2
popq %rdi
movq %r14, %rsi
callq 0x193f0
movq 0x270(%rbx), %rdi
pushq $0x2a
popq %rsi
callq 0x18780
testq %rax, %rax
je 0x39154
movq 0x2dbf3(%rip), %rax     # 0x66d40
movb $0x0, 0x618(%rax)
movq %rbx, %rdi
callq 0x18f70
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_changelevel
void SP_target_changelevel (edict_t *ent)
{
	if (!ent->map)
	{
		gi.dprintf("target_changelevel with no map at %s\n", vtos(ent->s.origin));
		G_FreeEdict (ent);
		return;
	}

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x270(%rdi)
je 0x391d8
movq 0x2dc21(%rip), %rdi     # 0x66da0
addq $0x48, %rdi
leaq 0x1c040(%rip), %rsi     # 0x551ca
callq 0x186d0
testl %eax, %eax
jne 0x391b8
movq 0x270(%rbx), %rdi
leaq 0x1c02f(%rip), %rsi     # 0x551d0
callq 0x186d0
testl %eax, %eax
jne 0x391b8
leaq 0x1c025(%rip), %rax     # 0x551d6
movq %rax, 0x270(%rbx)
movq 0x2db01(%rip), %rax     # 0x66cc0
movq %rax, 0x228(%rbx)
movl $0x1, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2d421(%rip), %rax     # 0x66600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x1bfb1(%rip), %rdi     # 0x551a4
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_splash
void use_target_splash (edict_t *self, edict_t *other, edict_t *activator)
{
	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (TE_SPLASH);
	gi.WriteByte (self->count);
	gi.WritePosition (self->s.origin);
	gi.WriteDir (self->movedir);
	gi.WriteByte (self->sounds);
	gi.multicast (self->s.origin, MULTICAST_PVS);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x2d3e1(%rip), %r12     # 0x66600
pushq $0x3
popq %rdi
callq *0xc8(%r12)
pushq $0xa
popq %rdi
callq *0xc8(%r12)
movl 0x290(%r14), %edi
callq *0xc8(%r12)
leaq 0x4(%r14), %r15
movq %r15, %rdi
callq *0xf0(%r12)
leaq 0x19c(%r14), %rdi
callq *0xf8(%r12)
movl 0x28c(%r14), %edi
callq *0xc8(%r12)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq *0xb0(%r12)
movl 0x280(%r14), %eax
testl %eax, %eax
je 0x392b0
cvtsi2ss %eax, %xmm0
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
pushq $0x1d
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x180c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_splash
void SP_target_splash (edict_t *self)
{
	self->use = use_target_splash;
	G_SetMovedir (self->s.angles, self->movedir);

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

	self->svflags = SVF_NOCLIENT;
}

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

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

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

// Assembly:
movq 0x2d9e6(%rip), %rax     # 0x66dc0
movq %rax, 0x228(%rdi)
movl $0x1, 0xc8(%rdi)
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x393fd
jnp 0x39431
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rdi
leaq 0x19c(%rbx), %r14
movq %r14, %rsi
callq 0x197f0
movss 0x190(%rbx), %xmm0
movq %r14, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18a70
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: use_target_blaster
void use_target_blaster (edict_t *self, edict_t *other, edict_t *activator)
{
	int effect;

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

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

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

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

	self->svflags = SVF_NOCLIENT;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2d46f(%rip), %rax     # 0x66920
movq %rax, 0x228(%rdi)
addq $0x10, %rdi
leaq 0x19c(%rbx), %rsi
callq 0x197f0
movq 0x2d131(%rip), %rax     # 0x66600
leaq 0x1bd0e(%rip), %rdi     # 0x551e4
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x394f2
movl $0xf, 0x280(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3950e
jp 0x3950e
movl $0x447a0000, 0x190(%rbx) # imm = 0x447A0000
movl $0x1, 0xc8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_crosslevel_target
void SP_target_crosslevel_target (edict_t *self)
{
	if (! self->delay)
		self->delay = 1;
	self->svflags = SVF_NOCLIENT;

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

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

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

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

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

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x19c(%rdi), %xmm0
addss 0x1b6a5(%rip), %xmm0    # 0x5511c
movq 0x2d322(%rip), %r14     # 0x66da0
movss 0x4(%r14), %xmm1
subss 0x144(%rdi), %xmm1
divss 0x157fc(%rip), %xmm1    # 0x4f290
mulss 0x1a4(%rdi), %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %eax
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq 0x2cb4a(%rip), %rax     # 0x66600
movq 0x2a0(%rdi), %rcx
movl $0x320, %edi            # imm = 0x320
addl 0x32c(%rcx), %edi
callq *0x30(%rax)
movss 0x4(%r14), %xmm0
movaps %xmm0, %xmm1
subss 0x144(%rbx), %xmm1
movss 0x190(%rbx), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x39afb
addss 0x1579f(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
jmp 0x39b42
testb $0x1, 0x140(%rbx)
je 0x39b42
cvttss2si 0x19c(%rbx), %eax
movss 0x1a0(%rbx), %xmm0
movss %xmm0, 0x19c(%rbx)
movsbl %al, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1a0(%rbx)
movss 0x1a4(%rbx), %xmm0
xorps 0x18176(%rip), %xmm0    # 0x51cb0
movss %xmm0, 0x1a4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_lightramp_use
void target_lightramp_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (!self->enemy)
	{
		edict_t		*e;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2a0(%rdi)
jne 0x39c22
leaq 0x4(%rbx), %rax
movq %rax, (%rsp)
movq 0x2ca8b(%rip), %r15     # 0x66600
xorl %ebp, %ebp
movq 0x150(%rbx), %rdx
movq %rbp, %rdi
movl $0x158, %esi            # imm = 0x158
callq 0x195e0
testq %rax, %rax
je 0x39c18
movq %rax, %rbp
movq 0x138(%rax), %rdi
leaq 0x1c378(%rip), %rsi     # 0x55f1d
callq 0x18bc0
testl %eax, %eax
je 0x39c0c
movq 0x8(%r15), %r13
movq 0x138(%rbx), %r12
movq (%rsp), %rdi
callq 0x19200
leaq 0x1b64c(%rip), %rdi     # 0x55215
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r13
movq 0x8(%r15), %r14
movq 0x150(%rbx), %r12
movq 0x138(%rbp), %r13
movq %rbp, %rdi
addq $0x4, %rdi
callq 0x19200
leaq 0x1b626(%rip), %rdi     # 0x5521f
movq %r12, %rsi
movq %r13, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq *%r14
jmp 0x39b77
movq %rbp, 0x2a0(%rbx)
jmp 0x39b77
cmpq $0x0, 0x2a0(%rbx)
je 0x39c4c
movq 0x2d177(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
movss %xmm0, 0x144(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19d58
movq 0x8(%r15), %r14
movq 0x138(%rbx), %r15
movq 0x150(%rbx), %r12
movq (%rsp), %rdi
callq 0x19200
leaq 0x1b5d6(%rip), %rdi     # 0x55244
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: SP_target_lightramp
void SP_target_lightramp (edict_t *self)
{
	if (!self->message || strlen(self->message) != 2 || self->message[0] < 'a' || self->message[0] > 'z' || self->message[1] < 'a' || self->message[1] > 'z' || self->message[0] == self->message[1])
	{
		gi.dprintf("target_lightramp has bad ramp (%s) at %s\n", self->message, vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x130(%rdi), %r14
testq %r14, %r14
je 0x39cd5
movq %r14, %rdi
callq 0x186c0
cmpq $0x2, %rax
jne 0x39cd5
movb (%r14), %al
leal -0x7b(%rax), %ecx
cmpb $-0x1a, %cl
jb 0x39cd5
movb 0x1(%r14), %cl
leal -0x7b(%rcx), %edx
cmpb $-0x1a, %dl
setae %dl
cmpb %cl, %al
setne %al
testb %dl, %al
jne 0x39d08
movq 0x2c924(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x1b572(%rip), %rdi     # 0x55262
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
movq 0x2d1b1(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x39cfb
jp 0x39cfb
cmpq $0x0, 0x150(%rbx)
je 0x39d9d
orb $0x1, 0xc8(%rbx)
movq 0x2cb07(%rip), %rax     # 0x66840
movq %rax, 0x228(%rbx)
movq 0x2d209(%rip), %rax     # 0x66f50
movq %rax, 0x210(%rbx)
movsbl (%r14), %eax
leal -0x61(%rax), %ecx
cvtsi2ss %ecx, %xmm0
movss %xmm0, 0x19c(%rbx)
movsbl 0x1(%r14), %ecx
leal -0x61(%rcx), %edx
cvtsi2ss %edx, %xmm0
movss %xmm0, 0x1a0(%rbx)
subl %eax, %ecx
cvtsi2ss %ecx, %xmm0
movss 0x190(%rbx), %xmm1
divss 0x15505(%rip), %xmm1    # 0x4f290
divss %xmm1, %xmm0
movss %xmm0, 0x1a4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2c85c(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x19b6f(%rip), %rdi     # 0x5392e
jmp 0x39cf0
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_earthquake_think
void target_earthquake_think (edict_t *self)
{
	int		i;
	edict_t	*e;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2cfc7(%rip), %r14     # 0x66da0
movss 0x4(%r14), %xmm0
ucomiss 0x250(%rdi), %xmm0
jbe 0x39e26
movq 0x2c811(%rip), %rax     # 0x66600
leaq 0x4(%rbx), %rdi
movl 0x2e8(%rbx), %ecx
movss 0x15127(%rip), %xmm0    # 0x4ef28
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbx, %rsi
xorl %edx, %edx
callq *0x28(%rax)
movss 0x4(%r14), %xmm0
addss 0x165e2(%rip), %xmm0    # 0x50400
movss %xmm0, 0x250(%rbx)
movq 0x2c72b(%rip), %rcx     # 0x66558
movq 0x2ccd4(%rip), %r15     # 0x66b08
movl 0x8c(%r15), %eax
movl $0x760, %r12d           # imm = 0x760
addq (%rcx), %r12
pushq $0x1
popq %rbp
movl $0x7fff, %r13d          # imm = 0x7FFF
cmpl %eax, %ebp
jge 0x39f64
cmpl $0x0, -0x258(%r12)
je 0x39f56
cmpq $0x0, -0x260(%r12)
je 0x39f56
cmpq $0x0, (%r12)
je 0x39f56
andq $0x0, (%r12)
callq 0x19bf0
andl %r13d, %eax
cvtsi2ss %eax, %xmm0
movss 0x153f1(%rip), %xmm1    # 0x4f288
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x17d51(%rip), %xmm1    # 0x51bf8
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
cvtss2sd -0xf8(%r12), %xmm1
movsd 0x1b25f(%rip), %xmm2    # 0x55120
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xf8(%r12)
callq 0x19bf0
andl %r13d, %eax
cvtsi2ss %eax, %xmm0
divss 0x1539d(%rip), %xmm0    # 0x4f288
cvtss2sd %xmm0, %xmm0
addsd 0x17d01(%rip), %xmm0    # 0x51bf8
addsd %xmm0, %xmm0
cvtss2sd -0xf4(%r12), %xmm1
mulsd 0x1b213(%rip), %xmm0    # 0x55120
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xf4(%r12)
cvtss2sd 0x190(%rbx), %xmm0
cvtsi2sdl -0xe0(%r12), %xmm1
movsd 0x193e7(%rip), %xmm2    # 0x53320
divsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm0
movss %xmm0, -0xf0(%r12)
movl 0x8c(%r15), %eax
incl %ebp
addq $0x4a8, %r12            # imm = 0x4A8
jmp 0x39e4d
movss 0x4(%r14), %xmm0
movss 0x144(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x39f87
addss 0x15311(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_target.c
// Function: target_earthquake_use
void target_earthquake_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->timestamp = level.time + self->count;
	self->nextthink = level.time + FRAMETIME;
	self->activator = activator;
	self->last_move_time = 0;
}

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x158(%rdi)
jne 0x3a014
movq 0x2c612(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x1b283(%rip), %rdi     # 0x5528c
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
cmpl $0x0, 0x290(%rbx)
jne 0x3a027
movl $0x5, 0x290(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3a043
jp 0x3a043
movl $0x43480000, 0x190(%rbx) # imm = 0x43480000
orb $0x1, 0xc8(%rbx)
movq 0x2c497(%rip), %rax     # 0x664e8
movq %rax, 0x210(%rbx)
movq 0x2c871(%rip), %rax     # 0x668d0
movq %rax, 0x228(%rbx)
movq 0x2c593(%rip), %rax     # 0x66600
leaq 0x1b22d(%rip), %rdi     # 0x552a1
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: InitTrigger
void InitTrigger (edict_t *self)
{
	if (!VectorCompare (self->s.angles, vec3_origin))
		G_SetMovedir (self->s.angles, self->movedir);

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x2c6d2(%rip), %rsi     # 0x66768
movq %r14, %rdi
callq 0x18c20
testl %eax, %eax
jne 0x3a0b1
leaq 0x19c(%rbx), %rsi
movq %r14, %rdi
callq 0x197f0
pushq $0x1
popq %rbp
movl %ebp, 0x108(%rbx)
andl $0x0, 0x118(%rbx)
movq 0x2c538(%rip), %rax     # 0x66600
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
callq *0x58(%rax)
movl %ebp, 0xc8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: multi_trigger
void multi_trigger (edict_t *ent)
{
	if (ent->nextthink)
		return;		// already been triggered

	G_UseTargets (ent, ent->activator);

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

// Assembly:
movss 0x200(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3a0fa
jnp 0x3a0fb
retq
pushq %rbx
movq %rdi, %rbx
movq 0x2b0(%rdi), %rsi
callq 0x19ac0
movss 0x2f8(%rbx), %xmm0
ucomiss 0x15876(%rip), %xmm0    # 0x4f990
jbe 0x3a140
movq 0x2cd35(%rip), %rax     # 0x66e58
movq %rax, 0x210(%rbx)
movq 0x2cc6f(%rip), %rax     # 0x66da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
jmp 0x3a172
andq $0x0, 0x220(%rbx)
movq 0x2cc51(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x15134(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
movq 0x2c2c5(%rip), %rax     # 0x66430
movq %rax, 0x210(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_trigger.c
// Function: Touch_Multi
void Touch_Multi (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if(other->client)
	{
		if (self->spawnflags & 2)
			return;
	}
	else if (other->svflags & SVF_MONSTER)
	{
		if (!(self->spawnflags & 1))
			return;
	}
	else
		return;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x58(%rsi)
je 0x3a1a3
testb $0x2, 0x140(%rbx)
je 0x3a1b6
jmp 0x3a207
testb $0x4, 0xc8(%r14)
je 0x3a207
testb $0x1, 0x140(%rbx)
je 0x3a207
leaq 0x19c(%rbx), %r15
movq 0x2c5a4(%rip), %rsi     # 0x66768
movq %r15, %rdi
callq 0x18c20
testl %eax, %eax
jne 0x3a1f8
leaq 0x10(%r14), %rdi
leaq 0xc(%rsp), %r12
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x183d0
movq %r12, %rdi
movq %r15, %rsi
callq 0x18690
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x3a207
movq %r14, 0x2b0(%rbx)
movq %rbx, %rdi
callq 0x19530
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3a26c
movl %eax, %eax
leaq 0x1b1a3(%rip), %rcx     # 0x553f8
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
movq 0x2c39d(%rip), %rax     # 0x66600
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movss 0x2f8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3a288
jp 0x3a288
movl $0x3e4ccccd, 0x2f8(%rbx) # imm = 0x3E4CCCCD
movq 0x2cbf1(%rip), %rax     # 0x66e80
movq %rax, 0x220(%rbx)
andl $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 0x3a2c2
movq 0x2ca28(%rip), %rcx     # 0x66ce8
jmp 0x3a2c9
movq 0x2c89f(%rip), %rcx     # 0x66b68
movl %eax, 0x108(%rbx)
movq %rcx, 0x228(%rbx)
leaq 0x10(%rbx), %r14
movq 0x2c487(%rip), %rsi     # 0x66768
movq %r14, %rdi
callq 0x18c20
testl %eax, %eax
jne 0x3a2fc
leaq 0x19c(%rbx), %rsi
movq %r14, %rdi
callq 0x197f0
movq 0x2c2fd(%rip), %r14     # 0x66600
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_O2/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 0x3a39c
leaq 0xcc(%rbx), %rdi
leaq 0xfc(%rbx), %rsi
movss 0x160af(%rip), %xmm0    # 0x50400
leaq 0xc(%rsp), %r14
movq %r14, %rdx
callq 0x19940
movl 0x140(%rbx), %eax
andl $-0x6, %eax
orl $0x4, %eax
movl %eax, 0x140(%rbx)
movq 0x2c289(%rip), %rax     # 0x66600
movq 0x8(%rax), %r12
movq 0x138(%rbx), %r15
movq %r14, %rdi
callq 0x19200
leaq 0x1af3d(%rip), %rdi     # 0x552ce
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r12
movl $0xbf800000, 0x2f8(%rbx) # imm = 0xBF800000
movq %rbx, %rdi
callq 0x190a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2c051(%rip), %r14     # 0x66668
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x3a670
callq 0x18180
movq %rax, 0x330(%rbx)
testq %rax, %rax
je 0x3a69d
cmpq $0x0, 0x150(%rbx)
je 0x3a6c1
movq 0x2bfba(%rip), %r14     # 0x66600
leaq 0x1acb3(%rip), %rdi     # 0x55300
callq *0x48(%r14)
leaq 0x1acb8(%rip), %rdi     # 0x55310
callq *0x48(%r14)
movq 0x2c875(%rip), %rax     # 0x66ed8
movq %rax, 0x228(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2bf89(%rip), %rax     # 0x66600
movq 0x8(%rax), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x19200
leaq 0x1ac92(%rip), %rdi     # 0x55320
movq %rax, %rsi
xorl %eax, %eax
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
movq 0x2bf5c(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x40(%r14), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x19200
leaq 0x1ac84(%rip), %rdi     # 0x55343
jmp 0x3a6e6
movq 0x2bf38(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
addq $0x4, %rbx
movq %rbx, %rdi
callq 0x19200
leaq 0x1ac86(%rip), %rdi     # 0x5536c
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_O2/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 0x3a76f
movq %rdi, %r14
decl %edx
movl %edx, 0x290(%rdi)
movl 0x140(%rdi), %eax
je 0x3a77b
testb $0x1, %al
jne 0x3a76f
movq 0x2bed5(%rip), %r14     # 0x66600
leaq 0x1ac52(%rip), %rsi     # 0x55384
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r14)
movq 0x20(%r14), %r15
leaq 0x17629(%rip), %rdi     # 0x51d6f
callq *0x48(%r14)
movss 0x147d6(%rip), %xmm0    # 0x4ef28
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 0x3a7bd
movq 0x2be7a(%rip), %r15     # 0x66600
leaq 0x1ac08(%rip), %rsi     # 0x55395
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r15)
movq 0x20(%r15), %r12
leaq 0x175ce(%rip), %rdi     # 0x51d6f
callq *0x48(%r15)
movss 0x1477b(%rip), %xmm0    # 0x4ef28
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 0x19530
// File: /workspace/github_c_makefile_star2_O2/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 0x3a7f4
movl $0x2, 0x290(%rdi)
movq 0x2c195(%rip), %rax     # 0x66990
movq %rax, 0x228(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b753(%rip), %rsi     # 0x55f91
callq 0x18bc0
testl %eax, %eax
je 0x3a908
cmpl $0x0, 0x254(%r14)
jle 0x3a92e
leaq 0x19c(%rbx), %rdi
movss 0x190(%rbx), %xmm0
mulss 0x146a4(%rip), %xmm0    # 0x4ef14
leaq 0x1c0(%r14), %rsi
callq 0x18a70
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x3a92e
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 0x2c4dd(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
ucomiss 0x24c(%r14), %xmm0
jbe 0x3a92e
addss 0x1535e(%rip), %xmm0    # 0x4fc38
movss %xmm0, 0x24c(%r14)
movq 0x2bd16(%rip), %rax     # 0x66600
movl 0x545e0(%rip), %edx     # 0x8eed0
movss 0x14630(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %r14, %rdi
xorl %esi, %esi
movaps %xmm0, %xmm1
callq *0x20(%rax)
jmp 0x3a92e
leaq 0x19c(%rbx), %rdi
movss 0x190(%rbx), %xmm0
mulss 0x145f5(%rip), %xmm0    # 0x4ef14
addq $0x1c0, %r14            # imm = 0x1C0
movq %r14, %rsi
callq 0x18a70
testb $0x1, 0x140(%rbx)
jne 0x3a93f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/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 0x18520
movq 0x2bc9f(%rip), %rax     # 0x66600
leaq 0x1aa41(%rip), %rdi     # 0x553a9
movq %rax, %r14
callq *0x48(%rax)
movl %eax, 0x5455c(%rip)     # 0x8eed0
movq 0x2c5c5(%rip), %rax     # 0x66f40
movq %rax, 0x220(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3a99e
jp 0x3a99e
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_O2/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 0x2bc32(%rip), %rax     # 0x66600
callq *0x90(%rax)
testb $0x2, 0x140(%rbx)
jne 0x3a9e5
andq $0x0, 0x228(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3aa10
movq %rdi, %rbx
movss 0x144(%rdi), %xmm1
movq 0x2c39a(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x3aa19
addq $0x8, %rsp
jmp 0x3aab0
movq %rsi, %r14
movl 0x140(%rbx), %r10d
xorl %ecx, %ecx
testb $0x10, %r10b
sete %cl
leaq 0x1a881(%rip), %rdx     # 0x552b4
addss (%rdx,%rcx,4), %xmm0
movss %xmm0, 0x144(%rbx)
testb $0x4, %r10b
jne 0x3aa7c
movl (%rax), %eax
pushq $0xa
popq %rcx
cltd
idivl %ecx
testl %edx, %edx
jne 0x3aa7c
movq 0x2bba7(%rip), %rax     # 0x66600
movl 0x2e8(%rbx), %edx
movss 0x144c1(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %r14, %rdi
xorl %esi, %esi
movaps %xmm0, %xmm1
callq *0x20(%rax)
movl 0x140(%rbx), %r10d
shll $0x2, %r10d
andl $0x20, %r10d
leaq 0x4(%r14), %r8
movl 0x280(%rbx), %eax
movq 0x2bcd3(%rip), %rcx     # 0x66768
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x1f
pushq %r10
pushq %rax
pushq %rax
callq 0x19260
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18520
movq 0x2bb39(%rip), %rax     # 0x66600
leaq 0x1a8ec(%rip), %rdi     # 0x553ba
movq %rax, %r14
callq *0x48(%rax)
movl %eax, 0x2e8(%rbx)
movq 0x2bb67(%rip), %rax     # 0x66648
movq %rax, 0x220(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x3aafb
movl $0x5, 0x280(%rbx)
movl 0x140(%rbx), %eax
movl %eax, %ecx
notl %ecx
andl $0x1, %ecx
movl %ecx, 0x108(%rbx)
testb $0x2, %al
je 0x3ab20
movq 0x2c307(%rip), %rax     # 0x66e20
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_O2/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 0x2bb16(%rip), %r14     # 0x66668
cmpq $0x0, 0x48(%r14)
je 0x3ab8c
movq %rbx, %rdi
callq 0x18520
movq 0x48(%r14), %rdi
callq 0x197a0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1e0(%rbx)
movq 0x2c033(%rip), %rax     # 0x66bb0
movq %rax, 0x220(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2ba6d(%rip), %rax     # 0x66600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x1a825(%rip), %rdi     # 0x553cc
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/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 0x3abc8
retq
movl 0xc8(%rsi), %eax
andl $0x6, %eax
cmpl $0x4, %eax
jne 0x3abc7
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 0x3abc7
andq $0x0, 0x2b8(%rsi)
movss 0x1a4(%rdi), %xmm0
movss %xmm0, 0x1c8(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3ac4c
jp 0x3ac4c
movl $0x43480000, 0x190(%rbx) # imm = 0x43480000
movq 0x2ba15(%rip), %r14     # 0x66668
cmpl $0x0, 0x28(%r14)
jne 0x3ac62
movl $0xc8, 0x28(%r14)
movss 0x14(%rbx), %xmm0
ucomiss %xmm1, %xmm0
jne 0x3ac75
jp 0x3ac75
movl $0x43b40000, 0x14(%rbx) # imm = 0x43B40000
movq %rbx, %rdi
callq 0x18520
movq 0x2ba5c(%rip), %rax     # 0x666e0
movq %rax, 0x220(%rbx)
cvtsi2ssl 0x28(%r14), %xmm0
movss %xmm0, 0x1a4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)