LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
leaq 0x20874(%rip), %rdi     # 0x536e1
movq %rdi, 0x120(%rbx)
movq 0x33785(%rip), %r14     # 0x66600
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movaps 0x205f7(%rip), %xmm0    # 0x53480
movups %xmm0, 0xcc(%rbx)
movsd 0x205f8(%rip), %xmm0    # 0x53490
movsd %xmm0, 0xdc(%rbx)
movq 0x33d01(%rip), %rax     # 0x66ba8
movq %rax, 0x228(%rbx)
movl $0x1, 0x27c(%rbx)
movl $0x10, 0x11c(%rbx)
orb $0x40, 0x44(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
leaq 0x20733(%rip), %rdi     # 0x5360a
callq *0x48(%r14)
leaq 0x207f1(%rip), %rdi     # 0x536d3
callq *0x48(%r14)
movq 0x33703(%rip), %rax     # 0x665f0
movq %rax, 0x210(%rbx)
movq 0x33ea5(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1d4f8(%rip), %xmm0    # 0x50400
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x118(%rdi)
andl $0x0, 0x108(%rdi)
movq 0x336a1(%rip), %r14     # 0x66600
leaq 0x20662(%rip), %rdi     # 0x535c8
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
callq 0x19bf0
pushq $0x10
popq %rcx
cltd
idivl %ecx
movl %edx, 0x38(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x337a4(%rip), %rax     # 0x66730
movq %rax, 0x210(%rbx)
movq 0x33e06(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1c2e9(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x118(%rdi)
andl $0x0, 0x108(%rdi)
movq 0x33601(%rip), %r14     # 0x66600
leaq 0x206fd(%rip), %rdi     # 0x53703
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
testb $0x1, 0x140(%rbx)
je 0x3301d
movl $0x1, 0x3c(%rbx)
callq 0x19bf0
pushq $0x10
popq %rcx
cltd
idivl %ecx
movl %edx, 0x38(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x33dac(%rip), %rax     # 0x66de8
movq %rax, 0x210(%rbx)
movq 0x33d56(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1c239(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x118(%rdi)
andl $0x0, 0x108(%rdi)
movq 0x3357d(%rip), %r14     # 0x66600
leaq 0x20694(%rip), %rdi     # 0x5371e
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
testb $0x1, 0x140(%rbx)
je 0x330a1
movl $0x1, 0x3c(%rbx)
callq 0x19bf0
pushq $0x10
popq %rcx
cltd
idivl %ecx
movl %edx, 0x38(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x33d28(%rip), %rax     # 0x66de8
movq %rax, 0x210(%rbx)
movq 0x33cd2(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1c1b5(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x330f5
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
movq 0x334f8(%rip), %rax     # 0x66600
movq 0x20(%rax), %r15
leaq 0x20627(%rip), %rdi     # 0x5373a
callq *0x48(%rax)
pushq $0x4
popq %rbp
movss 0x1be07(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
leaq 0x20612(%rip), %r15     # 0x5374a
subl $0x1, %ebp
jb 0x3314e
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x18940
jmp 0x33138
leaq 0x203ca(%rip), %rsi     # 0x5351f
movq %r14, %rdi
movl %ebx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x19820
// File: /workspace/github_c_makefile_star2_O2/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 0x33d47(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3318b
jnp 0x3319a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
andl $0x0, 0x118(%rbx)
movl $0x2, 0x108(%rbx)
movq 0x3344e(%rip), %rax     # 0x66600
leaq 0x205b6(%rip), %rdi     # 0x5376f
movq %rax, %r14
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
movl 0x140(%rbx), %eax
testb $0x2, %al
jne 0x331e2
testb $0x4, %al
jne 0x331eb
testb $0x8, %al
jne 0x331f4
testb $0x10, %al
jne 0x331fd
testb $0x20, %al
jne 0x33206
andl $0x0, 0x38(%rbx)
jmp 0x3320d
movl $0x1, 0x38(%rbx)
jmp 0x3320d
movl $0x2, 0x38(%rbx)
jmp 0x3320d
movl $0x3, 0x38(%rbx)
jmp 0x3320d
movl $0x4, 0x38(%rbx)
jmp 0x3320d
movl $0x5, 0x38(%rbx)
movaps 0x2013c(%rip), %xmm0    # 0x53350
movups %xmm0, 0xcc(%rbx)
movsd 0x2013d(%rip), %xmm0    # 0x53360
movsd %xmm0, 0xdc(%rbx)
movl $0x2, 0x260(%rbx)
movl $0x1, 0x27c(%rbx)
orb $0x6, 0xc8(%rbx)
movq 0x336fb(%rip), %rax     # 0x66948
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_O2/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 0x3336f
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x332b9
jp 0x332b9
movl $0x43960000, 0x190(%rbx) # imm = 0x43960000
movl $0x2, 0x118(%rbx)
andl $0x0, 0x108(%rbx)
movq 0x3332f(%rip), %r14     # 0x66600
leaq 0x204d8(%rip), %rdi     # 0x537b0
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movaps 0x2006a(%rip), %xmm0    # 0x53350
movups %xmm0, 0xcc(%rbx)
movsd 0x2010b(%rip), %xmm0    # 0x53400
movsd %xmm0, 0xdc(%rbx)
movq 0x3383c(%rip), %rax     # 0x66b40
movq %rax, 0x210(%rbx)
movq 0x33a8e(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1bf71(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
movq 0x33cca(%rip), %rax     # 0x66ff8
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 0x3328a(%rip), %rax     # 0x66600
movq 0x8(%rax), %r14
leaq 0xe4(%rbx), %rdi
callq 0x19200
leaq 0x20400(%rip), %rdi     # 0x5378d
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_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
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x200dd(%rip), %xmm0    # 0x534a0
movups %xmm0, 0xcc(%rdi)
movsd 0x200de(%rip), %xmm0    # 0x534b0
movsd %xmm0, 0xdc(%rdi)
movq 0x3321f(%rip), %r14     # 0x66600
leaq 0x203e4(%rip), %rdi     # 0x537cc
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_O2/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 0x19ac0
movss 0xec(%rbx), %xmm0
addss 0x1bb06(%rip), %xmm0    # 0x4ef28
movss %xmm0, 0xc(%rbx)
movl 0x280(%rbx), %eax
cvtsi2ss %eax, %xmm0
addl $0x28, %eax
cvtsi2ss %eax, %xmm1
pushq $0x1b
popq %rcx
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x180c0
movq %rbx, %rdi
popq %rbx
jmp 0x188f0
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: misc_viper_bomb_prethink
void misc_viper_bomb_prethink (edict_t *self)
{
	vec3_t	v;
	float	diff;

	self->groundentity = NULL;

	diff = self->timestamp - level.time;
	if (diff < -1.0)
		diff = -1.0;

	VectorScale (self->moveinfo.dir, 1.0 + diff, v);
	v[2] = diff;

	diff = self->s.angles[2];
	vectoangles (v, self->s.angles);
	self->s.angles[2] = diff + 10;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x2b8(%rdi)
movss 0x144(%rdi), %xmm0
movq 0x3392e(%rip), %rax     # 0x66da0
subss 0x4(%rax), %xmm0
movss 0x1e7b5(%rip), %xmm1    # 0x51c34
maxss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
addq $0x38c, %rdi            # imm = 0x38C
movss 0x1ba90(%rip), %xmm0    # 0x4ef28
addss %xmm1, %xmm0
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x18a70
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%r14)
leaq 0x10(%rbx), %rsi
movss 0x18(%rbx), %xmm0
movss %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x19240
movss 0x8(%rsp), %xmm0
addss 0x1ba3a(%rip), %xmm0    # 0x4ef14
movss %xmm0, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: misc_viper_bomb_use
void misc_viper_bomb_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t	*viper;

	self->solid = SOLID_BBOX;
	self->svflags &= ~SVF_NOCLIENT;
	self->s.effects |= EF_ROCKET;
	self->use = NULL;
	self->movetype = MOVETYPE_TOSS;
	self->prethink = misc_viper_bomb_prethink;
	self->touch = misc_viper_bomb_touch;
	self->activator = activator;

	viper = G_Find (NULL, FOFS(classname), "misc_viper");
	VectorScale (viper->moveinfo.dir, viper->moveinfo.speed, self->velocity);

	self->timestamp = level.time;
	VectorCopy (viper->moveinfo.dir, self->moveinfo.dir);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, 0x108(%rdi)
andb $-0x2, 0xc8(%rdi)
orb $0x10, 0x40(%rdi)
andq $0x0, 0x228(%rdi)
movl $0x7, 0x118(%rdi)
movq 0x3325c(%rip), %rax     # 0x66778
movq %rax, 0x208(%rdi)
movq 0x33606(%rip), %rax     # 0x66b30
movq %rax, 0x220(%rdi)
movq %rdx, 0x2b0(%rdi)
leaq 0x202ac(%rip), %rdx     # 0x537eb
xorl %edi, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x195e0
movq %rax, %r14
leaq 0x38c(%rax), %rdi
movss 0x378(%rax), %xmm0
leaq 0x1c0(%rbx), %rsi
callq 0x18a70
movq 0x33830(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
movss %xmm0, 0x144(%rbx)
movss 0x38c(%r14), %xmm0
movss %xmm0, 0x38c(%rbx)
movss 0x390(%r14), %xmm0
movss %xmm0, 0x390(%rbx)
movss 0x394(%r14), %xmm0
movss %xmm0, 0x394(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_viper_bomb
void SP_misc_viper_bomb (edict_t *self)
{
	self->movetype = MOVETYPE_NONE;
	self->solid = SOLID_NOT;
	VectorSet (self->mins, -8, -8, -8);
	VectorSet (self->maxs, 8, 8, 8);

	self->s.modelindex = gi.modelindex ("models/objects/bomb/tris.md2");

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

	self->use = misc_viper_bomb_use;
	self->svflags |= SVF_NOCLIENT;

	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
andl $0x0, 0x108(%rdi)
movaps 0x1fddc(%rip), %xmm0    # 0x533b0
movups %xmm0, 0xcc(%rdi)
movsd 0x1fddd(%rip), %xmm0    # 0x533c0
movsd %xmm0, 0xdc(%rdi)
movq 0x3300e(%rip), %rax     # 0x66600
leaq 0x201fd(%rip), %rdi     # 0x537f6
movq %rax, %r14
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
xorl %eax, %eax
cmpl %eax, 0x280(%rbx)
jne 0x33616
movl $0x3e8, 0x280(%rbx)     # imm = 0x3E8
movq 0x335c3(%rip), %rax     # 0x66be0
movq %rax, 0x228(%rbx)
orb $0x1, 0xc8(%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_misc.c
// Function: SP_misc_strogg_ship
void SP_misc_strogg_ship (edict_t *ent)
{
	if (!ent->target)
	{
		gi.dprintf ("%s without a target at %s\n", ent->classname, 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/strogg1/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_strogg_ship_use;
	ent->svflags |= SVF_NOCLIENT;
	ent->moveinfo.accel = ent->moveinfo.decel = ent->moveinfo.speed = ent->speed;

	gi.linkentity (ent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x150(%rdi)
je 0x3373e
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x3368a
jp 0x3368a
movl $0x43960000, 0x190(%rbx) # imm = 0x43960000
movl $0x2, 0x118(%rbx)
andl $0x0, 0x108(%rbx)
movq 0x32f5e(%rip), %r14     # 0x66600
leaq 0x20185(%rip), %rdi     # 0x5382e
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movaps 0x1fc99(%rip), %xmm0    # 0x53350
movups %xmm0, 0xcc(%rbx)
movsd 0x1fd3a(%rip), %xmm0    # 0x53400
movsd %xmm0, 0xdc(%rbx)
movq 0x3346b(%rip), %rax     # 0x66b40
movq %rax, 0x210(%rbx)
movq 0x336bd(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1bba0(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
movq 0x32df9(%rip), %rax     # 0x664f8
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
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
movq 0x32ebb(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0xe4(%rbx), %rdi
callq 0x19200
leaq 0x200b0(%rip), %rdi     # 0x53813
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_satellite_dish
void SP_misc_satellite_dish (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -64, -64, 0);
	VectorSet (ent->maxs, 64, 64, 128);
	ent->s.modelindex = gi.modelindex ("models/objects/satellite/tris.md2");
	ent->use = misc_satellite_dish_use;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x1fc4c(%rip), %xmm0    # 0x53440
movups %xmm0, 0xcc(%rdi)
movsd 0x1fcbd(%rip), %xmm0    # 0x534c0
movsd %xmm0, 0xdc(%rdi)
movq 0x32dee(%rip), %r14     # 0x66600
leaq 0x20033(%rip), %rdi     # 0x5384c
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movq 0x33261(%rip), %rax     # 0x66a88
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_misc.c
// Function: SP_light_mine1
void SP_light_mine1 (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	ent->s.modelindex = gi.modelindex ("models/objects/minelite/light1/tris.md2");
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movq 0x32da0(%rip), %r14     # 0x66600
leaq 0x20007(%rip), %rdi     # 0x5386e
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_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_light_mine2
void SP_light_mine2 (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	ent->s.modelindex = gi.modelindex ("models/objects/minelite/light2/tris.md2");
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movq 0x32d60(%rip), %r14     # 0x66600
leaq 0x1ffef(%rip), %rdi     # 0x53896
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_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_gib_arm
void SP_misc_gib_arm (edict_t *ent)
{
	gi.setmodel (ent, "models/objects/gibs/arm/tris.md2");
	ent->solid = SOLID_NOT;
	ent->s.effects |= EF_GIB;
	ent->takedamage = DAMAGE_YES;
	ent->die = gib_die;
	ent->movetype = MOVETYPE_TOSS;
	ent->svflags |= SVF_MONSTER;
	ent->deadflag = DEAD_DEAD;
	ent->avelocity[0] = random()*200;
	ent->avelocity[1] = random()*200;
	ent->avelocity[2] = random()*200;
	ent->think = G_FreeEdict;
	ent->nextthink = level.time + 30;
	gi.linkentity (ent);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x32d31(%rip), %r14     # 0x66600
leaq 0x1ffe8(%rip), %rsi     # 0x538be
callq *0x58(%r14)
andl $0x0, 0x108(%rbx)
orb $0x2, 0x40(%rbx)
movl $0x1, 0x27c(%rbx)
movq 0x33342(%rip), %rax     # 0x66c38
movq %rax, 0x238(%rbx)
movl $0x7, 0x118(%rbx)
orb $0x4, 0xc8(%rbx)
movl $0x2, 0x260(%rbx)
callq 0x19bf0
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1b958(%rip), %xmm0    # 0x4f288
mulss 0x1b96c(%rip), %xmm0    # 0x4f2a4
movss %xmm0, 0x1cc(%rbx)
callq 0x19bf0
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1b935(%rip), %xmm0    # 0x4f288
mulss 0x1b949(%rip), %xmm0    # 0x4f2a4
movss %xmm0, 0x1d0(%rbx)
callq 0x19bf0
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1b912(%rip), %xmm0    # 0x4f288
mulss 0x1b926(%rip), %xmm0    # 0x4f2a4
movss %xmm0, 0x1d4(%rbx)
movq 0x32aa3(%rip), %rax     # 0x66430
movq %rax, 0x210(%rbx)
movq 0x33405(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1b8ec(%rip), %xmm0    # 0x4f294
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_target_character
void SP_target_character (edict_t *self)
{
	self->movetype = MOVETYPE_PUSH;
	gi.setmodel (self, self->model);
	self->solid = SOLID_BSP;
	self->s.frame = 12;
	gi.linkentity (self);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, 0x118(%rdi)
movq 0x32a2a(%rip), %r14     # 0x66600
movq 0x120(%rdi), %rsi
callq *0x58(%r14)
movl $0x3, 0x108(%rbx)
movl $0xc, 0x38(%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_misc.c
// Function: target_string_use
void target_string_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t *e;
	size_t	n;
	size_t	len;
	char	c;

	len = strlen(self->message);
	for (e = self->teammaster; e; e = e->teamchain)
	{
		if (!e->count)
			continue;
		n = (size_t)e->count - 1;
		if (n > len)
		{
			e->s.frame = 12;
			continue;
		}

		c = self->message[n];
		if (c >= '0' && c <= '9')
			e->s.frame = c - '0';
		else if (c == '-')
			e->s.frame = 10;
		else if (c == ':')
			e->s.frame = 11;
		else
			e->s.frame = 12;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x130(%rdi), %r14
movq %r14, %rdi
callq 0x186c0
addq $0x2d0, %rbx            # imm = 0x2D0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x33c7f
movslq 0x290(%rbx), %rcx
testq %rcx, %rcx
je 0x33c76
decq %rcx
cmpq %rax, %rcx
jbe 0x33c47
movl $0xc, 0x38(%rbx)
jmp 0x33c76
movzbl (%r14,%rcx), %ecx
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x33c5c
addl $-0x30, %ecx
movl %ecx, 0x38(%rbx)
jmp 0x33c76
cmpl $0x3a, %ecx
je 0x33c6f
cmpl $0x2d, %ecx
jne 0x33c3e
movl $0xa, 0x38(%rbx)
jmp 0x33c76
movl $0xb, 0x38(%rbx)
addq $0x2c8, %rbx            # imm = 0x2C8
jmp 0x33c22
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_clock_format_countdown
static void func_clock_format_countdown (edict_t *self)
{
	if (self->style == 0)
	{
		Com_sprintf (self->message, CLOCK_MESSAGE_SIZE, "%2i", self->health);
		return;
	}

	if (self->style == 1)
	{
		Com_sprintf(self->message, CLOCK_MESSAGE_SIZE, "%2i:%2i", self->health / 60, self->health % 60);
		if (self->message[3] == ' ')
			self->message[3] = '0';
		return;
	}

	if (self->style == 2)
	{
		Com_sprintf(self->message, CLOCK_MESSAGE_SIZE, "%2i:%2i:%2i", self->health / 3600, (self->health - (self->health / 3600) * 3600) / 60, self->health % 60);
		if (self->message[3] == ' ')
			self->message[3] = '0';
		if (self->message[6] == ' ')
			self->message[6] = '0';
		return;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x32c(%rdi), %eax
cmpl $0x2, %eax
je 0x33ec1
cmpl $0x1, %eax
je 0x33e85
testl %eax, %eax
jne 0x33f2f
movq 0x130(%rbx), %rdi
movl 0x254(%rbx), %ecx
leaq 0x1fab0(%rip), %rdx     # 0x5392a
pushq $0x10
popq %rsi
xorl %eax, %eax
popq %rbx
jmp 0x18f30
movq 0x130(%rbx), %rdi
movl 0x254(%rbx), %eax
pushq $0x3c
popq %rcx
cltd
idivl %ecx
movl %edx, %r8d
leaq 0x1fa84(%rip), %rdx     # 0x53926
pushq $0x10
popq %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x18f30
movq 0x130(%rbx), %rax
cmpb $0x20, 0x3(%rax)
jne 0x33f2f
movb $0x30, 0x3(%rax)
jmp 0x33f2f
movq 0x130(%rbx), %rdi
movl 0x254(%rbx), %ecx
movl $0xe10, %esi            # imm = 0xE10
movl %ecx, %eax
cltd
idivl %esi
movl %eax, %r8d
imull $0xfffff1f0, %eax, %eax # imm = 0xFFFFF1F0
addl %ecx, %eax
pushq $0x3c
popq %rsi
cltd
idivl %esi
movl %eax, %r9d
movl %ecx, %eax
cltd
idivl %esi
movl %edx, %eax
leaq 0x1fa28(%rip), %rdx     # 0x53922
pushq $0x10
popq %rsi
movl %r8d, %ecx
movl %r9d, %r8d
movl %eax, %r9d
xorl %eax, %eax
callq 0x18f30
movq 0x130(%rbx), %rax
cmpb $0x20, 0x3(%rax)
jne 0x33f25
movb $0x30, 0x3(%rax)
movq 0x130(%rbx), %rax
cmpb $0x20, 0x6(%rax)
jne 0x33f2f
movb $0x30, 0x6(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_clock_reset
static void func_clock_reset (edict_t *self)
{
	self->activator = NULL;
	if (self->spawnflags & 1)
	{
		self->health = 0;
		self->wait = self->count;
	}
	else if (self->spawnflags & 2)
	{
		self->health = self->count;
		self->wait = 0;
	}
}

// Assembly:
andq $0x0, 0x2b0(%rdi)
movl 0x140(%rdi), %eax
testb $0x1, %al
jne 0x33f58
testb $0x2, %al
je 0x33f6f
movl 0x290(%rdi), %eax
movl %eax, 0x254(%rdi)
xorps %xmm0, %xmm0
jmp 0x33f67
andl $0x0, 0x254(%rdi)
cvtsi2ssl 0x290(%rdi), %xmm0
movss %xmm0, 0x2f8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_clock_use
void func_clock_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (!(self->spawnflags & 8))
		self->use = NULL;
	if (self->activator)
		return;
	self->activator = activator;
	self->think (self);
}

// Assembly:
testb $0x8, 0x140(%rdi)
jne 0x33f81
andq $0x0, 0x228(%rdi)
cmpq $0x0, 0x2b0(%rdi)
je 0x33f8c
retq
movq %rdx, 0x2b0(%rdi)
jmpq *0x210(%rdi)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_clock
void SP_func_clock (edict_t *self)
{
	if (!self->target)
	{
		gi.dprintf("%s with no target at %s\n", self->classname, vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

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

	if ((self->spawnflags & 1) && (!self->count))
		self->count = 60*60;;

	func_clock_reset (self);

	self->message = gi.TagMalloc (CLOCK_MESSAGE_SIZE, TAG_LEVEL);

	self->think = func_clock_think;

	if (self->spawnflags & 4)
		self->use = func_clock_use;
	else
		self->nextthink = level.time + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x150(%rdi)
je 0x34036
movl 0x140(%rbx), %eax
testb $0x2, %al
je 0x33fc6
cmpl $0x0, 0x290(%rbx)
je 0x3406e
testb $0x1, %al
je 0x33fdd
cmpl $0x0, 0x290(%rbx)
jne 0x33fdd
movl $0xe10, 0x290(%rbx)     # imm = 0xE10
movq %rbx, %rdi
callq 0x33f31
movq 0x32614(%rip), %rax     # 0x66600
pushq $0x10
popq %rdi
movl $0x2fe, %esi            # imm = 0x2FE
callq *0x108(%rax)
movq %rax, 0x130(%rbx)
movq 0x32408(%rip), %rax     # 0x66410
movq %rax, 0x210(%rbx)
testb $0x4, 0x140(%rbx)
jne 0x3405a
movq 0x32d81(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1aefc(%rip), %xmm0    # 0x4ef28
movss %xmm0, 0x200(%rbx)
jmp 0x34068
movq 0x325c3(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x1f8d6(%rip), %rdi     # 0x5392e
jmp 0x34090
movq 0x32bcf(%rip), %rax     # 0x66c30
movq %rax, 0x228(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x3258b(%rip), %rax     # 0x66600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x1f8b7(%rip), %rdi     # 0x53947
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r15
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: teleporter_touch
void teleporter_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	edict_t		*dest;
	int			i;

	if (!other->client)
		return;
	dest = G_Find (NULL, FOFS(targetname), self->target);
	if (!dest)
	{
		gi.dprintf ("Couldn't find destination\n");
		return;
	}

	// unlink to make sure it can't possibly interfere with KillBox
	gi.unlinkentity (other);

	VectorCopy (dest->s.origin, other->s.origin);
	VectorCopy (dest->s.origin, other->s.old_origin);
	other->s.origin[2] += 10;

	// clear the velocity and hold them in place briefly
	VectorClear (other->velocity);
	other->client->ps.pmove.pm_time = 160>>3;		// hold time
	other->client->ps.pmove.pm_flags |= PMF_TIME_TELEPORT;

	// draw the teleport splash at source and on the player
	self->owner->s.event = EV_PLAYER_TELEPORT;
	other->s.event = EV_PLAYER_TELEPORT;

	// set angles
	for (i=0 ; i<3 ; i++)
	{
		other->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(dest->s.angles[i] - other->client->resp.cmd_angles[i]);
	}

	VectorClear (other->s.angles);
	VectorClear (other->client->ps.viewangles);
	VectorClear (other->client->v_angle);

	// kill anything at the destination
	KillBox (other);

	gi.linkentity (other);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x58(%rsi)
je 0x341eb
movq %rsi, %rbx
movq %rdi, %r15
movq 0x150(%rdi), %rdx
xorl %edi, %edi
movl $0x158, %esi            # imm = 0x158
callq 0x195e0
testq %rax, %rax
je 0x341f7
movq %rax, %r14
movq 0x32519(%rip), %rax     # 0x66600
movq %rbx, %rdi
movq %rax, %r12
callq *0x98(%rax)
movss 0x4(%r14), %xmm0
movss %xmm0, 0x4(%rbx)
movss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%rbx)
movss 0xc(%r14), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x4(%r14), %xmm1
movss %xmm1, 0x1c(%rbx)
movss 0x8(%r14), %xmm1
movss %xmm1, 0x20(%rbx)
movss 0xc(%r14), %xmm1
movss %xmm1, 0x24(%rbx)
addss 0x1add7(%rip), %xmm0    # 0x4ef14
movss %xmm0, 0xc(%rbx)
andl $0x0, 0x1c8(%rbx)
andq $0x0, 0x1c0(%rbx)
movq 0x58(%rbx), %rax
movb $0x14, 0x11(%rax)
orb $0x20, 0x10(%rax)
movq 0x110(%r15), %rcx
pushq $0x6
popq %rdx
movl %edx, 0x50(%rcx)
movl %edx, 0x50(%rbx)
xorl %ecx, %ecx
movss 0x1bbe9(%rip), %xmm0    # 0x4fd60
movss 0x1bbe5(%rip), %xmm1    # 0x4fd64
cmpq $0x3, %rcx
je 0x341ab
movss 0x10(%r14,%rcx,4), %xmm2
subss 0xdf8(%rax,%rcx,4), %xmm2
mulss %xmm0, %xmm2
divss %xmm1, %xmm2
cvttss2si %xmm2, %edx
movw %dx, 0x14(%rax,%rcx,2)
incq %rcx
jmp 0x3417f
andl $0x0, 0x18(%rbx)
andq $0x0, 0x10(%rbx)
andl $0x0, 0x24(%rax)
andq $0x0, 0x1c(%rax)
andl $0x0, 0xec4(%rax)
andq $0x0, 0xebc(%rax)
movq %rbx, %rdi
callq 0x18b30
movq %rbx, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x90(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x32402(%rip), %rax     # 0x66600
movq 0x8(%rax), %rcx
leaq 0x1f756(%rip), %rdi     # 0x5395f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_teleporter
void SP_misc_teleporter (edict_t *ent)
{
	edict_t		*trig;

	if (!ent->target)
	{
		gi.dprintf ("teleporter without a target.\n");
		G_FreeEdict (ent);
		return;
	}

	gi.setmodel (ent, "models/objects/dmspot/tris.md2");
	ent->s.skinnum = 1;
	ent->s.effects = EF_TELEPORTER;
	ent->s.sound = gi.soundindex ("world/amb10.wav");
	ent->solid = SOLID_BBOX;

	VectorSet (ent->mins, -32, -32, -24);
	VectorSet (ent->maxs, 32, 32, -16);
	gi.linkentity (ent);

	trig = G_Spawn ();
	trig->touch = teleporter_touch;
	trig->solid = SOLID_TRIGGER;
	trig->target = ent->target;
	trig->owner = ent;
	VectorCopy (ent->s.origin, trig->s.origin);
	VectorSet (trig->mins, -8, -8, 8);
	VectorSet (trig->maxs, 8, 8, 24);
	gi.linkentity (trig);
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x150(%rdi)
je 0x34311
movq 0x323cc(%rip), %r14     # 0x66600
leaq 0x1f75d(%rip), %rsi     # 0x53998
movq %rbx, %rdi
callq *0x58(%r14)
movabsq $0x2000000000001, %rax  # imm = 0x2000000000001
movq %rax, 0x3c(%rbx)
leaq 0x1f760(%rip), %rdi     # 0x539b7
callq *0x48(%r14)
movl %eax, 0x4c(%rbx)
movl $0x2, 0x108(%rbx)
movaps 0x1f261(%rip), %xmm0    # 0x534d0
movups %xmm0, 0xcc(%rbx)
movsd 0x1f262(%rip), %xmm0    # 0x534e0
movsd %xmm0, 0xdc(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
callq 0x198d0
movq 0x3274c(%rip), %rcx     # 0x669e8
movq %rcx, 0x220(%rax)
movl $0x1, 0x108(%rax)
movq 0x150(%rbx), %rcx
movq %rcx, 0x150(%rax)
movq %rbx, 0x110(%rax)
movss 0x4(%rbx), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%rax)
movss 0xc(%rbx), %xmm0
movss %xmm0, 0xc(%rax)
movaps 0x1f209(%rip), %xmm0    # 0x534f0
movups %xmm0, 0xcc(%rax)
movsd 0x1f20a(%rip), %xmm0    # 0x53500
movsd %xmm0, 0xdc(%rax)
movq %rax, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
movq 0x322e8(%rip), %rcx     # 0x66600
leaq 0x1f65b(%rip), %rdi     # 0x5397a
xorl %eax, %eax
callq *0x8(%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_teleporter_dest
void SP_misc_teleporter_dest (edict_t *ent)
{
	if (!(ent->spawnflags & 1))
		gi.setmodel (ent, "models/objects/dmspot/tris.md2");

	ent->s.skinnum = 0;

	if (!(ent->spawnflags & 2))
	{
		ent->solid = SOLID_BBOX;
	//	ent->s.effects |= EF_FLIES;
	}
	VectorSet (ent->mins, -32, -32, -24);
	VectorSet (ent->maxs, 32, 32, -16);
	gi.linkentity (ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %eax
testb $0x1, %al
jne 0x3435b
movq 0x322b8(%rip), %rax     # 0x66600
leaq 0x1f649(%rip), %rsi     # 0x53998
movq %rbx, %rdi
callq *0x58(%rax)
movl 0x140(%rbx), %eax
andl $0x0, 0x3c(%rbx)
testb $0x2, %al
jne 0x3436d
movl $0x2, 0x108(%rbx)
movaps 0x1f15c(%rip), %xmm0    # 0x534d0
movups %xmm0, 0xcc(%rbx)
movsd 0x1f15d(%rip), %xmm0    # 0x534e0
movsd %xmm0, 0xdc(%rbx)
movq 0x3226e(%rip), %rax     # 0x66600
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: SV_CheckVelocity
void SV_CheckVelocity (edict_t *ent)
{
	int		i;

//
// bound velocity
//
	for (i=0 ; i<3 ; i++)
	{
		if (ent->velocity[i] > sv_maxvelocity->value)
			ent->velocity[i] = sv_maxvelocity->value;
		else if (ent->velocity[i] < -sv_maxvelocity->value)
			ent->velocity[i] = -sv_maxvelocity->value;
	}
}

// Assembly:
movq 0x32573(%rip), %rax     # 0x66970
movq (%rax), %rax
xorl %ecx, %ecx
movaps 0x1d8a7(%rip), %xmm0    # 0x51cb0
cmpq $0x3, %rcx
je 0x34438
movss 0x1c0(%rdi,%rcx,4), %xmm2
movss 0x20(%rax), %xmm1
ucomiss %xmm1, %xmm2
ja 0x3442a
xorps %xmm0, %xmm1
ucomiss %xmm2, %xmm1
jbe 0x34433
movss %xmm1, 0x1c0(%rdi,%rcx,4)
incq %rcx
jmp 0x34409
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: SV_RunThink
qboolean SV_RunThink (edict_t *ent)
{
	float	thinktime;

	thinktime = ent->nextthink;
	if (thinktime <= 0)
		return true;
	if (thinktime > level.time+0.001)
		return true;
	
	ent->nextthink = 0;
	if (!ent->think) {
		gi.error("NULL ent->think");
		return false;
	}
	ent->think (ent);

	return false;
}

// Assembly:
pushq %rbx
movss 0x200(%rdi), %xmm0
pushq $0x1
popq %rbx
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x34499
cvtss2sd %xmm0, %xmm0
movq 0x32948(%rip), %rax     # 0x66da0
cvtss2sd 0x4(%rax), %xmm1
addsd 0x1f563(%rip), %xmm1    # 0x539c8
ucomisd %xmm1, %xmm0
ja 0x34499
andl $0x0, 0x200(%rdi)
movq 0x210(%rdi), %rax
testq %rax, %rax
je 0x34484
callq *%rax
xorl %ebx, %ebx
jmp 0x34499
movq 0x32175(%rip), %rcx     # 0x66600
leaq 0x1f596(%rip), %rdi     # 0x53a28
xorl %ebx, %ebx
xorl %eax, %eax
callq *0x38(%rcx)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: SV_Impact
void SV_Impact (edict_t *e1, trace_t *trace)
{
	edict_t		*e2;
//	cplane_t	backplane;

	e2 = trace->ent;

	if (e1->touch && e1->solid != SOLID_NOT)
		e1->touch (e1, e2, &trace->plane, trace->surface);
	
	if (e2->touch && e2->solid != SOLID_NOT)
		e2->touch (e2, e1, NULL, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rsi), %r14
movq 0x220(%rdi), %rax
testq %rax, %rax
je 0x344d0
cmpl $0x0, 0x108(%rbx)
je 0x344d0
movq %rsi, %rdx
movq 0x30(%rsi), %rcx
addq $0x18, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
movq 0x220(%r14), %rax
testq %rax, %rax
je 0x344f9
cmpl $0x0, 0x108(%r14)
je 0x344f9
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: ClipVelocity
int ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
{
	float	backoff;
	float	change;
	int		i, blocked;
	
	blocked = 0;
	if (normal[2] > 0)
		blocked |= 1;		// floor
	if (!normal[2])
		blocked |= 2;		// step
	
	backoff = DotProduct (in, normal) * overbounce;

	for (i=0 ; i<3 ; i++)
	{
		change = normal[i]*backoff;
		out[i] = in[i] - change;
		if (out[i] > -STOP_EPSILON && out[i] < STOP_EPSILON)
			out[i] = 0;
	}

	return blocked;
}

// Assembly:
movss 0x8(%rsi), %xmm1
movss (%rdi), %xmm3
movss 0x4(%rdi), %xmm2
mulss 0x4(%rsi), %xmm2
mulss (%rsi), %xmm3
addss %xmm2, %xmm3
movss 0x8(%rdi), %xmm2
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
mulss %xmm0, %xmm2
xorl %eax, %eax
movaps 0x1aa0a(%rip), %xmm0    # 0x4ef40
movsd 0x1b70a(%rip), %xmm3    # 0x4fc48
cmpq $0x3, %rax
je 0x34576
movss (%rsi,%rax,4), %xmm5
mulss %xmm2, %xmm5
movss (%rdi,%rax,4), %xmm4
subss %xmm5, %xmm4
movaps %xmm4, %xmm5
andps %xmm0, %xmm5
cvtss2sd %xmm5, %xmm5
ucomisd %xmm5, %xmm3
xorps %xmm5, %xmm5
ja 0x3456c
movaps %xmm4, %xmm5
movss %xmm5, (%rdx,%rax,4)
incq %rax
jmp 0x3453e
xorps %xmm0, %xmm0
xorl %ecx, %ecx
ucomiss %xmm0, %xmm1
seta %cl
leal 0x2(%rcx), %eax
ucomiss %xmm0, %xmm1
cmovnel %ecx, %eax
cmovpl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: SV_PushEntity
trace_t SV_PushEntity (edict_t *ent, vec3_t push)
{
	trace_t	trace;
	vec3_t	start;
	vec3_t	end;
	int		mask;

	VectorCopy (ent->s.origin, start);
	VectorAdd (start, push, end);

retry:
	if (ent->clipmask)
		mask = ent->clipmask;
	else
		mask = MASK_SOLID;

	trace = gi.trace (start, ent->mins, ent->maxs, end, ent, mask);
	
	VectorCopy (trace.endpos, ent->s.origin);
	gi.linkentity (ent);

	if (trace.fraction != 1.0)
	{
		SV_Impact (ent, &trace);

		// if the pushed entity went away and the pusher is still there
		if (!trace.ent->inuse && ent->inuse)
		{
			// move the pusher back and try again
			VectorCopy (start, ent->s.origin);
			gi.linkentity (ent);
			goto retry;
		}
	}

	if (ent->inuse)
		G_TouchTriggers (ent);

	return trace;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x4(%rsi), %xmm0
leaq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movss 0xc(%rsi), %xmm1
movss %xmm1, 0x8(%rax)
movsd (%rdx), %xmm2
addps %xmm0, %xmm2
leaq 0x20(%rsp), %rax
movlps %xmm2, (%rax)
addss 0x8(%rdx), %xmm1
movss %xmm1, 0x8(%rax)
leaq 0xcc(%rsi), %r13
leaq 0xd8(%rsi), %rbp
movq 0x31b94(%rip), %r12     # 0x66600
leaq 0x30(%rsp), %r15
movl 0x10c(%r14), %eax
testl %eax, %eax
pushq $0x3
popq %rcx
cmovel %ecx, %eax
movl %eax, (%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
leaq 0x20(%rsp), %r8
movq %r14, %r9
callq *0x60(%r12)
pushq $0x9
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movsd 0xc(%rbx), %xmm0
movsd %xmm0, 0x4(%r14)
movss 0x14(%rbx), %xmm0
movss %xmm0, 0xc(%r14)
movq %r14, %rdi
callq *0x90(%r12)
movss 0x8(%rbx), %xmm0
ucomiss 0x1a451(%rip), %xmm0    # 0x4ef28
jne 0x34adb
jnp 0x34b20
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18b20
movq 0x40(%rbx), %rax
cmpl $0x0, 0x60(%rax)
movl 0x60(%r14), %eax
jne 0x34b24
testl %eax, %eax
je 0x34b30
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x4(%r14)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0xc(%r14)
movq %r14, %rdi
callq *0x90(%r12)
jmp 0x34a71
movl 0x60(%r14), %eax
testl %eax, %eax
je 0x34b30
movq %r14, %rdi
callq 0x19380
movq %rbx, %rax
addq $0x78, %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_phys.c
// Function: SV_Physics_Noclip
void SV_Physics_Noclip (edict_t *ent)
{
// regular thinking
	if (!SV_RunThink (ent))
		return;
	
	VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles);
	VectorMA (ent->s.origin, FRAMETIME, ent->velocity, ent->s.origin);

	gi.linkentity (ent);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x18660
testl %eax, %eax
je 0x35314
leaq 0x10(%rbx), %rdi
leaq 0x1cc(%rbx), %rsi
movss 0x19fb0(%rip), %xmm0    # 0x4f290
movq %rdi, %rdx
callq 0x19940
leaq 0x4(%rbx), %rdi
leaq 0x1c0(%rbx), %rsi
movss 0x19f95(%rip), %xmm0    # 0x4f290
movq %rdi, %rdx
callq 0x19940
movq 0x312f6(%rip), %rax     # 0x66600
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: SV_AddRotationalFriction
void SV_AddRotationalFriction (edict_t *ent)
{
	int		n;
	float	adjustment;

	VectorMA (ent->s.angles, FRAMETIME, ent->avelocity, ent->s.angles);
	adjustment = FRAMETIME * sv_stopspeed * sv_friction;
	for (n = 0; n < 3; n++)
	{
		if (ent->avelocity[n] > 0)
		{
			ent->avelocity[n] -= adjustment;
			if (ent->avelocity[n] < 0)
				ent->avelocity[n] = 0;
		}
		else
		{
			ent->avelocity[n] += adjustment;
			if (ent->avelocity[n] > 0)
				ent->avelocity[n] = 0;
		}
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
addq $0x1cc, %rbx            # imm = 0x1CC
movss 0x19cfc(%rip), %xmm0    # 0x4f290
movq %rbx, %rsi
movq %rdi, %rdx
callq 0x19940
xorl %eax, %eax
xorps %xmm0, %xmm0
movss 0x1e44c(%rip), %xmm1    # 0x539f8
movss 0x1dc60(%rip), %xmm2    # 0x53214
cmpq $0x3, %rax
je 0x355eb
movss (%rbx,%rax,4), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x355d4
addss %xmm1, %xmm3
movss %xmm3, (%rbx,%rax,4)
ucomiss %xmm3, %xmm0
ja 0x355e2
jmp 0x355e6
addss %xmm2, %xmm3
movss %xmm3, (%rbx,%rax,4)
ucomiss %xmm0, %xmm3
jbe 0x355e6
andl $0x0, (%rbx,%rax,4)
incq %rax
jmp 0x355b4
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: G_RunEntity
void G_RunEntity (edict_t *ent)
{
	if (ent->prethink)
		ent->prethink (ent);

	switch ( (int)ent->movetype)
	{
	case MOVETYPE_PUSH:
	case MOVETYPE_STOP:
		SV_Physics_Pusher (ent);
		break;
	case MOVETYPE_NONE:
		SV_Physics_None (ent);
		break;
	case MOVETYPE_NOCLIP:
		SV_Physics_Noclip (ent);
		break;
	case MOVETYPE_STEP:
		SV_Physics_Step (ent);
		break;
	case MOVETYPE_TOSS:
	case MOVETYPE_BOUNCE:
	case MOVETYPE_FLY:
	case MOVETYPE_FLYMISSILE:
 	case MOVETYPE_REFLECT: // SKWiD MOD
		SV_Physics_Toss (ent);
		break;
	default:
		gi.error ("SV_Physics: bad movetype %i", (int)ent->movetype);			
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x208(%rdi), %rax
testq %rax, %rax
je 0x358b1
movq %rbx, %rdi
callq *%rax
movl 0x118(%rbx), %esi
cmpq $0xa, %rsi
ja 0x358df
leaq 0x1e138(%rip), %rax     # 0x539fc
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
popq %rbx
jmp 0x19330
movq %rbx, %rdi
popq %rbx
jmp 0x184f0
movq 0x30d1a(%rip), %rax     # 0x66600
movq 0x38(%rax), %rcx
leaq 0x1e1b9(%rip), %rdi     # 0x53aaa
xorl %eax, %eax
popq %rbx
jmpq *%rcx
movq %rbx, %rdi
popq %rbx
jmp 0x18660
movq %rbx, %rdi
popq %rbx
jmp 0x19bc0
movq %rbx, %rdi
popq %rbx
jmp 0x18ae0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: SortMaplist
void SortMaplist(MapInfo arr[], int min, int max) {
	if (min < max) {
		int ndx = MapDivide(arr, min, max);
		SortMaplist(arr, min, ndx - 1);
		SortMaplist(arr, ndx + 1, max);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl %ebx, %ebp
jge 0x36529
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x19540
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x19710
incl %r15d
movl %r15d, %ebp
jmp 0x36500
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: MapDivide
int MapDivide(MapInfo arr[], int min, int max) {
	MapInfo tmp = arr[max];
	int nndx = (min - 1);

	for (int x = min; x <= max - 1; x++) {
		if (strcmp(arr[x].mapname, tmp.mapname) < 0) {
			nndx++;
			flip(&arr[nndx], &arr[x]);
		}
	}
	flip(&arr[nndx + 1], &arr[max]);
	return(nndx + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movslq %edx, %r12
imulq $0x18, %r12, %rax
leaq (%rdi,%rax), %rcx
movq %rcx, 0x20(%rsp)
movq (%rdi,%rax), %r14
movslq %esi, %r13
decl %ebp
imulq $0x18, %r13, %r15
addq %rdi, %r15
cmpq %r12, %r13
jge 0x365c1
movq (%r15), %rdi
movq %r14, %rsi
callq 0x18bc0
testl %eax, %eax
jns 0x365b8
incl %ebp
movslq %ebp, %rax
imulq $0x18, %rax, %rax
movq 0x10(%rbx,%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rbx,%rax), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx,%rax)
movups (%r15), %xmm0
movups %xmm0, (%rbx,%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r15)
movaps (%rsp), %xmm0
movups %xmm0, (%r15)
incq %r13
addq $0x18, %r15
jmp 0x36567
incl %ebp
movslq %ebp, %rax
imulq $0x18, %rax, %rcx
movq 0x10(%rbx,%rcx), %rdx
movq %rdx, 0x10(%rsp)
movups (%rbx,%rcx), %xmm0
movaps %xmm0, (%rsp)
movq 0x20(%rsp), %rsi
movq 0x10(%rsi), %rdx
movq %rdx, 0x10(%rbx,%rcx)
movups (%rsi), %xmm0
movups %xmm0, (%rbx,%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rsi)
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x28, %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_save.c
// Function: WriteField1
void WriteField1(FILE* f, field_t* field, byte* base)
{
	void* p;
	size_t		len;
	int			index;

	if (field->flags & FFL_SPAWNTEMP)
		return;

	p = (void*)(base + field->ofs);
	switch (field->type)
	{
	case F_INT:
	case F_FLOAT:
	case F_ANGLEHACK:
	case F_VECTOR:
	case F_IGNORE:
		break;

	case F_LSTRING:
	case F_GSTRING:
		if (*(char**)p)
			len = strlen(*(char**)p) + 1;
		else
			len = 0;
		*(size_t*)p = len;
		break;
	case F_EDICT:
		if (*(edict_t**)p == NULL)
			index = -1;
		else
			index = *(edict_t**)p - g_edicts;
		*(int*)p = index;
		break;
	case F_CLIENT:
		if (*(gclient_t**)p == NULL)
			index = -1;
		else
			index = *(gclient_t**)p - game.clients;
		*(int*)p = index;
		break;
	case F_ITEM:
		if (*(edict_t**)p == NULL)
			index = -1;
		else
			index = *(gitem_t**)p - itemlist;
		*(int*)p = index;
		break;

		//relative to code segment
	case F_FUNCTION:
		if (*(byte**)p == NULL)
			index = 0;
		else
			index = *(byte**)p - ((byte*)InitGame);
		*(int*)p = index;
		break;

		//relative to data segment
	case F_MMOVE:
		if (*(byte**)p == NULL)
			index = 0;
		else
			index = *(byte**)p - (byte*)&mmove_reloc;
		*(int*)p = index;
		break;

	default:
		gi.error("WriteEdict: unknown field type");
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x10(%rsi)
jne 0x36735
movl 0xc(%rsi), %eax
cmpq $0xb, %rax
ja 0x36712
movq %rdx, %rbx
movslq 0x8(%rsi), %r14
leaq 0x1d45e(%rip), %rcx     # 0x53ac8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3672f
callq 0x186c0
incq %rax
jmp 0x36731
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x366ed
movq 0x2febb(%rip), %rcx     # 0x66558
subq (%rcx), %rax
movl $0x4a8, %ecx            # imm = 0x4A8
jmp 0x366e6
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x366ed
subq 0x30789(%rip), %rax     # 0x66e40
movl $0x88, %ecx
jmp 0x366e6
movq (%rbx,%r14), %rax
movl 0x302c0(%rip), %ecx     # 0x66988
jmp 0x36700
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x366ed
movq 0x30666(%rip), %rcx     # 0x66d40
subq 0x408(%rcx), %rax
movl $0x9140, %ecx           # imm = 0x9140
cqto
idivq %rcx
jmp 0x366f0
pushq $-0x1
popq %rax
movl %eax, (%rbx,%r14)
jmp 0x36735
movq (%rbx,%r14), %rax
movl 0x2ff88(%rip), %ecx     # 0x66688
movl %eax, %edx
subl %ecx, %edx
xorl %ecx, %ecx
testq %rax, %rax
cmovnel %edx, %ecx
movl %ecx, (%rbx,%r14)
jmp 0x36735
movq 0x2fee7(%rip), %rax     # 0x66600
movq 0x38(%rax), %rcx
leaq 0x1d948(%rip), %rdi     # 0x5406c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
xorl %eax, %eax
movq %rax, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq