LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x444cc
movq 0x3e17f(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xe4, %rdi
callq 0x19260
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rax, %rdx
leaq 0x30065(%rip), %rdi     # 0x7451f
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x4463a
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x444f6
jp 0x444f6
movq -0x8(%rbp), %rax
movss 0x2bf96(%rip), %xmm0    # 0x70484
movss %xmm0, 0x190(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x118(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
leaq 0x30021(%rip), %rdi     # 0x7453a
movq 0x3e0e0(%rip), %rax     # 0x82600
callq *0x40(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movss 0x2bf50(%rip), %xmm0    # 0x70488
movss %xmm0, 0xcc(%rax)
movq -0x8(%rbp), %rax
movss 0x2bf3c(%rip), %xmm0    # 0x70488
movss %xmm0, 0xd0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xd4(%rax)
movq -0x8(%rbp), %rax
movss 0x2fc89(%rip), %xmm0    # 0x741f8
movss %xmm0, 0xd8(%rax)
movq -0x8(%rbp), %rax
movss 0x2fc75(%rip), %xmm0    # 0x741f8
movss %xmm0, 0xdc(%rax)
movq -0x8(%rbp), %rax
movss 0x2bedd(%rip), %xmm0    # 0x70474
movss %xmm0, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq 0x3e596(%rip), %rcx     # 0x82b40
movq %rcx, 0x210(%rax)
movss 0x2bcdb(%rip), %xmm0    # 0x70294
movq 0x3e7e0(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x3df1c(%rip), %rcx     # 0x824f8
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x378(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x37c(%rax)
movq -0x8(%rbp), %rax
movss %xmm0, 0x374(%rax)
movq 0x3dfd3(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x108(%rax)
movq -0x8(%rbp), %rax
movss 0x2faf0(%rip), %xmm0    # 0x74204
movss %xmm0, 0xcc(%rax)
movq -0x8(%rbp), %rax
movss 0x2fadc(%rip), %xmm0    # 0x74204
movss %xmm0, 0xd0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0xd4(%rax)
movq -0x8(%rbp), %rax
movss 0x2b7c9(%rip), %xmm0    # 0x6ff14
movss %xmm0, 0xd8(%rax)
movq -0x8(%rbp), %rax
movss 0x2b7b5(%rip), %xmm0    # 0x6ff14
movss %xmm0, 0xdc(%rax)
movq -0x8(%rbp), %rax
movss 0x2b771(%rip), %xmm0    # 0x6fee4
movss %xmm0, 0xe0(%rax)
leaq 0x2fdd6(%rip), %rdi     # 0x74558
movq 0x3de77(%rip), %rax     # 0x82600
callq *0x40(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x3e2e8(%rip), %rcx     # 0x82a88
movq %rcx, 0x228(%rax)
movq 0x3de52(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x108(%rax)
leaq 0x2fd7b(%rip), %rdi     # 0x7457a
movq 0x3ddfa(%rip), %rax     # 0x82600
callq *0x40(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq 0x3dde7(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x118(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x108(%rax)
leaq 0x2fd43(%rip), %rdi     # 0x745a2
movq 0x3dd9a(%rip), %rax     # 0x82600
callq *0x40(%rax)
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq 0x3dd87(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3dd5d(%rip), %rax     # 0x82600
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
leaq 0x2fd18(%rip), %rsi     # 0x745ca
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x27c(%rax)
movq -0x8(%rbp), %rax
movq 0x3e350(%rip), %rcx     # 0x82c38
movq %rcx, 0x238(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0x118(%rax)
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0xc8(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x260(%rax)
callq 0x19c80
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
movss 0x2b954(%rip), %xmm1    # 0x70288
divss %xmm1, %xmm0
movss 0x2b960(%rip), %xmm1    # 0x702a0
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1cc(%rax)
callq 0x19c80
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
movss 0x2b922(%rip), %xmm1    # 0x70288
divss %xmm1, %xmm0
movss 0x2b92e(%rip), %xmm1    # 0x702a0
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1d0(%rax)
callq 0x19c80
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
movss 0x2b8f0(%rip), %xmm1    # 0x70288
divss %xmm1, %xmm0
movss 0x2b8fc(%rip), %xmm1    # 0x702a0
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x1d4(%rax)
movq -0x8(%rbp), %rax
movq 0x3da71(%rip), %rcx     # 0x82430
movq %rcx, 0x210(%rax)
movss 0x2b8c2(%rip), %xmm0    # 0x70290
movq 0x3e3cb(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq 0x3dc13(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x2, 0x118(%rax)
movq 0x3d8ff(%rip), %rax     # 0x82600
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq 0x120(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movl $0x3, 0x108(%rax)
movq -0x8(%rbp), %rax
movl $0xc, 0x38(%rax)
movq 0x3d8ca(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
callq 0x186e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x44e56
movq -0x20(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x44da4
jmp 0x44e42
movq -0x20(%rbp), %rax
movslq 0x290(%rax), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x44dce
movq -0x20(%rbp), %rax
movl $0xc, 0x38(%rax)
jmp 0x44e42
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x30, %eax
jl 0x44e05
movsbl -0x31(%rbp), %eax
cmpl $0x39, %eax
jg 0x44e05
movsbl -0x31(%rbp), %ecx
subl $0x30, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
jmp 0x44e40
movsbl -0x31(%rbp), %eax
cmpl $0x2d, %eax
jne 0x44e1b
movq -0x20(%rbp), %rax
movl $0xa, 0x38(%rax)
jmp 0x44e3e
movsbl -0x31(%rbp), %eax
cmpl $0x3a, %eax
jne 0x44e31
movq -0x20(%rbp), %rax
movl $0xb, 0x38(%rax)
jmp 0x44e3c
movq -0x20(%rbp), %rax
movl $0xc, 0x38(%rax)
jmp 0x44e3e
jmp 0x44e40
jmp 0x44e42
movq -0x20(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x44d87
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x32c(%rax)
jne 0x451c6
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x254(%rax), %ecx
movl $0x10, %esi
leaq 0x2f47c(%rip), %rdx     # 0x74636
movb $0x0, %al
callq 0x18f90
jmp 0x45319
movq -0x8(%rbp), %rax
cmpl $0x1, 0x32c(%rax)
jne 0x45242
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x254(%rax), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x254(%rax), %eax
movl $0x3c, %esi
cltd
idivl %esi
movl %edx, %r8d
movl $0x10, %esi
leaq 0x2f41f(%rip), %rdx     # 0x74632
movb $0x0, %al
callq 0x18f90
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movsbl 0x3(%rax), %eax
cmpl $0x20, %eax
jne 0x4523d
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movb $0x30, 0x3(%rax)
jmp 0x45319
movq -0x8(%rbp), %rax
cmpl $0x2, 0x32c(%rax)
jne 0x45319
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x254(%rax), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl 0x254(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x254(%rax), %eax
movl $0xe10, %esi            # imm = 0xE10
cltd
idivl %esi
movl %eax, %edx
movl -0xc(%rbp), %eax
imull $0xe10, %edx, %edx      # imm = 0xE10
subl %edx, %eax
movl $0x3c, %esi
cltd
idivl %esi
movl %eax, %r8d
movq -0x8(%rbp), %rax
movl 0x254(%rax), %eax
movl $0x3c, %esi
cltd
idivl %esi
movl %edx, %r9d
movl $0x10, %esi
leaq 0x2f364(%rip), %rdx     # 0x7462e
movb $0x0, %al
callq 0x18f90
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movsbl 0x3(%rax), %eax
cmpl $0x20, %eax
jne 0x452f4
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movb $0x30, 0x3(%rax)
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movsbl 0x6(%rax), %eax
cmpl $0x20, %eax
jne 0x45317
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rax
movb $0x30, 0x6(%rax)
jmp 0x45319
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x45371
movq -0x8(%rbp), %rax
movl $0x0, 0x254(%rax)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x290(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x2f8(%rax)
jmp 0x453a8
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x453a6
movq -0x8(%rbp), %rax
movl 0x290(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x254(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x2f8(%rax)
jmp 0x453a8
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x453e5
movq -0x8(%rbp), %rax
movq $0x0, 0x228(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2b0(%rax)
je 0x453f5
jmp 0x45415
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x45489
movq 0x3d1bf(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rax, %rdx
leaq 0x2f1c3(%rip), %rdi     # 0x7463a
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x455aa
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x454f7
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x454f7
movq 0x3d151(%rip), %rax     # 0x82600
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x19260
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq %rax, %rdx
leaq 0x2f16e(%rip), %rdi     # 0x74653
movb $0x0, %al
callq *%rcx
movq -0x8(%rbp), %rdi
callq 0x19cd0
jmp 0x455aa
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x45524
movq -0x8(%rbp), %rax
cmpl $0x0, 0x290(%rax)
jne 0x45524
movq -0x8(%rbp), %rax
movl $0xe10, 0x290(%rax)     # imm = 0xE10
movq -0x8(%rbp), %rdi
callq 0x45320
movl $0x10, %edi
movl $0x2fe, %esi            # imm = 0x2FE
movq 0x3d0c2(%rip), %rax     # 0x82600
callq *0x108(%rax)
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x130(%rax)
movq -0x8(%rbp), %rax
movq 0x3ceb3(%rip), %rcx     # 0x82410
movq %rcx, 0x210(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4558a
movq -0x8(%rbp), %rax
movq 0x3d6af(%rip), %rcx     # 0x82c30
movq %rcx, 0x228(%rax)
jmp 0x455aa
movss 0x2a95a(%rip), %xmm0    # 0x6feec
movq 0x3d807(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x45ab6
movq 0x3cb5b(%rip), %rax     # 0x82600
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
leaq 0x2ebf0(%rip), %rsi     # 0x746a4
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x45ae1
movq -0x8(%rbp), %rax
movl $0x2, 0x108(%rax)
movq -0x8(%rbp), %rax
movss 0x2b91f(%rip), %xmm0    # 0x7140c
movss %xmm0, 0xcc(%rax)
movq -0x8(%rbp), %rax
movss 0x2b90b(%rip), %xmm0    # 0x7140c
movss %xmm0, 0xd0(%rax)
movq -0x8(%rbp), %rax
movss 0x2e6eb(%rip), %xmm0    # 0x74200
movss %xmm0, 0xd4(%rax)
movq -0x8(%rbp), %rax
movss 0x2a94b(%rip), %xmm0    # 0x70474
movss %xmm0, 0xd8(%rax)
movq -0x8(%rbp), %rax
movss 0x2a937(%rip), %xmm0    # 0x70474
movss %xmm0, 0xdc(%rax)
movq -0x8(%rbp), %rax
movss 0x2a937(%rip), %xmm0    # 0x70488
movss %xmm0, 0xe0(%rax)
movq 0x3caa0(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_phys.c
// Function: SV_TestEntityPosition
edict_t	*SV_TestEntityPosition (edict_t *ent)
{
	trace_t	trace;
	int		mask;

	if (ent->clipmask)
		mask = ent->clipmask;
	else
		mask = MASK_SOLID;
	trace = gi.trace (ent->s.origin, ent->mins, ent->maxs, ent->s.origin, ent, mask);
	
	if (trace.startsolid)
		return g_edicts;
		
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10c(%rax)
je 0x45bab
movq -0x10(%rbp), %rax
movl 0x10c(%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x45bb2
movl $0x3, -0x5c(%rbp)
movq 0x3ca47(%rip), %rax     # 0x82600
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
movq -0x10(%rbp), %rdx
addq $0xcc, %rdx
movq -0x10(%rbp), %rcx
addq $0xd8, %rcx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq -0x10(%rbp), %r9
movl -0x5c(%rbp), %r10d
leaq -0xa8(%rbp), %rdi
movl %r10d, (%rsp)
callq *%rax
leaq -0x58(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x48, %edx
callq 0x18dc0
cmpl $0x0, -0x54(%rbp)
je 0x45c23
movq 0x3c93e(%rip), %rax     # 0x82558
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x45c2b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x45d0d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x1c0(%rax,%rcx,4), %xmm0
movq 0x3ccff(%rip), %rax     # 0x82970
movq (%rax), %rax
ucomiss 0x20(%rax), %xmm0
jbe 0x45c9c
movq 0x3ccef(%rip), %rax     # 0x82970
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss %xmm0, 0x1c0(%rax,%rcx,4)
jmp 0x45cfd
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x1c0(%rax,%rcx,4), %xmm1
movq 0x3ccbc(%rip), %rax     # 0x82970
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x45cfb
movq 0x3cc9b(%rip), %rax     # 0x82970
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss %xmm0, 0x1c0(%rax,%rcx,4)
jmp 0x45cfd
jmp 0x45cff
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x45c4f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x200(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x45d42
movl $0x1, -0x4(%rbp)
jmp 0x45dc7
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x3d04e(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x2e975(%rip), %xmm2    # 0x746d8
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x45d76
movl $0x1, -0x4(%rbp)
jmp 0x45dc7
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x200(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x210(%rax)
jne 0x45daf
leaq 0x2e996(%rip), %rdi     # 0x74730
movq 0x3c85f(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x38(%rcx)
movl $0x0, -0x4(%rbp)
jmp 0x45dc7
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0x45e2c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x108(%rax)
je 0x45e2c
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
callq *%rax
movq -0x18(%rbp), %rax
cmpq $0x0, 0x220(%rax)
je 0x45e61
movq -0x18(%rbp), %rax
cmpl $0x0, 0x108(%rax)
je 0x45e61
movq -0x18(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %ecx, %ecx
movq %rcx, %rdx
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x45ea6
movl -0x2c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x45ec2
jp 0x45ec2
movl -0x2c(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
movq -0x10(%rbp), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
mulss -0x1c(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0x45fb5
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
mulss -0x20(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
subss -0x24(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2e770(%rip), %xmm1    # 0x746e0
ucomisd %xmm1, %xmm0
jbe 0x45fa5
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x2ac89(%rip), %xmm0    # 0x70c18
ucomisd %xmm1, %xmm0
jbe 0x45fa5
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x45fa7
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x45f17
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x1c(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
addss 0x8(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10c(%rax)
je 0x4681c
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x46823
movl $0x3, -0x2c(%rbp)
movq 0x3bdd6(%rip), %rax     # 0x82600
movq 0x60(%rax), %rax
leaq -0x1c(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0xcc, %rdx
movq -0x8(%rbp), %rcx
addq $0xd8, %rcx
leaq -0x28(%rbp), %r8
movq -0x8(%rbp), %r9
movl -0x2c(%rbp), %r10d
leaq -0x78(%rbp), %rdi
movl %r10d, (%rsp)
callq *%rax
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
movl $0x48, %edx
callq 0x18dc0
movq -0x88(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rcx
movss %xmm0, 0x4(%rcx)
movss 0x10(%rax), %xmm0
movq -0x8(%rbp), %rcx
movss %xmm0, 0x8(%rcx)
movss 0x14(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq 0x3bd55(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x88(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x29670(%rip), %xmm1    # 0x6ff40
ucomisd %xmm1, %xmm0
jne 0x468da
jp 0x468da
jmp 0x4694a
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x18b50
movq -0x88(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x0, 0x60(%rax)
jne 0x46948
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x46948
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq 0x3bcca(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x46800
jmp 0x4694a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x4695d
movq -0x8(%rbp), %rdi
callq 0x193f0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18680
cmpl $0x0, %eax
jne 0x4759c
jmp 0x47600
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x1cc, %rsi            # imm = 0x1CC
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movss 0x28cd5(%rip), %xmm0    # 0x70294
callq 0x199c0
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
movss 0x28cad(%rip), %xmm0    # 0x70294
callq 0x199c0
movq 0x3b00d(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
addq $0x1cc, %rsi            # imm = 0x1CC
movq -0x8(%rbp), %rdx
addq $0x10, %rdx
movss 0x28785(%rip), %xmm0    # 0x70294
callq 0x199c0
movss 0x2b068(%rip), %xmm0    # 0x72b84
movss %xmm0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x47bf7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x1cc(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x47b99
movss -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x1cc(%rax,%rcx,4), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x1cc(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss 0x1cc(%rax,%rcx,4), %xmm0
jbe 0x47b97
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x1cc(%rax,%rcx,4)
jmp 0x47be7
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addss 0x1cc(%rax,%rcx,4), %xmm0
movss %xmm0, 0x1cc(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss 0x1cc(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x47be5
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x1cc(%rax,%rcx,4)
jmp 0x47be7
jmp 0x47be9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x47b28
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x208(%rax)
je 0x481cb
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl 0x118(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0xa, %rax
ja 0x4822a
movq -0x10(%rbp), %rax
leaq 0x2c51a(%rip), %rcx     # 0x74704
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x18500
jmp 0x4824a
movq -0x8(%rbp), %rdi
callq 0x19420
jmp 0x4824a
movq -0x8(%rbp), %rdi
callq 0x19c50
jmp 0x4824a
movq -0x8(%rbp), %rdi
callq 0x18b10
jmp 0x4824a
movq -0x8(%rbp), %rdi
callq 0x19390
jmp 0x4824a
movq 0x3a3cf(%rip), %rax     # 0x82600
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x118(%rax), %esi
leaq 0x2c56c(%rip), %rdi     # 0x747b2
movb $0x0, %al
callq *%rcx
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x49360
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x195c0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
subl $0x1, %edx
callq 0x19780
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x19780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x4941d
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jge 0x49410
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x30(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x18ad0
jmp 0x49412
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x493b7
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
callq 0x18ad0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x496d5
jmp 0x49731
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x2, %eax
jne 0x4972f
jmp 0x496f6
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4972d
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x186e0
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl $0x1, %edx
callq 0x19960
jmp 0x49731
jmp 0x49731
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x564cd(%rip), %rdi     # 0x9fe48
movl $0x9140, %edx           # imm = 0x9140
callq 0x18dc0
movq 0x38fa4(%rip), %rax     # 0x82930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x499bc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x5649f(%rip), %rdx     # 0x9fe48
callq 0x18580
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x49990
movq -0x8(%rbp), %rcx
leaq 0x56481(%rip), %rdi     # 0x9fe48
movl $0x9140, %esi           # imm = 0x9140
movl $0x1, %edx
callq 0x19960
movq 0x38f53(%rip), %rax     # 0x82930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49a0a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x19380
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x499e1
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x9140, %esi           # imm = 0x9140
movl $0x1, %edx
callq 0x18430
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x49a44
jmp 0x49a44
movq 0x38ee5(%rip), %rax     # 0x82930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49a78
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x19b20
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x49a4f
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x49a9d
callq 0x18e10
movq -0x8(%rbp), %rdi
leaq 0x2a6a7(%rip), %rsi     # 0x7414f
callq 0x196a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x49ad7
movq 0x38b41(%rip), %rax     # 0x82600
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rsi
leaq 0x273f3(%rip), %rdi     # 0x70ec1
movb $0x0, %al
callq *%rcx
jmp 0x49ba4
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x188f0
leaq -0x220(%rbp), %rdi
leaq 0x28e49(%rip), %rsi     # 0x72941
callq 0x182c0
leaq -0x220(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x200, %esi            # imm = 0x200
movl $0x1, %edx
callq 0x19960
movl -0xc(%rbp), %ecx
movq 0x3921f(%rip), %rax     # 0x82d40
movl %ecx, 0x620(%rax)
movq -0x18(%rbp), %rcx
movq 0x3920e(%rip), %rdi     # 0x82d40
movl $0x628, %esi            # imm = 0x628
movl $0x1, %edx
callq 0x19960
movq 0x391f8(%rip), %rax     # 0x82d40
movl $0x0, 0x620(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x391dd(%rip), %rcx     # 0x82d40
cmpl 0x610(%rcx), %eax
jge 0x49b9b
movq -0x18(%rbp), %rdi
movq 0x391ca(%rip), %rax     # 0x82d40
movq 0x408(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x9140, %rax, %rax     # imm = 0x9140
addq %rax, %rsi
callq 0x196d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x49b59
movq -0x18(%rbp), %rdi
callq 0x18600
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x4c0(%rbp), %rdi
movl $0x4a8, %edx            # imm = 0x4A8
callq 0x18dc0
movq 0x38c81(%rip), %rax     # 0x82a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49def
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x4c0(%rbp), %rdx
callq 0x18580
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x49dc3
movq -0x8(%rbp), %rcx
leaq -0x4c0(%rbp), %rdi
movl $0x4a8, %esi            # imm = 0x4A8
movl $0x1, %edx
callq 0x19960
movq 0x38c30(%rip), %rax     # 0x82a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49e3d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x19380
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x49e14
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
leaq -0x168(%rbp), %rdi
movq 0x38f33(%rip), %rsi     # 0x82da0
movl $0x158, %edx            # imm = 0x158
callq 0x18dc0
movq 0x3887a(%rip), %rax     # 0x826f8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49eae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x168(%rbp), %rdx
callq 0x18580
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x49e82
movq -0x8(%rbp), %rcx
leaq -0x168(%rbp), %rdi
movl $0x158, %esi            # imm = 0x158
movl $0x1, %edx
callq 0x19960
movq 0x38829(%rip), %rax     # 0x826f8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49eff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x38eb4(%rip), %rdx     # 0x82da0
callq 0x19380
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x49ed3
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadEdict
void ReadEdict(FILE* f, edict_t* ent)
{
	field_t* field;
	size_t	count;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x4a8, %esi            # imm = 0x4A8
movl $0x1, %edx
callq 0x18430
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x49f44
jmp 0x49f44
movq 0x38af5(%rip), %rax     # 0x82a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49f78
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x19b20
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x49f4f
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_save.c
// Function: ReadLevelLocals
void ReadLevelLocals(FILE* f)
{
	field_t* field;
	size_t	count;

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

	for (field = levelfields; field->name; field++)
	{
		ReadField(f, field, (byte*)&level);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x38e09(%rip), %rdi     # 0x82da0
movl $0x158, %esi            # imm = 0x158
movl $0x1, %edx
callq 0x18430
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x49fb3
jmp 0x49fb3
movq 0x3873e(%rip), %rax     # 0x826f8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49fea
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x38dc9(%rip), %rdx     # 0x82da0
callq 0x19b20
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x49fbe
addq $0x20, %rsp
popq %rbp
retq