LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ThrowHead
void ThrowHead (edict_t *self, char *gibname, int damage, int type)
{
	vec3_t	vd;
	float	vscale;

	self->s.skinnum = 0;
	self->s.frame = 0;
	VectorClear (self->mins);
	VectorClear (self->maxs);

	self->s.modelindex2 = 0;
	gi.setmodel (self, gibname);
	self->solid = SOLID_NOT;
	self->s.effects |= EF_GIB;
	self->s.effects &= ~EF_FLIES;
	self->s.sound = 0;
	self->flags |= FL_NO_KNOCKBACK;
	self->svflags &= ~SVF_MONSTER;
	self->takedamage = DAMAGE_YES;
	self->die = gib_die;

	if (type == GIB_ORGANIC)
	{
		self->movetype = MOVETYPE_TOSS;
		self->touch = gib_touch;
		vscale = 0.5;
	}
	else
	{
		self->movetype = MOVETYPE_BOUNCE;
		vscale = 1.0;
	}

	VelocityForDamage (damage, vd);
	VectorMA (self->velocity, vscale, vd, self->velocity);
	ClipGibVelocity (self);

	self->avelocity[YAW] = crandom()*600;

	self->think = G_FreeEdict;
	self->nextthink = level.time + 10 + random()*10;

	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0x38(%rdi)
movl %r12d, 0x2c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xcc(%rdi)
movq %r12, 0xdc(%rdi)
movq 0x34f7c(%rip), %r15     # 0x68600
callq *0x58(%r15)
movl %r12d, 0x108(%rbx)
movl $0xffffbffd, %eax       # imm = 0xFFFFBFFD
andl 0x40(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x40(%rbx)
movl %r12d, 0x4c(%rbx)
orb $0x8, 0x11d(%rbx)
andb $-0x5, 0xc8(%rbx)
movl $0x1, 0x27c(%rbx)
movq 0x35578(%rip), %rax     # 0x68c38
movq %rax, 0x238(%rbx)
testl %r14d, %r14d
je 0x336e0
movss 0x1f854(%rip), %xmm0    # 0x52f28
movss %xmm0, (%rsp)
movl $0x9, %eax
jmp 0x33700
movq 0x34f41(%rip), %rax     # 0x68628
movq %rax, 0x220(%rbx)
movss 0x20d0a(%rip), %xmm0    # 0x54400
movss %xmm0, (%rsp)
movl $0x7, %eax
movl %eax, 0x118(%rbx)
leaq 0x4(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x19600
leaq 0x1c0(%rbx), %rdi
movss (%rsp), %xmm0
movq %r14, %rsi
movq %rdi, %rdx
callq 0x19760
movq %rbx, %rdi
callq 0x19030
callq 0x19a10
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1fb39(%rip), %xmm0    # 0x53288
cvtss2sd %xmm0, %xmm0
addsd 0x224bd(%rip), %xmm0    # 0x55c18
addsd %xmm0, %xmm0
mulsd 0x23bf1(%rip), %xmm0    # 0x57358
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1d0(%rbx)
movq 0x34cb6(%rip), %rax     # 0x68430
movq %rax, 0x210(%rbx)
movq 0x35618(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1f77f(%rip), %xmm0    # 0x52f14
movss %xmm0, (%rsp)
callq 0x19a10
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1fad8(%rip), %xmm0    # 0x53288
mulss 0x1f75c(%rip), %xmm0    # 0x52f14
addss (%rsp), %xmm0
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
callq *0x90(%r15)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ThrowClientHead
void ThrowClientHead (edict_t *self, int damage)
{
	vec3_t	vd;
	char	*gibname;

	if (rand()&1)
	{
		gibname = "models/objects/gibs/head2/tris.md2";
		self->s.skinnum = 1;		// second skin is player
	}
	else
	{
		gibname = "models/objects/gibs/skull/tris.md2";
		self->s.skinnum = 0;
	}

	self->s.origin[2] += 32;
	self->s.frame = 0;
	gi.setmodel (self, gibname);
	VectorSet (self->mins, -16, -16, 0);
	VectorSet (self->maxs, 16, 16, 16);

	self->takedamage = DAMAGE_NO;
	self->solid = SOLID_NOT;
	self->s.effects = EF_GIB;
	self->s.sound = 0;
	self->flags |= FL_NO_KNOCKBACK;

	self->movetype = MOVETYPE_BOUNCE;
	VelocityForDamage (damage, vd);
	VectorAdd (self->velocity, vd, self->velocity);

	if (self->client)	// bodies in the queue don't have a client anymore
	{
		self->client->anim_priority = ANIM_DEATH;
		self->client->anim_end = self->s.frame;
	}
	else
	{
		self->think = NULL;
		self->nextthink = 0;
	}

	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x19a10
andl $0x1, %eax
leaq 0x23d68(%rip), %rcx     # 0x57562
leaq 0x23d3e(%rip), %rsi     # 0x5753f
cmoveq %rcx, %rsi
movl %eax, 0x3c(%rbx)
movss 0xc(%rbx), %xmm0
addss 0x1fc37(%rip), %xmm0    # 0x5344c
movss %xmm0, 0xc(%rbx)
xorl %r14d, %r14d
movl %r14d, 0x38(%rbx)
movq 0x34dd8(%rip), %r15     # 0x68600
movq %rbx, %rdi
callq *0x58(%r15)
movaps 0x23b3a(%rip), %xmm0    # 0x57370
movups %xmm0, 0xcc(%rbx)
movsd 0x23b3b(%rip), %xmm0    # 0x57380
movsd %xmm0, 0xdc(%rbx)
movl %r14d, 0x27c(%rbx)
movl %r14d, 0x108(%rbx)
movl $0x2, 0x40(%rbx)
movl %r14d, 0x4c(%rbx)
orb $0x8, 0x11d(%rbx)
movl $0x9, 0x118(%rbx)
leaq 0x8(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x19600
movsd 0x1c0(%rbx), %xmm0
movsd (%r14), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, 0x1c0(%rbx)
movss 0x1c8(%rbx), %xmm0
addss 0x8(%r14), %xmm0
movss %xmm0, 0x1c8(%rbx)
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x338d1
movl $0x5, 0xef8(%rax)
movl 0x38(%rbx), %ecx
movl %ecx, 0xef4(%rax)
jmp 0x338e6
movq $0x0, 0x210(%rbx)
movl $0x0, 0x200(%rbx)
movq %rbx, %rdi
callq *0x90(%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: BecomeExplosion1
void BecomeExplosion1 (edict_t *self)
{
	if (!self->dontfree)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_EXPLOSION1);
		gi.WritePosition (self->s.origin);
		gi.multicast (self->s.origin, MULTICAST_PVS);
		
		G_FreeEdict (self);
	}
}

// Assembly:
cmpl $0x0, 0x49c(%rdi)
je 0x33b34
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x34abd(%rip), %r15     # 0x68600
movl $0x3, %edi
callq *0xc8(%r15)
movl $0x5, %edi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
movq %r14, %rdi
movl $0x2, %esi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: BecomeExplosion2
void BecomeExplosion2 (edict_t *self)
{
	if (!self->dontfree)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_EXPLOSION2);
		gi.WritePosition (self->s.origin);
		gi.multicast (self->s.origin, MULTICAST_PVS);

		G_FreeEdict (self);
	}
}

// Assembly:
cmpl $0x0, 0x49c(%rdi)
je 0x33b8f
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x34a62(%rip), %r15     # 0x68600
movl $0x3, %edi
callq *0xc8(%r15)
movl $0x6, %edi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
movq %r14, %rdi
movl $0x2, %esi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: path_corner_touch
void path_corner_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	vec3_t		v;
	edict_t		*next;

	if (other->movetarget != self)
		return;
	
	if (other->enemy)
		return;

	if (self->pathtarget)
	{
		char *savetarget;

		savetarget = self->target;
		self->target = self->pathtarget;
		G_UseTargets (self, other);
		self->target = savetarget;
	}

	if (self->target)
		next = G_PickTarget(self->target);
	else
		next = NULL;

	if ((next) && (next->spawnflags & 1))
	{
		VectorCopy (next->s.origin, v);
		v[2] += next->mins[2];
		v[2] -= other->mins[2];
		VectorCopy (v, other->s.origin);
		next = G_PickTarget(next->target);
		other->s.event = EV_OTHER_TELEPORT;
	}

	other->goalentity = other->movetarget = next;

	if (self->wait)
	{
		other->monsterinfo.pausetime = level.time + self->wait;
		other->monsterinfo.stand (other);
		return;
	}

	if (!other->movetarget)
	{
		other->monsterinfo.pausetime = level.time + 100000000;
		other->monsterinfo.stand (other);
	}
	else
	{
		VectorSubtract (other->goalentity->s.origin, other->s.origin, v);
		other->ideal_yaw = vectoyaw (v);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq %rdi, 0x1f0(%rsi)
jne 0x33bfc
cmpq $0x0, 0x2a0(%rsi)
je 0x33c06
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq 0x150(%rdi), %r14
movq 0x170(%rdi), %rax
testq %rax, %rax
je 0x33c38
movq %rax, 0x150(%rbx)
movq %rbx, %rdi
movq %rsi, %r15
callq 0x198e0
movq %r15, %rsi
movq %r14, 0x150(%rbx)
testq %r14, %r14
je 0x33c9f
movq %rsi, %r15
movq %r14, %rdi
callq 0x18350
testq %rax, %rax
je 0x33ca3
testb $0x1, 0x140(%rax)
movq %r15, %rsi
je 0x33ca8
movss 0xc(%rax), %xmm0
addss 0xd4(%rax), %xmm0
movaps %xmm0, %xmm1
subss 0xd4(%rsi), %xmm1
movsd 0x4(%rax), %xmm2
movss %xmm0, 0x8(%rsp)
movsd %xmm2, 0x4(%rsi)
movss %xmm1, 0xc(%rsi)
movq 0x150(%rax), %rdi
callq 0x18350
movq %r15, %rsi
movl $0x7, 0x50(%r15)
jmp 0x33ca8
xorl %eax, %eax
jmp 0x33ca8
xorl %eax, %eax
movq %r15, %rsi
movq %rax, 0x1f0(%rsi)
movq %rax, 0x1e8(%rsi)
movss 0x2f8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x33cc8
jnp 0x33cee
movq 0x350d1(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x420(%rsi)
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x3d0(%rsi)
testq %rax, %rax
je 0x33d2a
movsd 0x4(%rax), %xmm0
movsd 0x4(%rsi), %xmm1
subps %xmm1, %xmm0
movq %rsp, %rdi
movlps %xmm0, (%rdi)
movss 0xc(%rax), %xmm0
subss 0xc(%rsi), %xmm0
movss %xmm0, 0x8(%rdi)
movq %rsi, %rbx
callq 0x18070
movss %xmm0, 0x1fc(%rbx)
jmp 0x33bfc
movq 0x3506f(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x235fa(%rip), %xmm0    # 0x57338
jmp 0x33cd4
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_path_corner
void SP_path_corner (edict_t *self)
{
	if (!self->targetname)
	{
		gi.dprintf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

	self->solid = SOLID_TRIGGER;
	self->touch = path_corner_touch;
	VectorSet (self->mins, -8, -8, -8);
	VectorSet (self->maxs, 8, 8, 8);
	self->svflags |= SVF_NOCLIENT;
	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x158(%rdi)
je 0x33da5
movl $0x1, 0x108(%rbx)
movq 0x3508e(%rip), %rax     # 0x68df0
movq %rax, 0x220(%rbx)
movaps 0x23660(%rip), %xmm0    # 0x573d0
movups %xmm0, 0xcc(%rbx)
movsd 0x23661(%rip), %xmm0    # 0x573e0
movsd %xmm0, 0xdc(%rbx)
orb $0x1, 0xc8(%rbx)
movq 0x3486b(%rip), %rax     # 0x68600
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
movq 0x34854(%rip), %rax     # 0x68600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x237cc(%rip), %rdi     # 0x5758c
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: point_combat_touch
void point_combat_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	edict_t	*activator;

	if (other->movetarget != self)
		return;

	if (self->target)
	{
		other->target = self->target;
		other->goalentity = other->movetarget = G_PickTarget(other->target);
		if (!other->goalentity)
		{
			gi.dprintf("%s at %s target %s does not exist\n", self->classname, vtos(self->s.origin), self->target);
			other->movetarget = self;
		}
		self->target = NULL;
	}
	else if ((self->spawnflags & 1) && !(other->flags & (FL_SWIM|FL_FLY)))
	{
		other->monsterinfo.pausetime = level.time + 100000000;
		other->monsterinfo.aiflags |= AI_STAND_GROUND;
		other->monsterinfo.stand (other);
	}

	if (other->movetarget == self)
	{
		other->target = NULL;
		other->movetarget = NULL;
		other->goalentity = other->enemy;
		other->monsterinfo.aiflags &= ~AI_COMBAT_POINT;
	}

	if (self->pathtarget)
	{
		char *savetarget;

		savetarget = self->target;
		self->target = self->pathtarget;
		if (other->enemy && other->enemy->client)
			activator = other->enemy;
		else if (other->oldenemy && other->oldenemy->client)
			activator = other->oldenemy;
		else if (other->activator && other->activator->client)
			activator = other->activator;
		else
			activator = other;
		G_UseTargets (self, activator);
		self->target = savetarget;
	}
}

// Assembly:
cmpq %rdi, 0x1f0(%rsi)
je 0x33de1
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x33e6a
movq %rdi, 0x150(%r14)
callq 0x18350
movq %rax, 0x1f0(%r14)
movq %rax, 0x1e8(%r14)
testq %rax, %rax
jne 0x33e58
movq 0x347df(%rip), %rax     # 0x68600
movq 0x8(%rax), %r12
movq 0x138(%rbx), %r15
leaq 0x4(%rbx), %rdi
callq 0x190a0
movq 0x150(%rbx), %rcx
leaq 0x2376f(%rip), %rdi     # 0x575b2
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r12
movq %rbx, 0x1f0(%r14)
movq %rbx, %rax
movq $0x0, 0x150(%rbx)
cmpq %rbx, %rax
jne 0x33ea7
jmp 0x33e81
testb $0x1, 0x140(%rbx)
je 0x33e81
testb $0x3, 0x11c(%r14)
je 0x33f18
xorl %eax, %eax
movq %rax, 0x150(%r14)
movq %rax, 0x1f0(%r14)
movq 0x2a0(%r14), %rax
movq %rax, 0x1e8(%r14)
andb $-0x11, 0x3c1(%r14)
movq 0x170(%rbx), %rax
testq %rax, %rax
je 0x33f0c
movq 0x150(%rbx), %r15
movq %rax, 0x150(%rbx)
movq 0x2a0(%r14), %rsi
testq %rsi, %rsi
je 0x33ed4
cmpq $0x0, 0x58(%rsi)
jne 0x33efd
movq 0x2a8(%r14), %rsi
testq %rsi, %rsi
je 0x33ee7
cmpq $0x0, 0x58(%rsi)
jne 0x33efd
movq 0x2b0(%r14), %rsi
testq %rsi, %rsi
je 0x33efa
cmpq $0x0, 0x58(%rsi)
jne 0x33efd
movq %r14, %rsi
movq %rbx, %rdi
callq 0x198e0
movq %r15, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x34e81(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x2340c(%rip), %xmm0    # 0x57338
movss %xmm0, 0x420(%r14)
orb $0x1, 0x3c0(%r14)
movq %r14, %rdi
callq *0x3d0(%r14)
movq 0x1f0(%r14), %rax
jmp 0x33e63
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_point_combat
void SP_point_combat (edict_t *self)
{
	if (deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}
	self->solid = SOLID_TRIGGER;
	self->touch = point_combat_touch;
	VectorSet (self->mins, -8, -8, -16);
	VectorSet (self->maxs, 8, 8, 16);
	self->svflags = SVF_NOCLIENT;
	gi.linkentity (self);
}

// Assembly:
movq 0x34f66(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x33f6c
jnp 0x33f71
jmp 0x19a50
movl $0x1, %eax
movl %eax, 0x108(%rdi)
movq 0x34f05(%rip), %rcx     # 0x68e88
movq %rcx, 0x220(%rdi)
movaps 0x2345f(%rip), %xmm0    # 0x573f0
movups %xmm0, 0xcc(%rdi)
movsd 0x23460(%rip), %xmm0    # 0x57400
movsd %xmm0, 0xdc(%rdi)
movl %eax, 0xc8(%rdi)
movq 0x3464b(%rip), %rax     # 0x68600
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_viewthing
void SP_viewthing(edict_t *ent)
{
	gi.dprintf ("viewthing spawned\n");

	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	ent->s.renderfx = RF_FRAMELERP;
	VectorSet (ent->mins, -16, -16, -24);
	VectorSet (ent->maxs, 16, 16, 32);
	ent->s.modelindex = gi.modelindex ("models/objects/banner/tris.md2");
	gi.linkentity (ent);
	ent->nextthink = level.time + 0.5;
	ent->think = TH_viewthing;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x345e7(%rip), %r14     # 0x68600
leaq 0x235b5(%rip), %rdi     # 0x575d5
xorl %eax, %eax
callq *0x8(%r14)
movl $0x0, 0x118(%rbx)
movl $0x2, 0x108(%rbx)
movl $0x40, 0x44(%rbx)
movaps 0x233c8(%rip), %xmm0    # 0x57410
movups %xmm0, 0xcc(%rbx)
movsd 0x233c9(%rip), %xmm0    # 0x57420
movsd %xmm0, 0xdc(%rbx)
leaq 0x23582(%rip), %rdi     # 0x575e8
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x34d22(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x20375(%rip), %xmm0    # 0x54400
movss %xmm0, 0x200(%rbx)
movq 0x343ae(%rip), %rax     # 0x68448
movq %rax, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_light
void SP_light (edict_t *self)
{
	// no targeted lights in deathmatch, because they cause global messages
	if (!self->targetname || deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}

	if (self->style >= 32)
	{
		self->use = light_use;
		if (self->spawnflags & START_OFF)
			gi.configstring (CS_LIGHTS+self->style, "a");
		else
			gi.configstring (CS_LIGHTS+self->style, "m");
	}
}

// Assembly:
cmpq $0x0, 0x158(%rdi)
je 0x19a50
movq 0x34ddb(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x340f7
jnp 0x340fc
jmp 0x19a50
movl 0x32c(%rdi), %eax
cmpl $0x20, %eax
jl 0x34137
leaq 0x35(%rip), %rcx        # 0x34143
movq %rcx, 0x228(%rdi)
addl $0x320, %eax            # imm = 0x320
testb $0x1, 0x140(%rdi)
movq 0x344d8(%rip), %rcx     # 0x68600
movq 0x30(%rcx), %rcx
jne 0x34138
leaq 0x1e12a(%rip), %rsi     # 0x5225f
jmp 0x3413f
retq
leaq 0x1e589(%rip), %rsi     # 0x526c8
movl %eax, %edi
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: light_use
static void light_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->spawnflags & START_OFF)
	{
		gi.configstring (CS_LIGHTS+self->style, "m");
		self->spawnflags &= ~START_OFF;
	}
	else
	{
		gi.configstring (CS_LIGHTS+self->style, "a");
		self->spawnflags |= START_OFF;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x320, %edi            # imm = 0x320
movq 0x344ad(%rip), %rax     # 0x68600
movq 0x30(%rax), %rax
addl 0x32c(%rbx), %edi
testb $0x1, 0x140(%rbx)
jne 0x3417a
leaq 0x1e55b(%rip), %rsi     # 0x526c8
callq *%rax
movl 0x140(%rbx), %eax
orl $0x1, %eax
jmp 0x3418c
leaq 0x1e0de(%rip), %rsi     # 0x5225f
callq *%rax
movl 0x140(%rbx), %eax
andl $-0x2, %eax
movl %eax, 0x140(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_wall_use
void func_wall_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->solid == SOLID_NOT)
	{
		self->solid = SOLID_BSP;
		self->svflags &= ~SVF_NOCLIENT;
		KillBox (self);
	}
	else
	{
		self->solid = SOLID_NOT;
		self->svflags |= SVF_NOCLIENT;
	}
	gi.linkentity (self);

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x108(%rdi)
je 0x341b4
movl $0x0, 0x108(%rbx)
orb $0x1, 0xc8(%rbx)
jmp 0x341cd
movl $0x3, 0x108(%rbx)
andb $-0x2, 0xc8(%rbx)
movq %rbx, %rdi
callq 0x18a90
movq 0x3442c(%rip), %rax     # 0x68600
movq %rbx, %rdi
callq *0x90(%rax)
testb $0x2, 0x140(%rbx)
jne 0x341f1
movq $0x0, 0x228(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_wall
void SP_func_wall (edict_t *self)
{
	self->movetype = MOVETYPE_PUSH;
	gi.setmodel (self, self->model);

	if (self->spawnflags & 8)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 16)
		self->s.effects |= EF_ANIM_ALLFAST;

	// just a wall
	if ((self->spawnflags & 7) == 0)
	{
		self->solid = SOLID_BSP;
		gi.linkentity (self);
		return;
	}

	// it must be TRIGGER_SPAWN
	if (!(self->spawnflags & 1))
	{
//		gi.dprintf("func_wall missing TRIGGER_SPAWN\n");
		self->spawnflags |= 1;
	}

	// yell if the spawnflags are odd
	if (self->spawnflags & 4)
	{
		if (!(self->spawnflags & 2))
		{
			gi.dprintf("func_wall START_ON without TOGGLE\n");
			self->spawnflags |= 2;
		}
	}

	self->use = func_wall_use;
	if (self->spawnflags & 4)
	{
		self->solid = SOLID_BSP;
	}
	else
	{
		self->solid = SOLID_NOT;
		self->svflags |= SVF_NOCLIENT;
	}
	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x118(%rdi)
movq 0x343f5(%rip), %rax     # 0x68600
movq 0x120(%rdi), %rsi
movq %rax, %r14
callq *0x58(%rax)
movl 0x140(%rbx), %eax
testb $0x8, %al
je 0x34226
orb $0x10, 0x41(%rbx)
testb $0x10, %al
je 0x3422e
orb $0x20, 0x41(%rbx)
movl $0x3, %ebp
testb $0x7, %al
je 0x34285
testb $0x1, %al
jne 0x34244
orl $0x1, %eax
movl %eax, 0x140(%rbx)
movl %eax, %ecx
andl $0x6, %ecx
cmpl $0x4, %ecx
jne 0x3426a
leaq 0x233b2(%rip), %rdi     # 0x57607
xorl %eax, %eax
callq *0x8(%r14)
movl 0x140(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x140(%rbx)
movq 0x341a7(%rip), %rcx     # 0x68418
movq %rcx, 0x228(%rbx)
testb $0x4, %al
jne 0x34285
orb $0x1, 0xc8(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x108(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_object_touch
void func_object_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	// only squash thing we fall on top of
	if (!plane)
		return;
	if (plane->normal[2] < 1.0)
		return;
	if (other->takedamage == DAMAGE_NO)
		return;
	T_Damage (other, self, self, vec3_origin, self->s.origin, vec3_origin, self->dmg, 1, 0, MOD_CRUSH);
}

// Assembly:
testq %rdx, %rdx
je 0x342eb
movss 0x1ec80(%rip), %xmm0    # 0x52f28
ucomiss 0x8(%rdx), %xmm0
ja 0x342eb
cmpl $0x0, 0x27c(%rsi)
je 0x342eb
pushq %rax
movq %rdi, %rax
leaq 0x4(%rdi), %r8
movl 0x280(%rdi), %r10d
movq 0x3449b(%rip), %rcx     # 0x68768
movq %rsi, %rdi
movq %rax, %rsi
movq %rax, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq %r10
callq 0x190f0
addq $0x20, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_object
void SP_func_object (edict_t *self)
{
	gi.setmodel (self, self->model);

	self->mins[0] += 1;
	self->mins[1] += 1;
	self->mins[2] += 1;
	self->maxs[0] -= 1;
	self->maxs[1] -= 1;
	self->maxs[2] -= 1;

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

	if (self->spawnflags == 0)
	{
		self->solid = SOLID_BSP;
		self->movetype = MOVETYPE_PUSH;
		self->think = func_object_release;
		self->nextthink = level.time + 2 * FRAMETIME;
	}
	else
	{
		self->solid = SOLID_NOT;
		self->movetype = MOVETYPE_PUSH;
		self->use = func_object_use;
		self->svflags |= SVF_NOCLIENT;
	}

	if (self->spawnflags & 2)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 4)
		self->s.effects |= EF_ANIM_ALLFAST;

	self->clipmask = MASK_MONSTERSOLID;

	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x342ae(%rip), %rax     # 0x68600
movq 0x120(%rdi), %rsi
movq %rax, %r14
callq *0x58(%rax)
movups 0xcc(%rbx), %xmm0
addps 0x230c3(%rip), %xmm0    # 0x57430
movups %xmm0, 0xcc(%rbx)
movsd 0xdc(%rbx), %xmm0
addps 0x230bd(%rip), %xmm0    # 0x57440
movlps %xmm0, 0xdc(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x3439d
movl $0x64, 0x280(%rbx)
movl 0x140(%rbx), %eax
testl %eax, %eax
je 0x343e2
movl $0x0, 0x108(%rbx)
movl $0x2, 0x118(%rbx)
movq 0x34996(%rip), %rcx     # 0x68d58
movq %rcx, 0x228(%rbx)
orb $0x1, 0xc8(%rbx)
testb $0x2, %al
je 0x343d8
orb $0x10, 0x41(%rbx)
testb $0x4, %al
je 0x34420
orb $0x20, 0x41(%rbx)
jmp 0x34420
movl $0x3, 0x108(%rbx)
movl $0x2, 0x118(%rbx)
movq 0x341eb(%rip), %rax     # 0x685e8
movq %rax, 0x210(%rbx)
movq 0x34995(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x21bb0(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rbx)
movl $0x2020003, 0x10c(%rbx) # imm = 0x2020003
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_explosive_respawn
void func_explosive_respawn (edict_t *self)
{
	gi.sound (self, CHAN_AUTO, gi.soundindex ("tank/thud.wav"), 1, ATTN_NORM, 0);
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->takedamage = DAMAGE_YES;
	self->think = 0;
	KillBox (self);
	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x341b4(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
movq %rax, %r15
leaq 0x231d0(%rip), %rdi     # 0x5762a
callq *0x48(%rax)
movss 0x1eac3(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r14
movl $0x3, 0x108(%rbx)
andb $-0x2, 0xc8(%rbx)
movl $0x1, 0x27c(%rbx)
movq $0x0, 0x210(%rbx)
movq %rbx, %rdi
callq 0x18a90
movq %rbx, %rdi
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_explosive_spawn
void func_explosive_spawn (edict_t *self, edict_t *other, edict_t *activator)
{
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->use = NULL;
	KillBox (self);
	gi.linkentity (self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3, 0x108(%rdi)
andb $-0x2, 0xc8(%rdi)
movq $0x0, 0x228(%rdi)
callq 0x18a90
movq 0x33d79(%rip), %rax     # 0x68600
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_explosive
void SP_func_explosive (edict_t *self)
{
	/*
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (self);
		return;
	}
	*/

	// LM_JORM
	if (!self->speed)
	{	// auto-remove for deathmatch
		G_FreeEdict (self);
		return;
	}
	// LM_JORM

	self->movetype = MOVETYPE_PUSH;

	gi.modelindex ("models/objects/debris1/tris.md2");
	gi.modelindex ("models/objects/debris2/tris.md2");

	gi.setmodel (self, self->model);

	if (self->spawnflags & 1)
	{
		self->svflags |= SVF_NOCLIENT;
		self->solid = SOLID_NOT;
		self->use = func_explosive_spawn;
	}
	else
	{
		self->solid = SOLID_BSP;
		if (self->targetname)
			self->use = func_explosive_use;
	}

	if (self->spawnflags & 2)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 4)
		self->s.effects |= EF_ANIM_ALLFAST;

	if (self->use != func_explosive_use)
	{
//		if (!self->health)
		//surt health might be less than 0 on respawn
		if (self->health <= 0)
			self->health = 100;
		self->die = func_explosive_explode;
		self->takedamage = DAMAGE_YES;
	}

	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x348ab
jnp 0x3490a
movl $0x2, 0x118(%rbx)
movq 0x33d44(%rip), %r15     # 0x68600
leaq 0x22d75(%rip), %rdi     # 0x57638
callq *0x40(%r15)
leaq 0x21ef3(%rip), %rdi     # 0x567c1
callq *0x40(%r15)
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %r14
callq *0x58(%r15)
movl 0x140(%rbx), %eax
testb $0x1, %al
jne 0x34917
movl $0x3, 0x108(%rbx)
cmpq $0x0, 0x158(%rbx)
je 0x34936
movq 0x343f8(%rip), %rcx     # 0x68d00
jmp 0x3492f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
orb $0x1, 0xc8(%rbx)
movl $0x0, 0x108(%rbx)
movq 0x343f9(%rip), %rcx     # 0x68d28
movq %rcx, 0x228(%rbx)
testb $0x2, %al
je 0x3493e
orb $0x10, 0x41(%rbx)
testb $0x4, %al
je 0x34946
orb $0x20, 0x41(%rbx)
movq 0x228(%rbx), %rax
cmpq 0x343ac(%rip), %rax     # 0x68d00
je 0x34981
cmpl $0x0, 0x254(%rbx)
jg 0x34969
movl $0x64, 0x254(%rbx)
movq 0x33d10(%rip), %rax     # 0x68680
movq %rax, 0x238(%rbx)
movl $0x1, 0x27c(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: barrel_touch
void barrel_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)

{
	float	ratio;
	vec3_t	v;

	if ((!other->groundentity) || (other->groundentity == self))
		return;

	ratio = (float)other->mass / (float)self->mass;
	VectorSubtract (self->s.origin, other->s.origin, v);
	M_walkmove (self, vectoyaw(v), 20 * ratio * FRAMETIME);
}

// Assembly:
movq 0x2b8(%rsi), %rax
testq %rax, %rax
sete %cl
cmpq %rdi, %rax
sete %al
orb %cl, %al
jne 0x34a17
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtsi2ssl 0x1d8(%rsi), %xmm1
cvtsi2ssl 0x1d8(%rdi), %xmm0
divss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movsd 0x4(%rdi), %xmm0
movsd 0x4(%rsi), %xmm1
subps %xmm1, %xmm0
leaq 0x10(%rsp), %rdi
movlps %xmm0, (%rdi)
movss 0xc(%rbx), %xmm0
subss 0xc(%rsi), %xmm0
movss %xmm0, 0x8(%rdi)
callq 0x18070
movss 0xc(%rsp), %xmm1
mulss 0x1f23e(%rip), %xmm1    # 0x53c40
mulss 0x1e886(%rip), %xmm1    # 0x53290
movq %rbx, %rdi
callq 0x18490
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: barrel_delay
void barrel_delay (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	self->takedamage = DAMAGE_NO;
	self->nextthink = level.time + 2 * FRAMETIME;
	self->think = barrel_explode;
	self->activator = attacker;
}

// Assembly:
movl $0x0, 0x27c(%rdi)
movq 0x337b7(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x209d2(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rdi)
movq 0x33513(%rip), %rax     # 0x68b18
movq %rax, 0x210(%rdi)
movq %rdx, 0x2b0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_explobox
void SP_misc_explobox (edict_t *self)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (self);
		return;
	}

	gi.modelindex ("models/objects/debris1/tris.md2");
	gi.modelindex ("models/objects/debris2/tris.md2");
	gi.modelindex ("models/objects/debris3/tris.md2");

	self->solid = SOLID_BBOX;
	self->movetype = MOVETYPE_STEP;

	self->model = "models/objects/barrels/tris.md2";
	self->s.modelindex = gi.modelindex (self->model);
	VectorSet (self->mins, -16, -16, 0);
	VectorSet (self->maxs, 16, 16, 40);

	if (!self->mass)
		self->mass = 400;
	if (!self->health)
		self->health = 10;
	if (!self->dmg)
		self->dmg = 150;

	self->die = barrel_delay;
	self->takedamage = DAMAGE_YES;
	self->monsterinfo.aiflags = AI_NOSTEP;

	self->touch = barrel_touch;

#ifdef MONSTERS_OK
	self->think = M_droptofloor;
#endif
	self->nextthink = level.time + 2 * FRAMETIME;

	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3389d(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x35635
jnp 0x35642
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19a50
movq 0x32fb7(%rip), %r15     # 0x68600
leaq 0x21fe8(%rip), %rdi     # 0x57638
callq *0x40(%r15)
leaq 0x21166(%rip), %rdi     # 0x567c1
callq *0x40(%r15)
leaq 0x21ff2(%rip), %rdi     # 0x57658
callq *0x40(%r15)
movl $0x2, 0x108(%rbx)
movl $0x5, 0x118(%rbx)
leaq 0x21ff3(%rip), %rdi     # 0x57678
movq %rdi, 0x120(%rbx)
movq %r15, %r14
callq *0x40(%r15)
movl %eax, 0x28(%rbx)
movaps 0x21cd3(%rip), %xmm0    # 0x57370
movups %xmm0, 0xcc(%rbx)
movsd 0x21da4(%rip), %xmm0    # 0x57450
movsd %xmm0, 0xdc(%rbx)
cmpl $0x0, 0x1d8(%rbx)
jne 0x356c7
movl $0x190, 0x1d8(%rbx)     # imm = 0x190
cmpl $0x0, 0x254(%rbx)
jne 0x356da
movl $0xa, 0x254(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x356ed
movl $0x96, 0x280(%rbx)
movq 0x3328c(%rip), %rax     # 0x68980
movq %rax, 0x238(%rbx)
movl $0x1, 0x27c(%rbx)
movl $0x400, 0x3c0(%rbx)     # imm = 0x400
movq 0x337f2(%rip), %rax     # 0x68f08
movq %rax, 0x220(%rbx)
movq 0x3367c(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x20897(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_blackhole
void SP_misc_blackhole (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_NOT;
	VectorSet (ent->mins, -64, -64, 0);
	VectorSet (ent->maxs, 64, 64, 8);
	ent->s.modelindex = gi.modelindex ("models/objects/black/tris.md2");
	ent->s.renderfx = RF_TRANSLUCENT;
	ent->use = misc_blackhole_use;
	ent->think = misc_blackhole_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x118(%rdi)
movl %eax, 0x108(%rdi)
movaps 0x21cc7(%rip), %xmm0    # 0x57460
movups %xmm0, 0xcc(%rdi)
movsd 0x21cc8(%rip), %xmm0    # 0x57470
movsd %xmm0, 0xdc(%rdi)
movq 0x32e49(%rip), %r14     # 0x68600
leaq 0x21eda(%rip), %rdi     # 0x57698
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0x20, 0x44(%rbx)
movq 0x32dd5(%rip), %rax     # 0x685a8
movq %rax, 0x228(%rbx)
movq 0x336af(%rip), %rax     # 0x68e90
movq %rax, 0x210(%rbx)
movq 0x335b1(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x207cc(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_eastertank
void SP_misc_eastertank (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -32, -32, -16);
	VectorSet (ent->maxs, 32, 32, 32);
	ent->s.modelindex = gi.modelindex ("models/monsters/tank/tris.md2");
	ent->s.frame = 254;
	ent->think = misc_eastertank_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x21c14(%rip), %xmm0    # 0x57480
movups %xmm0, 0xcc(%rdi)
movsd 0x21c15(%rip), %xmm0    # 0x57490
movsd %xmm0, 0xdc(%rdi)
movq 0x32d76(%rip), %r14     # 0x68600
leaq 0x21e25(%rip), %rdi     # 0x576b6
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0xfe, 0x38(%rbx)
movq 0x3321a(%rip), %rax     # 0x68ac0
movq %rax, 0x210(%rbx)
movq 0x334ec(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x20707(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_easterchick
void SP_misc_easterchick (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -32, -32, 0);
	VectorSet (ent->maxs, 32, 32, 32);
	ent->s.modelindex = gi.modelindex ("models/monsters/bitch/tris.md2");
	ent->s.frame = 208;
	ent->think = misc_easterchick_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x21b6f(%rip), %xmm0    # 0x574a0
movups %xmm0, 0xcc(%rdi)
movsd 0x21b50(%rip), %xmm0    # 0x57490
movsd %xmm0, 0xdc(%rdi)
movq 0x32cb1(%rip), %r14     # 0x68600
leaq 0x21d7e(%rip), %rdi     # 0x576d4
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0xd0, 0x38(%rbx)
movq 0x32e4d(%rip), %rax     # 0x687b8
movq %rax, 0x210(%rbx)
movq 0x33427(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x20642(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_easterchick2
void SP_misc_easterchick2 (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -32, -32, 0);
	VectorSet (ent->maxs, 32, 32, 32);
	ent->s.modelindex = gi.modelindex ("models/monsters/bitch/tris.md2");
	ent->s.frame = 248;
	ent->think = misc_easterchick2_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x21aaa(%rip), %xmm0    # 0x574a0
movups %xmm0, 0xcc(%rdi)
movsd 0x21a8b(%rip), %xmm0    # 0x57490
movsd %xmm0, 0xdc(%rdi)
movq 0x32bec(%rip), %r14     # 0x68600
leaq 0x21cb9(%rip), %rdi     # 0x576d4
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0xf8, 0x38(%rbx)
movq 0x329c8(%rip), %rax     # 0x683f8
movq %rax, 0x210(%rbx)
movq 0x33362(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x2057d(%rip), %xmm0    # 0x55fc8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: commander_body_think
void commander_body_think (edict_t *self)
{
	if (++self->s.frame < 24)
		self->nextthink = level.time + FRAMETIME;
	else
		self->nextthink = 0;

	if (self->s.frame == 22)
		gi.sound (self, CHAN_BODY, gi.soundindex ("tank/thud.wav"), 1, ATTN_NORM, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x38(%rdi)
cmpl $0x17, %ecx
jge 0x35ad5
movq 0x3331e(%rip), %rcx     # 0x68da0
movss 0x4(%rcx), %xmm0
addss 0x1d801(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
cmpl $0x16, %eax
jne 0x35adf
movq 0x32b5d(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
leaq 0x21b7c(%rip), %rdi     # 0x5762a
callq *0x48(%rax)
movss 0x1d46f(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x4, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
movl $0x0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_monster_commander_body
void SP_monster_commander_body (edict_t *self)
{
	self->movetype = MOVETYPE_NONE;
	self->solid = SOLID_BBOX;
	self->model = "models/monsters/commandr/tris.md2";
	self->s.modelindex = gi.modelindex (self->model);
	VectorSet (self->mins, -32, -32, 0);
	VectorSet (self->maxs, 32, 32, 48);
	self->use = commander_body_use;
	self->takedamage = DAMAGE_YES;
	self->flags = FL_GODMODE;
	self->s.renderfx |= RF_FRAMELERP;
	gi.linkentity (self);

	gi.soundindex ("tank/thud.wav");
	gi.soundindex ("tank/pain.wav");

	self->think = commander_body_drop;
	self->nextthink = level.time + 5 * FRAMETIME;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
leaq 0x21b71(%rip), %rdi     # 0x57701
movq %rdi, 0x120(%rbx)
movq 0x32a62(%rip), %r14     # 0x68600
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movaps 0x218f4(%rip), %xmm0    # 0x574a0
movups %xmm0, 0xcc(%rbx)
movsd 0x218f5(%rip), %xmm0    # 0x574b0
movsd %xmm0, 0xdc(%rbx)
movq 0x32fde(%rip), %rax     # 0x68ba8
movq %rax, 0x228(%rbx)
movl $0x1, 0x27c(%rbx)
movl $0x10, 0x11c(%rbx)
orb $0x40, 0x44(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
leaq 0x21a30(%rip), %rdi     # 0x5762a
callq *0x48(%r14)
leaq 0x21aee(%rip), %rdi     # 0x576f3
callq *0x48(%r14)
movq 0x329e0(%rip), %rax     # 0x685f0
movq %rax, 0x210(%rbx)
movq 0x33182(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1e7d5(%rip), %xmm0    # 0x54400
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_banner
void SP_misc_banner (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_NOT;
	ent->s.modelindex = gi.modelindex ("models/objects/banner/tris.md2");
	ent->s.frame = rand() % 16;
	gi.linkentity (ent);

	ent->think = misc_banner_think;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x118(%rdi)
movl %eax, 0x108(%rdi)
movq 0x32972(%rip), %r14     # 0x68600
leaq 0x21953(%rip), %rdi     # 0x575e8
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
callq 0x19a10
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x10, %ecx
subl %ecx, %eax
movl %eax, 0x38(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x32a6e(%rip), %rax     # 0x68730
movq %rax, 0x210(%rbx)
movq 0x330d0(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1d5b3(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_ctf_banner
void SP_misc_ctf_banner (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_NOT;
	ent->s.modelindex = gi.modelindex ("models/ctf/banner/tris.md2");
	if (ent->spawnflags & 1) // team2
		ent->s.skinnum = 1;

	ent->s.frame = rand() % 16;
	gi.linkentity (ent);

	ent->think = misc_ctf_banner_think;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x118(%rdi)
movl %eax, 0x108(%rdi)
movq 0x328bf(%rip), %r14     # 0x68600
leaq 0x219db(%rip), %rdi     # 0x57723
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
testb $0x1, 0x140(%rbx)
je 0x35d5f
movl $0x1, 0x3c(%rbx)
callq 0x19a10
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x10, %ecx
subl %ecx, %eax
movl %eax, 0x38(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x33063(%rip), %rax     # 0x68de8
movq %rax, 0x210(%rbx)
movq 0x3300d(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1d4f0(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_ctf_small_banner
void SP_misc_ctf_small_banner (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_NOT;
	ent->s.modelindex = gi.modelindex ("models/ctf/banner/small.md2");
	if (ent->spawnflags & 1) // team2
		ent->s.skinnum = 1;

	ent->s.frame = rand() % 16;
	gi.linkentity (ent);

	ent->think = misc_ctf_banner_think;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x118(%rdi)
movl %eax, 0x108(%rdi)
movq 0x32834(%rip), %r14     # 0x68600
leaq 0x2196b(%rip), %rdi     # 0x5773e
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
testb $0x1, 0x140(%rbx)
je 0x35dea
movl $0x1, 0x3c(%rbx)
callq 0x19a10
leal 0xf(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $-0x10, %ecx
subl %ecx, %eax
movl %eax, 0x38(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x32fd8(%rip), %rax     # 0x68de8
movq %rax, 0x210(%rbx)
movq 0x32f82(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1d465(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: misc_deadsoldier_die
void misc_deadsoldier_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	int		n;

	if (self->health > -80)
		return;

	gi.sound (self, CHAN_BODY, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
	for (n= 0; n < 4; n++)
		ThrowGib (self, "models/objects/gibs/sm_meat/tris.md2", damage, GIB_ORGANIC);
	ThrowHead (self, "models/objects/gibs/head2/tris.md2", damage, GIB_ORGANIC);
}

// Assembly:
cmpl $-0x50, 0x254(%rdi)
jle 0x35e45
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
movq 0x327a8(%rip), %rax     # 0x68600
movq 0x20(%rax), %r15
leaq 0x218f7(%rip), %rdi     # 0x5775a
callq *0x48(%rax)
movl $0x4, %ebp
movss 0x1d0b5(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %r14, %rdi
movl $0x4, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
leaq 0x218dd(%rip), %r15     # 0x5776a
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x188e0
decl %ebp
jne 0x35e8d
leaq 0x21698(%rip), %rsi     # 0x5753f
movq %r14, %rdi
movl %ebx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x19660
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_deadsoldier
void SP_misc_deadsoldier (edict_t *ent)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (ent);
		return;
	}

	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	ent->s.modelindex=gi.modelindex ("models/deadbods/dude/tris.md2");

	// Defaults to frame 0
	if (ent->spawnflags & 2)
		ent->s.frame = 1;
	else if (ent->spawnflags & 4)
		ent->s.frame = 2;
	else if (ent->spawnflags & 8)
		ent->s.frame = 3;
	else if (ent->spawnflags & 16)
		ent->s.frame = 4;
	else if (ent->spawnflags & 32)
		ent->s.frame = 5;
	else
		ent->s.frame = 0;

	VectorSet (ent->mins, -16, -16, 0);
	VectorSet (ent->maxs, 16, 16, 16);
	ent->deadflag = DEAD_DEAD;
	ent->takedamage = DAMAGE_YES;
	ent->svflags |= SVF_MONSTER|SVF_DEADMONSTER;
	ent->die = misc_deadsoldier_die;
	ent->monsterinfo.aiflags |= AI_GOOD_GUY;

	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x32ff5(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x35edd
jnp 0x35eec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
movl $0x0, 0x118(%rbx)
movl $0x2, 0x108(%rbx)
movq 0x326f9(%rip), %rax     # 0x68600
leaq 0x21881(%rip), %rdi     # 0x5778f
movq %rax, %r14
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
movl 0x140(%rbx), %eax
testb $0x2, %al
jne 0x35f3a
testb $0x4, %al
jne 0x35f43
testb $0x8, %al
jne 0x35f4c
testb $0x10, %al
jne 0x35f55
testb $0x20, %al
jne 0x35f5e
movl $0x0, 0x38(%rbx)
jmp 0x35f65
movl $0x1, 0x38(%rbx)
jmp 0x35f65
movl $0x2, 0x38(%rbx)
jmp 0x35f65
movl $0x3, 0x38(%rbx)
jmp 0x35f65
movl $0x4, 0x38(%rbx)
jmp 0x35f65
movl $0x5, 0x38(%rbx)
movaps 0x21404(%rip), %xmm0    # 0x57370
movups %xmm0, 0xcc(%rbx)
movsd 0x21405(%rip), %xmm0    # 0x57380
movsd %xmm0, 0xdc(%rbx)
movl $0x2, 0x260(%rbx)
movl $0x1, 0x27c(%rbx)
orb $0x6, 0xc8(%rbx)
movq 0x329a3(%rip), %rax     # 0x68948
movq %rax, 0x238(%rbx)
orb $0x1, 0x3c1(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_viper
void SP_misc_viper (edict_t *ent)
{
	if (!ent->target)
	{
		gi.dprintf ("misc_viper without a target at %s\n", vtos(ent->absmin));
		G_FreeEdict (ent);
		return;
	}

	if (!ent->speed)
		ent->speed = 300;

	ent->movetype = MOVETYPE_PUSH;
	ent->solid = SOLID_NOT;
	ent->s.modelindex = gi.modelindex ("models/ships/viper/tris.md2");
	VectorSet (ent->mins, -16, -16, 0);
	VectorSet (ent->maxs, 16, 16, 32);

	ent->think = func_train_find;
	ent->nextthink = level.time + FRAMETIME;
	ent->use = misc_viper_use;
	ent->svflags |= SVF_NOCLIENT;
	ent->moveinfo.accel = ent->moveinfo.decel = ent->moveinfo.speed = ent->speed;

	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x150(%rdi)
je 0x360ca
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x36011
jp 0x36011
movl $0x43960000, 0x190(%rbx) # imm = 0x43960000
movl $0x2, 0x118(%rbx)
movl $0x0, 0x108(%rbx)
movq 0x325d4(%rip), %r14     # 0x68600
leaq 0x2179d(%rip), %rdi     # 0x577d0
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movaps 0x2132f(%rip), %xmm0    # 0x57370
movups %xmm0, 0xcc(%rbx)
movsd 0x213d0(%rip), %xmm0    # 0x57420
movsd %xmm0, 0xdc(%rbx)
movq 0x32ae1(%rip), %rax     # 0x68b40
movq %rax, 0x210(%rbx)
movq 0x32d33(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1d216(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq 0x32f6f(%rip), %rax     # 0x68ff8
movq %rax, 0x228(%rbx)
orb $0x1, 0xc8(%rbx)
movss 0x190(%rbx), %xmm0
movss %xmm0, 0x378(%rbx)
movss %xmm0, 0x37c(%rbx)
movss %xmm0, 0x374(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
movq 0x3252f(%rip), %rax     # 0x68600
movq 0x8(%rax), %r14
leaq 0xe4(%rbx), %rdi
callq 0x190a0
leaq 0x216c5(%rip), %rdi     # 0x577ad
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19a50
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_bigviper
void SP_misc_bigviper (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -176, -120, -24);
	VectorSet (ent->maxs, 176, 120, 72);
	ent->s.modelindex = gi.modelindex ("models/ships/bigviper/tris.md2");
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x2139f(%rip), %xmm0    # 0x574c0
movups %xmm0, 0xcc(%rdi)
movsd 0x213a0(%rip), %xmm0    # 0x574d0
movsd %xmm0, 0xdc(%rdi)
movq 0x324c1(%rip), %r14     # 0x68600
leaq 0x216a6(%rip), %rdi     # 0x577ec
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: misc_viper_bomb_touch
void misc_viper_bomb_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	G_UseTargets (self, self->activator);

	self->s.origin[2] = self->absmin[2] + 1;
	T_RadiusDamage (self, self, self->dmg, NULL, self->dmg+40, MOD_BOMB);
	BecomeExplosion2 (self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2b0(%rdi), %rsi
callq 0x198e0
movss 0xec(%rbx), %xmm0
addss 0x1cda8(%rip), %xmm0    # 0x52f28
movss %xmm0, 0xc(%rbx)
movl 0x280(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1b, %ecx
callq 0x180c0
movq %rbx, %rdi
popq %rbx
jmp 0x18890