LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x2b8(%rdi)
movss 0x144(%rdi), %xmm0
movq 0x32bc8(%rip), %rax     # 0x68da0
subss 0x4(%rax), %xmm0
movss 0x1fa6f(%rip), %xmm1    # 0x55c54
maxss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
addq $0x38c, %rdi            # imm = 0x38C
movss 0x1cd2a(%rip), %xmm0    # 0x52f28
addss %xmm1, %xmm0
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x189d0
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%r14)
leaq 0x10(%rbx), %rsi
movss 0x18(%rbx), %xmm0
movss %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x190d0
movss 0x8(%rsp), %xmm0
addss 0x1ccd4(%rip), %xmm0    # 0x52f14
movss %xmm0, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, 0x228(%rdi)
movl $0x7, 0x118(%rdi)
movq 0x324f3(%rip), %rax     # 0x68778
movq %rax, 0x208(%rdi)
movq 0x3289d(%rip), %rax     # 0x68b30
movq %rax, 0x220(%rdi)
movq %rdx, 0x2b0(%rdi)
leaq 0x21563(%rip), %rdx     # 0x5780b
xorl %edi, %edi
movl $0x138, %esi            # imm = 0x138
callq 0x19430
movq %rax, %r14
leaq 0x38c(%rax), %rdi
movss 0x378(%rax), %xmm0
leaq 0x1c0(%rbx), %rsi
callq 0x189d0
movq 0x32ac7(%rip), %rax     # 0x68da0
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_O3/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x118(%rdi)
movl %ebp, 0x108(%rdi)
movaps 0x21093(%rip), %xmm0    # 0x573d0
movups %xmm0, 0xcc(%rdi)
movsd 0x21094(%rip), %xmm0    # 0x573e0
movsd %xmm0, 0xdc(%rdi)
movq 0x322a5(%rip), %rax     # 0x68600
leaq 0x214b4(%rip), %rdi     # 0x57816
movq %rax, %r14
callq *0x40(%rax)
movl %eax, 0x28(%rbx)
cmpl %ebp, 0x280(%rbx)
jne 0x3637d
movl $0x3e8, 0x280(%rbx)     # imm = 0x3E8
movq 0x3285c(%rip), %rax     # 0x68be0
movq %rax, 0x228(%rbx)
orb $0x1, 0xc8(%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: 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 0x364a5
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x363ee
jp 0x363ee
movl $0x43960000, 0x190(%rbx) # imm = 0x43960000
movl $0x2, 0x118(%rbx)
movl $0x0, 0x108(%rbx)
movq 0x321f7(%rip), %r14     # 0x68600
leaq 0x2143e(%rip), %rdi     # 0x5784e
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movaps 0x20f52(%rip), %xmm0    # 0x57370
movups %xmm0, 0xcc(%rbx)
movsd 0x20ff3(%rip), %xmm0    # 0x57420
movsd %xmm0, 0xdc(%rbx)
movq 0x32704(%rip), %rax     # 0x68b40
movq %rax, 0x210(%rbx)
movq 0x32956(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1ce39(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq 0x32092(%rip), %rax     # 0x684f8
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 0x32154(%rip), %rax     # 0x68600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0xe4(%rbx), %rdi
callq 0x190a0
leaq 0x21369(%rip), %rdi     # 0x57833
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%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: 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
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x20eff(%rip), %xmm0    # 0x57460
movups %xmm0, 0xcc(%rdi)
movsd 0x20f70(%rip), %xmm0    # 0x574e0
movsd %xmm0, 0xdc(%rdi)
movq 0x32081(%rip), %r14     # 0x68600
leaq 0x212e6(%rip), %rdi     # 0x5786c
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movq 0x324f4(%rip), %rax     # 0x68a88
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_O3/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
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movq 0x32030(%rip), %r14     # 0x68600
leaq 0x212b7(%rip), %rdi     # 0x5788e
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: 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
movl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movq 0x31fed(%rip), %r14     # 0x68600
leaq 0x2129c(%rip), %rdi     # 0x578b6
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: 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 0x31fbe(%rip), %r14     # 0x68600
leaq 0x21295(%rip), %rsi     # 0x578de
callq *0x58(%r14)
movl $0x0, 0x108(%rbx)
orb $0x2, 0x40(%rbx)
movl $0x1, 0x27c(%rbx)
movq 0x325cc(%rip), %rax     # 0x68c38
movq %rax, 0x238(%rbx)
movl $0x7, 0x118(%rbx)
orb $0x4, 0xc8(%rbx)
movl $0x2, 0x260(%rbx)
callq 0x19a10
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1cbe2(%rip), %xmm0    # 0x53288
mulss 0x1cbf6(%rip), %xmm0    # 0x532a4
movss %xmm0, 0x1cc(%rbx)
callq 0x19a10
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1cbbc(%rip), %xmm0    # 0x53288
mulss 0x1cbd0(%rip), %xmm0    # 0x532a4
movss %xmm0, 0x1d0(%rbx)
callq 0x19a10
andl %ebp, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1cb96(%rip), %xmm0    # 0x53288
mulss 0x1cbaa(%rip), %xmm0    # 0x532a4
movss %xmm0, 0x1d4(%rbx)
movq 0x31d27(%rip), %rax     # 0x68430
movq %rax, 0x210(%rbx)
movq 0x32689(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1cb70(%rip), %xmm0    # 0x53294
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_O3/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 0x31c9c(%rip), %r14     # 0x68600
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_O3/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, %r14
movq 0x130(%rdi), %rbx
movq %rbx, %rdi
callq 0x18680
movq 0x2d0(%r14), %rcx
testq %rcx, %rcx
je 0x36a0a
movslq 0x290(%rcx), %rdx
testq %rdx, %rdx
je 0x36a01
decq %rdx
cmpq %rax, %rdx
jbe 0x369d2
movl $0xc, 0x38(%rcx)
jmp 0x36a01
movzbl (%rbx,%rdx), %edx
leal -0x30(%rdx), %esi
cmpb $0x9, %sil
ja 0x369e7
addl $-0x30, %edx
movl %edx, 0x38(%rcx)
jmp 0x36a01
cmpl $0x3a, %edx
je 0x369fa
cmpl $0x2d, %edx
jne 0x369c9
movl $0xa, 0x38(%rcx)
jmp 0x36a01
movl $0xb, 0x38(%rcx)
movq 0x2c8(%rcx), %rcx
jmp 0x369b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36cb3
cmpl $0x1, %eax
je 0x36c5a
testl %eax, %eax
jne 0x36d53
movq 0x130(%rbx), %rdi
movl 0x254(%rbx), %ecx
leaq 0x20cfd(%rip), %rdx     # 0x5794a
movl $0x10, %esi
xorl %eax, %eax
popq %rbx
jmp 0x18e10
movq 0x130(%rbx), %rdi
movslq 0x254(%rbx), %r8
imulq $-0x77777777, %r8, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %r8d, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0x5, %ecx
addl %eax, %ecx
imull $0x3c, %ecx, %eax
subl %eax, %r8d
leaq 0x20cb9(%rip), %rdx     # 0x57946
movl $0x10, %esi
xorl %eax, %eax
callq 0x18e10
movq 0x130(%rbx), %rax
cmpb $0x20, 0x3(%rax)
jne 0x36d53
movb $0x30, 0x3(%rax)
jmp 0x36d53
movq 0x130(%rbx), %rdi
movslq 0x254(%rbx), %r9
imulq $-0x6e5d4c3b, %r9, %rcx # imm = 0x91A2B3C5
shrq $0x20, %rcx
addl %r9d, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
sarl $0xb, %ecx
addl %eax, %ecx
imull $0xfffff1f0, %ecx, %eax # imm = 0xFFFFF1F0
addl %r9d, %eax
movslq %eax, %r8
imulq $-0x77777777, %r8, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %eax, %r8d
movl %r8d, %eax
shrl $0x1f, %eax
sarl $0x5, %r8d
addl %eax, %r8d
imulq $-0x77777777, %r9, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %r9d, %eax
movl %eax, %edx
shrl $0x1f, %edx
sarl $0x5, %eax
addl %edx, %eax
imull $0x3c, %eax, %eax
subl %eax, %r9d
leaq 0x20c1d(%rip), %rdx     # 0x57942
movl $0x10, %esi
xorl %eax, %eax
callq 0x18e10
movq 0x130(%rbx), %rax
cmpb $0x20, 0x3(%rax)
jne 0x36d49
movb $0x30, 0x3(%rax)
movq 0x130(%rbx), %rax
cmpb $0x20, 0x6(%rax)
jne 0x36d53
movb $0x30, 0x6(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x36d69
movq $0x0, 0x228(%rdi)
cmpq $0x0, 0x2b0(%rdi)
je 0x36d74
retq
movq %rdx, 0x2b0(%rdi)
jmpq *0x210(%rdi)
// File: /workspace/github_c_makefile_star2_O3/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 0x36db3
movl 0x140(%rbx), %ecx
testb $0x2, %cl
jne 0x36dda
testb $0x1, %cl
jne 0x36e03
movq $0x0, 0x2b0(%rbx)
jmp 0x36e3d
movq 0x31846(%rip), %rax     # 0x68600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x20b79(%rip), %rdi     # 0x5794e
jmp 0x36ec6
movl 0x290(%rbx), %eax
testl %eax, %eax
je 0x36ea4
testb $0x1, %cl
jne 0x36e1c
movq $0x0, 0x2b0(%rbx)
movl %eax, 0x254(%rbx)
xorps %xmm0, %xmm0
jmp 0x36e35
movl 0x290(%rbx), %eax
testl %eax, %eax
jne 0x36e1c
movl $0xe10, 0x290(%rbx)     # imm = 0xE10
movl $0xe10, %eax            # imm = 0xE10
movq $0x0, 0x2b0(%rbx)
movl $0x0, 0x254(%rbx)
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x2f8(%rbx)
movq 0x317bc(%rip), %rax     # 0x68600
movl $0x10, %edi
movl $0x2fe, %esi            # imm = 0x2FE
callq *0x108(%rax)
movq %rax, 0x130(%rbx)
movq 0x315ae(%rip), %rax     # 0x68410
movq %rax, 0x210(%rbx)
testb $0x4, 0x140(%rbx)
jne 0x36e90
movq 0x31f27(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x1c0a2(%rip), %xmm0    # 0x52f28
movss %xmm0, 0x200(%rbx)
jmp 0x36e9e
movq 0x31d99(%rip), %rax     # 0x68c30
movq %rax, 0x228(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x31755(%rip), %rax     # 0x68600
movq 0x8(%rax), %r15
movq 0x138(%rbx), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x20aa1(%rip), %rdi     # 0x57967
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%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: 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 0x37023
movq %rsi, %rbx
movq %rdi, %r15
movq 0x150(%rdi), %rdx
xorl %edi, %edi
movl $0x158, %esi            # imm = 0x158
callq 0x19430
testq %rax, %rax
je 0x3702f
movq %rax, %r14
movq 0x316e3(%rip), %rax     # 0x68600
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 0x1bfa1(%rip), %xmm0    # 0x52f14
movss %xmm0, 0xc(%rbx)
movl $0x0, 0x1c8(%rbx)
movq $0x0, 0x1c0(%rbx)
movq 0x58(%rbx), %rax
movb $0x14, 0x11(%rax)
orb $0x20, 0x10(%rax)
movq 0x110(%r15), %rcx
movl $0x6, %edx
movl %edx, 0x50(%rcx)
movl %edx, 0x50(%rbx)
xorl %ecx, %ecx
movss 0x1cdab(%rip), %xmm0    # 0x53d60
movss 0x1cda7(%rip), %xmm1    # 0x53d64
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
cmpq $0x3, %rcx
jne 0x36fbd
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
movq %rcx, 0x10(%rbx)
movl %ecx, 0x24(%rax)
movq %rcx, 0x1c(%rax)
movl %ecx, 0xec4(%rax)
movq %rcx, 0xebc(%rax)
movq %rbx, %rdi
callq 0x18a90
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 0x315ca(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x2093e(%rip), %rdi     # 0x5797f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/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 0x37149
movq 0x31594(%rip), %r14     # 0x68600
leaq 0x20945(%rip), %rsi     # 0x579b8
movq %rbx, %rdi
callq *0x58(%r14)
movabsq $0x2000000000001, %rax  # imm = 0x2000000000001
movq %rax, 0x3c(%rbx)
leaq 0x20948(%rip), %rdi     # 0x579d7
callq *0x48(%r14)
movl %eax, 0x4c(%rbx)
movl $0x2, 0x108(%rbx)
movaps 0x20449(%rip), %xmm0    # 0x574f0
movups %xmm0, 0xcc(%rbx)
movsd 0x2044a(%rip), %xmm0    # 0x57500
movsd %xmm0, 0xdc(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
callq 0x19700
movq 0x31914(%rip), %rcx     # 0x689e8
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 0x203f1(%rip), %xmm0    # 0x57510
movups %xmm0, 0xcc(%rax)
movsd 0x203f2(%rip), %xmm0    # 0x57520
movsd %xmm0, 0xdc(%rax)
movq %rax, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
movq 0x314b0(%rip), %rcx     # 0x68600
leaq 0x20843(%rip), %rdi     # 0x5799a
xorl %eax, %eax
callq *0x8(%rcx)
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_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 0x37193
movq 0x31480(%rip), %rax     # 0x68600
leaq 0x20831(%rip), %rsi     # 0x579b8
movq %rbx, %rdi
callq *0x58(%rax)
movl 0x140(%rbx), %eax
movl $0x0, 0x3c(%rbx)
testb $0x2, %al
jne 0x371a8
movl $0x2, 0x108(%rbx)
movaps 0x20341(%rip), %xmm0    # 0x574f0
movups %xmm0, 0xcc(%rbx)
movsd 0x20342(%rip), %xmm0    # 0x57500
movsd %xmm0, 0xdc(%rbx)
movq 0x31433(%rip), %rax     # 0x68600
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebx
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x372dd
cvtss2sd %xmm0, %xmm0
movq 0x31b0a(%rip), %rax     # 0x68da0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rax), %xmm1
addsd 0x20742(%rip), %xmm1    # 0x579e8
ucomisd %xmm1, %xmm0
ja 0x372dd
movl $0x0, 0x200(%rdi)
movq 0x210(%rdi), %rax
testq %rax, %rax
je 0x372c8
callq *%rax
xorl %ebx, %ebx
jmp 0x372dd
movq 0x31331(%rip), %rcx     # 0x68600
leaq 0x20772(%rip), %rdi     # 0x57a48
xorl %ebx, %ebx
xorl %eax, %eax
callq *0x38(%rcx)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x37314
cmpl $0x0, 0x108(%rbx)
je 0x37314
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 0x3733d
cmpl $0x0, 0x108(%r14)
je 0x3733d
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_O3/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 0x1bbc6(%rip), %xmm0    # 0x52f40
movsd 0x1c8c6(%rip), %xmm3    # 0x53c48
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 0x373aa
movaps %xmm4, %xmm5
movss %xmm5, (%rdx,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x37382
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_O3/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, %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
movq %rdi, %r14
movss %xmm1, 0x8(%rax)
leaq 0xcc(%rsi), %r13
leaq 0xd8(%rsi), %rbp
movq 0x30d1c(%rip), %r12     # 0x68600
leaq 0x30(%rsp), %r15
movl 0x10c(%rbx), %eax
testl %eax, %eax
movl $0x3, %ecx
cmovel %ecx, %eax
movl %eax, (%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
movq %rbp, %rcx
leaq 0x20(%rsp), %r8
movq %rbx, %r9
callq *0x60(%r12)
movl $0x9, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movsd 0xc(%r14), %xmm0
movsd %xmm0, 0x4(%rbx)
movss 0x14(%r14), %xmm0
movss %xmm0, 0xc(%rbx)
movq %rbx, %rdi
callq *0x90(%r12)
movss 0x8(%r14), %xmm0
ucomiss 0x1b5d5(%rip), %xmm0    # 0x52f28
jne 0x37957
jnp 0x37999
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18a80
movq 0x40(%r14), %rax
cmpl $0x0, 0x60(%rax)
movl 0x60(%rbx), %eax
jne 0x3799c
testl %eax, %eax
je 0x379a8
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x4(%rbx)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0xc(%rbx)
movq %rbx, %rdi
callq *0x90(%r12)
jmp 0x378e9
movl 0x60(%rbx), %eax
testl %eax, %eax
je 0x379a8
movq %rbx, %rdi
callq 0x19200
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x18620
testl %eax, %eax
je 0x382a6
leaq 0x10(%rbx), %rdi
leaq 0x1cc(%rbx), %rsi
movss 0x1b01e(%rip), %xmm0    # 0x53290
movq %rdi, %rdx
callq 0x19760
leaq 0x4(%rbx), %rdi
leaq 0x1c0(%rbx), %rsi
movss 0x1b003(%rip), %xmm0    # 0x53290
movq %rdi, %rdx
callq 0x19760
movq 0x30364(%rip), %rax     # 0x68600
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ad03(%rip), %xmm0    # 0x53290
movq %rbx, %rsi
movq %rdi, %rdx
callq 0x19760
xorl %eax, %eax
xorps %xmm0, %xmm0
movss 0x1f473(%rip), %xmm1    # 0x57a18
movss 0x1ec87(%rip), %xmm2    # 0x57234
movss (%rbx,%rax,4), %xmm3
ucomiss %xmm0, %xmm3
jbe 0x385c7
addss %xmm1, %xmm3
movss %xmm3, (%rbx,%rax,4)
ucomiss %xmm3, %xmm0
ja 0x385d5
jmp 0x385dc
addss %xmm2, %xmm3
movss %xmm3, (%rbx,%rax,4)
ucomiss %xmm0, %xmm3
jbe 0x385dc
movl $0x0, (%rbx,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x385ad
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x388fb
movq %rbx, %rdi
callq *%rax
movl 0x118(%rbx), %esi
cmpq $0xa, %rsi
ja 0x38929
leaq 0x1f10e(%rip), %rax     # 0x57a1c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %rbx, %rdi
popq %rbx
jmp 0x191c0
movq %rbx, %rdi
popq %rbx
jmp 0x184c0
movq 0x2fcd0(%rip), %rax     # 0x68600
movq 0x38(%rax), %rcx
leaq 0x1f18f(%rip), %rdi     # 0x57aca
xorl %eax, %eax
popq %rbx
jmpq *%rcx
movq %rbx, %rdi
popq %rbx
jmp 0x18620
movq %rbx, %rdi
popq %rbx
jmp 0x199e0
movq %rbx, %rdi
popq %rbx
jmp 0x18a40
nop
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl %edx, %esi
jge 0x3962f
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x193a0
movl %eax, %r15d
leal -0x1(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x19560
incl %r15d
movl %r15d, %ebp
cmpl %ebx, %r15d
jl 0x395fd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3983c
movl 0xc(%rsi), %eax
cmpq $0xb, %rax
ja 0x39819
movq %rdx, %rbx
movslq 0x8(%rsi), %r14
leaq 0x1e383(%rip), %rcx     # 0x57ae8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x39836
callq 0x18680
incq %rax
jmp 0x39838
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x397f2
movq 0x2edc0(%rip), %rcx     # 0x68558
subq (%rcx), %rax
shrq $0x3, %rax
imull $0x8ce2cabd, %eax, %eax # imm = 0x8CE2CABD
jmp 0x397f7
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x397f2
subq 0x2f689(%rip), %rax     # 0x68e40
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
jmp 0x397f7
movq (%rbx,%r14), %rax
movl 0x2f1bb(%rip), %ecx     # 0x68988
jmp 0x39807
movq (%rbx,%r14), %rax
testq %rax, %rax
je 0x397f2
movq 0x2f561(%rip), %rcx     # 0x68d40
subq 0x408(%rcx), %rax
shrq $0x6, %rax
imull $0x4f4fc08d, %eax, %eax # imm = 0x4F4FC08D
jmp 0x397f7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rbx,%r14)
jmp 0x3983c
movq (%rbx,%r14), %rax
movl 0x2ee81(%rip), %ecx     # 0x68688
movl %eax, %edx
subl %ecx, %edx
xorl %ecx, %ecx
testq %rax, %rax
cmovnel %edx, %ecx
movl %ecx, (%rbx,%r14)
jmp 0x3983c
movq 0x2ede0(%rip), %rax     # 0x68600
movq 0x38(%rax), %rcx
leaq 0x1e861(%rip), %rdi     # 0x5808c
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
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: WriteField2
void WriteField2(FILE* f, field_t* field, byte* base)
{
	size_t		len;
	void* p;

	if (field->flags & FFL_SPAWNTEMP)
		return;

	p = (void*)(base + field->ofs);
	switch (field->type)
	{
	case F_LSTRING:
		if (*(char**)p)
		{
			len = strlen(*(char**)p) + 1;
			fwrite(*(char**)p, len, 1, f);
		}
		break;
	default:// MJD Added because the compile FREAKS, here
		break;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x10(%rsi)
jne 0x39887
cmpl $0x2, 0xc(%rsi)
jne 0x39887
movslq 0x8(%rsi), %rax
movq (%rdx,%rax), %r14
testq %r14, %r14
je 0x39887
movq %rdi, %rbx
movq %r14, %rdi
callq 0x18680
leaq 0x1(%rax), %rsi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19710
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadField
void ReadField(FILE* f, field_t* field, byte* base)
{
	void* p;
	int			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:
		len = *(int*)p;
		if (!len)
			*(char**)p = NULL;
		else
		{
			*(char**)p = gi.TagMalloc(len, TAG_LEVEL);
			size_t count = fread(*(char**)p, len, 1, f);
			if (count)
				; // don't worry, be happy
		}
		break;
	case F_EDICT:
		index = *(int*)p;
		if (index == -1)
			*(edict_t**)p = NULL;
		else
			*(edict_t**)p = &g_edicts[index];
		break;
	case F_CLIENT:
		index = *(int*)p;
		if (index == -1)
			*(gclient_t**)p = NULL;
		else
			*(gclient_t**)p = &game.clients[index];
		break;
	case F_ITEM:
		index = *(int*)p;
		if (index == -1)
			*(gitem_t**)p = NULL;
		else
			*(gitem_t**)p = &itemlist[index];
		break;

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testb $0x1, 0x10(%rsi)
jne 0x39998
movl 0xc(%rsi), %eax
cmpq $0xb, %rax
ja 0x399a4
movq %rdx, %rbx
movslq 0x8(%rsi), %r12
leaq 0x1e25c(%rip), %rcx     # 0x57b18
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq (%rbx,%r12), %r15
testq %r15, %r15
je 0x39990
movq %rdi, %r14
movq 0x2ed24(%rip), %rax     # 0x68600
movl %r15d, %edi
movl $0x2fe, %esi            # imm = 0x2FE
callq *0x108(%rax)
movq %rax, (%rbx,%r12)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x183f0
movslq (%rbx,%r12), %rax
testq %rax, %rax
je 0x39990
addq 0x2ed6c(%rip), %rax     # 0x68688
jmp 0x3998a
movslq (%rbx,%r12), %rax
cmpq $-0x1, %rax
je 0x39990
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rax
addq 0x2f506(%rip), %rax     # 0x68e40
jmp 0x3998a
movslq (%rbx,%r12), %rax
testq %rax, %rax
je 0x39990
addq 0x2f03c(%rip), %rax     # 0x68988
jmp 0x3998a
movslq (%rbx,%r12), %rax
cmpq $-0x1, %rax
je 0x39990
movq 0x2f3e1(%rip), %rcx     # 0x68d40
imulq $0x9140, %rax, %rax     # imm = 0x9140
addq 0x408(%rcx), %rax
jmp 0x3998a
movslq (%rbx,%r12), %rax
cmpq $-0x1, %rax
je 0x39990
movq 0x2ebd8(%rip), %rcx     # 0x68558
imulq $0x4a8, %rax, %rax      # imm = 0x4A8
addq (%rcx), %rax
movq %rax, (%rbx,%r12)
jmp 0x39998
movq $0x0, (%rbx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2ec55(%rip), %rax     # 0x68600
movq 0x38(%rax), %rcx
leaq 0x1e6f5(%rip), %rdi     # 0x580ab
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: WriteClient
void WriteClient(FILE* f, gclient_t* client)
{
	field_t* field;

	// all of the ints, floats, and vectors stay as they are
	temp = *client;

	// change the pointers to lengths or indexes
	for (field = clientfields; field->name; field++)
	{
		WriteField1(f, field, (byte*)&temp);
	}

	// write the block
	fwrite(&temp, sizeof(temp), 1, f);

	// now write any allocated data following the edict
	for (field = clientfields; field->name; field++)
	{
		WriteField2(f, field, (byte*)client);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4c29e(%rip), %rdi     # 0x85c78
movl $0x9140, %edx           # imm = 0x9140
callq 0x18c80
movq 0x2ef45(%rip), %r15     # 0x68930
cmpq $0x0, (%r15)
je 0x39a0e
leaq 0x4c280(%rip), %r12     # 0x85c78
movq %r15, %rsi
movq %r12, %rdx
callq 0x18540
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x399f8
leaq 0x4c263(%rip), %rdi     # 0x85c78
movl $0x9140, %esi           # imm = 0x9140
movl $0x1, %edx
movq %r14, %rcx
callq 0x19710
movq 0x2ef02(%rip), %r15     # 0x68930
cmpq $0x0, (%r15)
je 0x39a4d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x191b0
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x39a34
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadClient
void ReadClient(FILE* f, gclient_t* client)
{
	field_t* field;
	size_t	count;

	count = fread(client, sizeof(*client), 1, f);
	if (count)
		; // don't worry, be happy

	for (field = clientfields; field->name; field++)
	{
		ReadField(f, field, (byte*)client);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x9140, %esi           # imm = 0x9140
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x183f0
movq 0x2eeb0(%rip), %r15     # 0x68930
cmpq $0x0, (%r15)
je 0x39a9f
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x198b0
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x39a86
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: WriteGame
void WriteGame(char* filename, qboolean autosave)
{
	FILE* f;
	int		i;
	char	str[MAX_INFO_STRING];

	if (!autosave)
		SaveClientData();

	f = fopen(filename, "wb");
	if (!f)
	{
		gi.error("Couldn't open %s", filename);
		return;
	}

	memset(str, 0, sizeof(str));
	strcpy(str, __DATE__);
	fwrite(str, sizeof(str), 1, f);

	game.autosaved = autosave;
	fwrite(&game, sizeof(game), 1, f);
	game.autosaved = false;

	for (i = 0; i < game.maxclients; i++)
		WriteClient(f, &game.clients[i]);

	fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %esi, %ebp
movq %rdi, %r14
testl %esi, %esi
jne 0x39ac2
callq 0x18cd0
leaq 0x1d7f7(%rip), %rsi     # 0x572c0
movq %r14, %rdi
callq 0x19470
testq %rax, %rax
je 0x39b99
movq %rax, %rbx
leaq 0xc(%rsp), %r14
movl $0x1f4, %edx            # imm = 0x1F4
movq %r14, %rdi
xorl %esi, %esi
callq 0x18880
movabsq $0x3220343120677541, %rax # imm = 0x3220343120677541
movq %rax, -0xc(%r14)
movl $0x353230, -0x4(%r14)   # imm = 0x353230
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movl $0x1, %edx
movq %rbx, %rcx
callq 0x19710
movq 0x2f21d(%rip), %r14     # 0x68d40
movl %ebp, 0x620(%r14)
movl $0x628, %esi            # imm = 0x628
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x19710
movl $0x0, 0x620(%r14)
cmpl $0x0, 0x610(%r14)
jle 0x39b82
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x408(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x194a0
incq %r12
movslq 0x610(%r14), %rax
addq $0x9140, %r15           # imm = 0x9140
cmpq %rax, %r12
jl 0x39b5a
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x185a0
movq 0x2ea60(%rip), %rax     # 0x68600
movq 0x38(%rax), %rcx
leaq 0x1a352(%rip), %rdi     # 0x53efd
movq %r14, %rsi
xorl %eax, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadGame
void ReadGame(char* filename)
{
	FILE* f;
	int		i;
	char	str[MAX_INFO_STRING] = { 0 };
	size_t	count;

	gi.FreeTags(TAG_GAME);

	f = fopen(filename, "rb");
	if (!f)
	{
		gi.error("Couldn't open %s", filename);
		return;
	}

	count = fread(str, sizeof(str), 1, f);
	if (count)
		; // don't worry, be happy
	if (strcmp(str, __DATE__))
	{
		fclose(f);
		gi.error("Savegame from an older version.\n");
	}

	g_edicts = gi.TagMalloc(game.maxentities * sizeof(g_edicts[0]), TAG_GAME);
	globals.edicts = g_edicts;

	count = fread(&game, sizeof(game), 1, f);
	game.clients = gi.TagMalloc(game.maxclients * sizeof(game.clients[0]), TAG_GAME);
	for (i = 0; i < game.maxclients; i++)
		ReadClient(f, &game.clients[i]);

	fclose(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %r14
movq %rsp, %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x18880
movq 0x2ea18(%rip), %r15     # 0x68600
movl $0x2fd, %edi            # imm = 0x2FD
callq *0x118(%r15)
leaq 0x1d6c2(%rip), %rsi     # 0x572bd
movq %r14, %rdi
callq 0x19470
testq %rax, %rax
je 0x39d10
movq %rax, %rbx
movq %rsp, %r14
movl $0x200, %esi            # imm = 0x200
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x183f0
movabsq $0x3220343120677541, %rax # imm = 0x3220343120677541
xorq (%r14), %rax
movl 0x8(%r14), %ecx
xorq $0x353230, %rcx         # imm = 0x353230
orq %rax, %rcx
je 0x39c59
movq %rbx, %rdi
callq 0x185a0
leaq 0x1e476(%rip), %rdi     # 0x580c9
xorl %eax, %eax
callq *0x38(%r15)
movq 0x2f0e0(%rip), %r14     # 0x68d40
imull $0x4a8, 0x614(%r14), %edi # imm = 0x4A8
movl $0x2fd, %esi            # imm = 0x2FD
callq *0x108(%r15)
movq 0x2e8da(%rip), %rcx     # 0x68558
movq %rax, (%rcx)
movq 0x2ee80(%rip), %rcx     # 0x68b08
movq %rax, 0x80(%rcx)
movl $0x628, %esi            # imm = 0x628
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x183f0
imull $0x9140, 0x610(%r14), %edi # imm = 0x9140
movl $0x2fd, %esi            # imm = 0x2FD
callq *0x108(%r15)
movq %rax, 0x408(%r14)
cmpl $0x0, 0x610(%r14)
jle 0x39cfa
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x408(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x19290
incq %r12
movslq 0x610(%r14), %rax
addq $0x9140, %r15           # imm = 0x9140
cmpq %rax, %r12
jl 0x39cd2
movq %rbx, %rdi
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x185a0
movq 0x38(%r15), %rcx
leaq 0x1a1e2(%rip), %rdi     # 0x53efd
movq %r14, %rsi
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: WriteEdict
void WriteEdict(FILE* f, edict_t* ent)
{
	field_t* field;
	edict_t		temp;

	// all of the ints, floats, and vectors stay as they are
	temp = *ent;

	// change the pointers to lengths or indexes
	for (field = fields; field->name; field++)
	{
		WriteField1(f, field, (byte*)&temp);
	}

	// write the block
	fwrite(&temp, sizeof(temp), 1, f);

	// now write any allocated data following the edict
	for (field = fields; field->name; field++)
	{
		WriteField2(f, field, (byte*)ent);
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rdi
movl $0x4a8, %edx            # imm = 0x4A8
callq 0x18c80
movq 0x2ece8(%rip), %r15     # 0x68a40
cmpq $0x0, (%r15)
je 0x39d77
movq %rsp, %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x18540
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x39d61
movq %rsp, %rdi
movl $0x4a8, %esi            # imm = 0x4A8
movl $0x1, %edx
movq %r14, %rcx
callq 0x19710
movq 0x2ecad(%rip), %r15     # 0x68a40
cmpq $0x0, (%r15)
je 0x39db2
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x191b0
cmpq $0x0, 0x18(%r15)
leaq 0x18(%r15), %r15
jne 0x39d99
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: WriteLevelLocals
void WriteLevelLocals(FILE* f)
{
	field_t* field;
	level_locals_t		temp;

	// all of the ints, floats, and vectors stay as they are
	temp = level;

	// change the pointers to lengths or indexes
	for (field = levelfields; field->name; field++)
	{
		WriteField1(f, field, (byte*)&temp);
	}

	// write the block
	fwrite(&temp, sizeof(temp), 1, f);

	// now write any allocated data following the edict
	for (field = levelfields; field->name; field++)
	{
		WriteField2(f, field, (byte*)&level);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
movq 0x2efc9(%rip), %rsi     # 0x68da0
leaq 0x8(%rsp), %rdi
movl $0x158, %edx            # imm = 0x158
callq 0x18c80
movq 0x2e90b(%rip), %r14     # 0x686f8
cmpq $0x0, (%r14)
je 0x39e0e
leaq 0x8(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x18540
cmpq $0x0, 0x18(%r14)
leaq 0x18(%r14), %r14
jne 0x39df8
leaq 0x8(%rsp), %rdi
movl $0x158, %esi            # imm = 0x158
movl $0x1, %edx
movq %rbx, %rcx
callq 0x19710
movq 0x2e8cc(%rip), %r14     # 0x686f8
cmpq $0x0, (%r14)
je 0x39e52
movq 0x2ef67(%rip), %r15     # 0x68da0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x191b0
cmpq $0x0, 0x18(%r14)
leaq 0x18(%r14), %r14
jne 0x39e39
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq