LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: button_fire
void button_fire (edict_t *self)
{
	if (self->moveinfo.state == STATE_UP || self->moveinfo.state == STATE_TOP)
		return;

	self->moveinfo.state = STATE_UP;
	if (self->moveinfo.sound_start && !(self->flags & FL_TEAMSLAVE))
		gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_start, 1, ATTN_STATIC, 0);
	Move_Calc (self, self->moveinfo.end_origin, button_wait);
}

// Assembly:
testl $0xfffffffd, 0x388(%rdi) # imm = 0xFFFFFFFD
jne 0x2d1f1
retq
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x388(%rdi)
movl 0x368(%rdi), %edx
testl %edx, %edx
je 0x2d237
testb $0x4, 0x11d(%rbx)
jne 0x2d237
movq 0x3b3e7(%rip), %rax     # 0x68600
movss 0x25d07(%rip), %xmm0    # 0x52f28
movss 0x25ce7(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
leaq 0x350(%rbx), %rsi
movq 0x3b59b(%rip), %rdx     # 0x687e0
movq %rbx, %rdi
popq %rbx
jmp 0x18e70
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_use_areaportals
void door_use_areaportals (edict_t *self, qboolean open)
{
	edict_t	*t = NULL;

	if (!self->target)
		return;

	//surt eliminate level 4 warnings. (removed assignment in conditional while)
	t = G_Find (t, FOFS(targetname), self->target);
	while (t)
	{
		if (Q_stricmp(t->classname, "func_areaportal") == 0)
		{
			gi.SetAreaPortalState (t->style, open);
		}
		t = G_Find (t, FOFS(targetname), self->target);
	}
}

// Assembly:
movq 0x150(%rdi), %rdx
testq %rdx, %rdx
je 0x2d579
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %edi, %edi
movl $0x158, %esi            # imm = 0x158
callq 0x19430
testq %rax, %rax
je 0x2d570
movq %rax, %r15
leaq 0x28838(%rip), %r12     # 0x55d62
movq 0x3b0cf(%rip), %r13     # 0x68600
movq 0x138(%r15), %rdi
movq %r12, %rsi
callq 0x18690
testl %eax, %eax
jne 0x2d554
movl 0x32c(%r15), %edi
movl %ebx, %esi
callq *0x80(%r13)
movq 0x150(%r14), %rdx
movq %r15, %rdi
movl $0x158, %esi            # imm = 0x158
callq 0x19430
movq %rax, %r15
testq %rax, %rax
jne 0x2d531
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_hit_top
void door_hit_top (edict_t *self)
{
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_end)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_end, 1, ATTN_STATIC, 0);
		self->s.sound = 0;
	}
	self->moveinfo.state = STATE_TOP;
	if (self->spawnflags & DOOR_TOGGLE)
		return;
	if (self->moveinfo.wait >= 0)
	{
		self->think = door_go_down;
		self->nextthink = level.time + self->moveinfo.wait;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2d5bd
movl 0x370(%rbx), %edx
testl %edx, %edx
je 0x2d5b6
movq 0x3b068(%rip), %rax     # 0x68600
movss 0x25988(%rip), %xmm0    # 0x52f28
movss 0x25968(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl $0x0, 0x4c(%rbx)
movl $0x0, 0x388(%rbx)
testb $0x20, 0x140(%rbx)
jne 0x2d602
movss 0x384(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2d602
movq 0x3b931(%rip), %rax     # 0x68f18
movq %rax, 0x210(%rbx)
movq 0x3b7ab(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_go_down
void door_go_down (edict_t *self)
{
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_start)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_start, 1, ATTN_STATIC, 0);
		self->s.sound = self->moveinfo.sound_middle;
	}
	if (self->max_health)
	{
		self->takedamage = DAMAGE_YES;
		self->health = self->max_health;
	}
	
	self->moveinfo.state = STATE_DOWN;
	if (strcmp(self->classname, "func_door") == 0)
		Move_Calc (self, self->moveinfo.start_origin, door_hit_bottom);
	else if (strcmp(self->classname, "func_door_rotating") == 0)
		AngleMove_Calc (self, door_hit_bottom);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2d64c
movl 0x368(%rbx), %edx
testl %edx, %edx
je 0x2d643
movq 0x3afdb(%rip), %rax     # 0x68600
movss 0x258fb(%rip), %xmm0    # 0x52f28
movss 0x258db(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl 0x36c(%rbx), %eax
movl %eax, 0x4c(%rbx)
movl 0x258(%rbx), %eax
testl %eax, %eax
je 0x2d666
movl $0x1, 0x27c(%rbx)
movl %eax, 0x254(%rbx)
movl $0x3, 0x388(%rbx)
movq 0x138(%rbx), %r14
leaq 0x286f4(%rip), %rsi     # 0x55d72
movq %r14, %rdi
callq 0x18b20
testl %eax, %eax
je 0x2d6a5
leaq 0x286eb(%rip), %rsi     # 0x55d7c
movq %r14, %rdi
callq 0x18b20
testl %eax, %eax
je 0x2d6c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x338(%rbx), %rsi
movq 0x3b79d(%rip), %rdx     # 0x68e50
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18e70
movq 0x3b787(%rip), %rsi     # 0x68e50
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x182d0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_hit_bottom
void door_hit_bottom (edict_t *self)
{
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_end)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_end, 1, ATTN_STATIC, 0);
		self->s.sound = 0;
	}
	self->moveinfo.state = STATE_BOTTOM;
	door_use_areaportals (self, false);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2d71b
movl 0x370(%rbx), %edx
testl %edx, %edx
je 0x2d714
movq 0x3af0a(%rip), %rax     # 0x68600
movss 0x2582a(%rip), %xmm0    # 0x52f28
movss 0x2580a(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl $0x0, 0x4c(%rbx)
movl $0x1, 0x388(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x18230
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_go_up
void door_go_up (edict_t *self, edict_t *activator)
{
	if (self->moveinfo.state == STATE_UP)
		return;		// already going up

	if (self->moveinfo.state == STATE_TOP)
	{	// reset top wait time
		if (self->moveinfo.wait >= 0)
			self->nextthink = level.time + self->moveinfo.wait;
		return;
	}
	
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_start)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_start, 1, ATTN_STATIC, 0);
		self->s.sound = self->moveinfo.sound_middle;
	}
	self->moveinfo.state = STATE_UP;
	if (strcmp(self->classname, "func_door") == 0)
		Move_Calc (self, self->moveinfo.end_origin, door_hit_top);
	else if (strcmp(self->classname, "func_door_rotating") == 0)
		AngleMove_Calc (self, door_hit_top);

	G_UseTargets (self, activator);
	door_use_areaportals (self, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x388(%rdi), %eax
cmpl $0x2, %eax
je 0x2d76b
movq %rdi, %rbx
testl %eax, %eax
jne 0x2d771
movss 0x384(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2d76b
movq 0x3b642(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r14
testb $0x4, 0x11d(%rbx)
jne 0x2d7b5
movl 0x368(%rbx), %edx
testl %edx, %edx
je 0x2d7ac
movq 0x3ae72(%rip), %rax     # 0x68600
movss 0x25792(%rip), %xmm0    # 0x52f28
movss 0x25772(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl 0x36c(%rbx), %eax
movl %eax, 0x4c(%rbx)
movl $0x2, 0x388(%rbx)
movq 0x138(%rbx), %r15
leaq 0x285a5(%rip), %rsi     # 0x55d72
movq %r15, %rdi
callq 0x18b20
testl %eax, %eax
je 0x2d7fd
leaq 0x2859c(%rip), %rsi     # 0x55d7c
movq %r15, %rdi
callq 0x18b20
testl %eax, %eax
jne 0x2d813
movq 0x3b0b5(%rip), %rsi     # 0x688a8
movq %rbx, %rdi
callq 0x182d0
jmp 0x2d813
leaq 0x350(%rbx), %rsi
movq 0x3b09d(%rip), %rdx     # 0x688a8
movq %rbx, %rdi
callq 0x18e70
movq %rbx, %rdi
movq %r14, %rsi
callq 0x198e0
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x18230
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_use
void door_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t	*ent;

	if (self->flags & FL_TEAMSLAVE)
		return;

	if (self->spawnflags & DOOR_TOGGLE)
	{
		if (self->moveinfo.state == STATE_UP || self->moveinfo.state == STATE_TOP)
		{
			// trigger all paired doors
			for (ent = self ; ent ; ent = ent->teamchain)
			{
				ent->message = NULL;
				ent->touch = NULL;
				door_go_down (ent);
			}
			return;
		}
	}
	
	// trigger all paired doors
	for (ent = self ; ent ; ent = ent->teamchain)
	{
		ent->message = NULL;
		ent->touch = NULL;
		door_go_up (ent, activator);
	}
}

// Assembly:
testb $0x4, 0x11d(%rdi)
jne 0x2d8ad
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x20, 0x140(%rdi)
je 0x2d87f
testl $0xfffffffd, 0x388(%rbx) # imm = 0xFFFFFFFD
jne 0x2d87f
xorl %r14d, %r14d
movq %r14, 0x130(%rbx)
movq %r14, 0x220(%rbx)
movq %rbx, %rdi
callq 0x19b48
movq 0x2c8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2d85b
jmp 0x2d8a6
xorl %eax, %eax
movq %rax, 0x130(%rbx)
movq %rax, 0x220(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x187b0
movq 0x2c8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2d87f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Touch_DoorTrigger
void Touch_DoorTrigger (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (other->health <= 0)
		return;

	if (!(other->svflags & SVF_MONSTER) && (!other->client))
		return;

	if ((self->owner->spawnflags & DOOR_NOMONSTER) && (other->svflags & SVF_MONSTER))
		return;

	if (level.time < self->touch_debounce_time)
		return;
	self->touch_debounce_time = level.time + 1.0;

	door_use (self->owner, other, other);
}

// Assembly:
cmpl $0x0, 0x254(%rsi)
jle 0x2d8f9
testb $0x4, 0xc8(%rsi)
jne 0x2d8d0
cmpq $0x0, 0x58(%rsi)
je 0x2d8f9
movq 0x110(%rdi), %rax
jmp 0x2d8e0
movq 0x110(%rdi), %rax
testb $0x8, 0x140(%rax)
jne 0x2d8f9
movq 0x3b4b9(%rip), %rcx     # 0x68da0
movss 0x4(%rcx), %xmm0
movss 0x240(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2d8fa
retq
addss 0x25626(%rip), %xmm0    # 0x52f28
movss %xmm0, 0x240(%rdi)
movq %rax, %rdi
movq %rsi, %rdx
jmp 0x19ae8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Think_CalcMoveSpeed
void Think_CalcMoveSpeed (edict_t *self)
{
	edict_t	*ent;
	float	min;
	float	time;
	float	newspeed;
	float	ratio;
	float	dist;

	if (self->flags & FL_TEAMSLAVE)
		return;		// only the team master does this

	// find the smallest distance any member of the team will be moving
	min = fabs(self->moveinfo.distance);
	for (ent = self->teamchain; ent; ent = ent->teamchain)
	{
		dist = fabs(ent->moveinfo.distance);
		if (dist < min)
			min = dist;
	}

	time = min / self->moveinfo.speed;

	// adjust speeds so they will all complete at the same time
	for (ent = self; ent; ent = ent->teamchain)
	{
		newspeed = fabs(ent->moveinfo.distance) / time;
		ratio = newspeed / ent->moveinfo.speed;
		if (ent->moveinfo.accel == ent->moveinfo.speed)
			ent->moveinfo.accel = newspeed;
		else
			ent->moveinfo.accel *= ratio;
		if (ent->moveinfo.decel == ent->moveinfo.speed)
			ent->moveinfo.decel = newspeed;
		else
			ent->moveinfo.decel *= ratio;
		ent->moveinfo.speed = newspeed;
	}
}

// Assembly:
testb $0x4, 0x11d(%rdi)
jne 0x2d9f5
movss 0x380(%rdi), %xmm1
andps 0x2560f(%rip), %xmm1    # 0x52f40
movq 0x2c8(%rdi), %rax
testq %rax, %rax
je 0x2d964
movaps 0x255fc(%rip), %xmm2    # 0x52f40
movss 0x380(%rax), %xmm0
andps %xmm2, %xmm0
minss %xmm1, %xmm0
movq 0x2c8(%rax), %rax
movaps %xmm0, %xmm1
testq %rax, %rax
jne 0x2d944
jmp 0x2d967
movaps %xmm1, %xmm0
divss 0x378(%rdi), %xmm0
movaps 0x255ca(%rip), %xmm1    # 0x52f40
movss 0x380(%rdi), %xmm2
andps %xmm1, %xmm2
divss %xmm0, %xmm2
movss 0x378(%rdi), %xmm3
movaps %xmm2, %xmm4
divss %xmm3, %xmm4
movss 0x374(%rdi), %xmm5
movaps %xmm5, %xmm6
mulss %xmm4, %xmm6
cmpeqss %xmm3, %xmm5
movaps %xmm5, %xmm7
andps %xmm2, %xmm7
andnps %xmm6, %xmm5
orps %xmm7, %xmm5
movss %xmm5, 0x374(%rdi)
movss 0x37c(%rdi), %xmm5
mulss %xmm5, %xmm4
cmpeqss %xmm3, %xmm5
movaps %xmm5, %xmm3
andps %xmm2, %xmm3
andnps %xmm4, %xmm5
orps %xmm3, %xmm5
movss %xmm5, 0x37c(%rdi)
movss %xmm2, 0x378(%rdi)
movq 0x2c8(%rdi), %rdi
testq %rdi, %rdi
jne 0x2d976
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Think_SpawnDoorTrigger
void Think_SpawnDoorTrigger (edict_t *ent)
{
	edict_t		*other;
	vec3_t		mins, maxs;

	if (ent->flags & FL_TEAMSLAVE)
		return;		// only the team leader spawns a trigger

	VectorCopy (ent->absmin, mins);
	VectorCopy (ent->absmax, maxs);

	for (other = ent->teamchain ; other ; other=other->teamchain)
	{
		AddPointToBounds (other->absmin, mins, maxs);
		AddPointToBounds (other->absmax, mins, maxs);
	}

	// expand 
	mins[0] -= 60;
	mins[1] -= 60;
	maxs[0] += 60;
	maxs[1] += 60;

	other = G_Spawn ();
	VectorCopy (mins, other->mins);
	VectorCopy (maxs, other->maxs);
	other->owner = ent;
	other->solid = SOLID_TRIGGER;
	other->movetype = MOVETYPE_NONE;
	other->touch = Touch_DoorTrigger;
	gi.linkentity (other);

	if (ent->spawnflags & DOOR_START_OPEN)
		door_use_areaportals (ent, true);

	Think_CalcMoveSpeed (ent);
}

// Assembly:
testb $0x4, 0x11d(%rdi)
jne 0x2db4f
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movsd 0xe4(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
movss 0xec(%rdi), %xmm1
movss %xmm1, 0x20(%rsp)
movsd 0xf0(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
movss 0xf8(%rdi), %xmm2
movss %xmm2, 0x10(%rsp)
movq 0x2c8(%rdi), %r12
testq %r12, %r12
je 0x2da9e
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0xe4(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x18c20
leaq 0xf0(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x18c20
movq 0x2c8(%r12), %r12
testq %r12, %r12
jne 0x2da5f
movsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addps 0x2823b(%rip), %xmm0    # 0x55ce0
movlps %xmm0, 0x18(%rsp)
addps 0x2823f(%rip), %xmm1    # 0x55cf0
movlps %xmm1, 0x8(%rsp)
callq 0x19700
movsd 0x1c(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movss 0x8(%rsp), %xmm2
shufps $0xd4, %xmm0, %xmm2     # xmm2 = xmm2[0,1],xmm0[1,3]
shufps $0x28, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[2,0]
movups %xmm1, 0xcc(%rax)
movsd 0xc(%rsp), %xmm0
movsd %xmm0, 0xdc(%rax)
movq %rbx, 0x110(%rax)
movl $0x1, 0x108(%rax)
movl $0x0, 0x118(%rax)
movq 0x3b3d1(%rip), %rcx     # 0x68ee0
movq %rcx, 0x220(%rax)
movq 0x3aae3(%rip), %rcx     # 0x68600
movq %rax, %rdi
callq *0x90(%rcx)
testb $0x1, 0x140(%rbx)
je 0x2db3c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x18230
movq %rbx, %rdi
callq 0x19b38
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_blocked
void door_blocked  (edict_t *self, edict_t *other)
{
	edict_t	*ent;

	if (!(other->svflags & SVF_MONSTER) && (!other->client) )
	{
		// give it a chance to go away on it's own terms (like gibs)
		T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, 100000, 1, 0, MOD_CRUSH);
		// if it's still there, nuke it
		if (other)
			BecomeExplosion1 (other);
		return;
	}

	T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, self->dmg, 1, 0, MOD_CRUSH);

	if (self->spawnflags & DOOR_CRUSHER)
		return;


// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
	if (self->moveinfo.wait >= 0)
	{
		if (self->moveinfo.state == STATE_DOWN)
		{
			for (ent = self->teammaster ; ent ; ent = ent->teamchain)
				door_go_up (ent, ent->activator);
		}
		else
		{
			for (ent = self->teammaster ; ent ; ent = ent->teamchain)
				door_go_down (ent);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x4, 0xc8(%rsi)
jne 0x2db6e
cmpq $0x0, 0x58(%r14)
je 0x2dbff
leaq 0x4(%r14), %r8
movl 0x280(%rbx), %eax
movq 0x3abe9(%rip), %rcx     # 0x68768
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq %rax
callq 0x190f0
addq $0x20, %rsp
testb $0x4, 0x140(%rbx)
jne 0x2dbb4
movss 0x384(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jae 0x2dbbc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x3, 0x388(%rbx)
movq 0x2d0(%rbx), %rbx
jne 0x2dbe9
testq %rbx, %rbx
je 0x2dbb4
movq 0x2b0(%rbx), %rsi
movq %rbx, %rdi
callq 0x187b0
movq 0x2c8(%rbx), %rbx
jmp 0x2dbcc
testq %rbx, %rbx
je 0x2dbb4
movq %rbx, %rdi
callq 0x19b48
movq 0x2c8(%rbx), %rbx
jmp 0x2dbe9
leaq 0x4(%r14), %r8
movq 0x3ab5e(%rip), %rcx     # 0x68768
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq $0x186a0                # imm = 0x186A0
callq 0x190f0
addq $0x20, %rsp
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x195c0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_killed
void door_killed (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	edict_t	*ent;

	for (ent = self->teammaster ; ent ; ent = ent->teamchain)
	{
		ent->health = ent->max_health;
		ent->takedamage = DAMAGE_NO;
	}
	door_use (self->teammaster, attacker, attacker);
}

// Assembly:
movq 0x2d0(%rdi), %rdi
testq %rdi, %rdi
je 0x19ae8
movq %rdi, %rax
movl 0x258(%rax), %ecx
movl %ecx, 0x254(%rax)
movl $0x0, 0x27c(%rax)
movq 0x2c8(%rax), %rax
testq %rax, %rax
jne 0x2dc4c
jmp 0x19ae8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_touch
void door_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (!other->client)
		return;

	if (level.time < self->touch_debounce_time)
		return;
	self->touch_debounce_time = level.time + 5.0;

	gi.centerprintf (other, "%s", self->message);
	gi.sound (other, CHAN_AUTO, gi.soundindex ("misc/talk1.wav"), 1, ATTN_NORM, 0);
}

// Assembly:
cmpq $0x0, 0x58(%rsi)
je 0x2dc93
movq 0x3b11f(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
movss 0x240(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2dc94
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
addss 0x25264(%rip), %xmm0    # 0x52f08
movss %xmm0, 0x240(%rdi)
movq 0x3a94d(%rip), %r14     # 0x68600
movq 0x130(%rdi), %rdx
leaq 0x24cec(%rip), %rsi     # 0x529ad
movq %rbx, %rdi
xorl %eax, %eax
callq *0x18(%r14)
movq 0x20(%r14), %r15
leaq 0x280ba(%rip), %rdi     # 0x55d8f
callq *0x48(%r14)
movss 0x25247(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: train_blocked
void train_blocked (edict_t *self, edict_t *other)
{
	if (!(other->svflags & SVF_MONSTER) && (!other->client) )
	{
		// give it a chance to go away on it's own terms (like gibs)
		T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, 100000, 1, 0, MOD_CRUSH);
		// if it's still there, nuke it
		if (other)
			BecomeExplosion1 (other);
		return;
	}

	if (level.time < self->touch_debounce_time)
		return;

	if (!self->dmg)
		return;
	self->touch_debounce_time = level.time + 0.5;
	T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, self->dmg, 1, 0, MOD_CRUSH);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rdx
testb $0x4, 0xc8(%rsi)
jne 0x2e750
cmpq $0x0, 0x58(%rbx)
je 0x2e7a9
movq 0x3a649(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
movss 0x240(%rdx), %xmm1
ucomiss %xmm0, %xmm1
ja 0x2e7a7
movl 0x280(%rdx), %eax
testl %eax, %eax
je 0x2e7a7
addss 0x25c85(%rip), %xmm0    # 0x54400
movss %xmm0, 0x240(%rdx)
leaq 0x4(%rbx), %r8
movq 0x39fda(%rip), %rcx     # 0x68768
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq %rax
callq 0x190f0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x4(%rbx), %r8
movq 0x39fb4(%rip), %rcx     # 0x68768
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq $0x186a0                # imm = 0x186A0
callq 0x190f0
addq $0x20, %rsp
movq %rbx, %rdi
popq %rbx
jmp 0x195c0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: train_wait
void train_wait (edict_t *self)
{
	if (self->target_ent->pathtarget)
	{
		char	*savetarget;
		edict_t	*ent;

		ent = self->target_ent;
		savetarget = ent->target;
		ent->target = ent->pathtarget;
		G_UseTargets (ent, self->activator);
		ent->target = savetarget;

		// make sure we didn't get killed by a killtarget
		if (!self->inuse)
			return;
	}

	if (self->moveinfo.wait)
	{
		if (self->moveinfo.wait > 0)
		{
			self->nextthink = level.time + self->moveinfo.wait;
			self->think = train_next;
		}
		else if (self->spawnflags & TRAIN_TOGGLE)  // && wait < 0
		{
			train_next (self);
			self->spawnflags &= ~TRAIN_START_ON;
			VectorClear (self->velocity);
			self->nextthink = 0;
		}

		if (!(self->flags & FL_TEAMSLAVE))
		{
			if (self->moveinfo.sound_end)
				gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_end, 1, ATTN_STATIC, 0);
			self->s.sound = 0;
		}
	}
	else
	{
		train_next (self);
	}
	
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x188(%rdi), %r14
movq 0x170(%r14), %rax
testq %rax, %rax
je 0x2e823
movq 0x150(%r14), %r15
movq %rax, 0x150(%r14)
movq 0x2b0(%rbx), %rsi
movq %r14, %rdi
callq 0x198e0
movq %r15, 0x150(%r14)
cmpl $0x0, 0x60(%rbx)
je 0x2e8d8
movss 0x384(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2e835
jnp 0x2e85b
jbe 0x2e868
movq 0x3a562(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x3a096(%rip), %rax     # 0x688e8
movq %rax, 0x210(%rbx)
jmp 0x2e899
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19ad0
testb $0x2, 0x140(%rbx)
je 0x2e899
movq %rbx, %rdi
callq 0x19ad0
andb $-0x2, 0x140(%rbx)
xorl %eax, %eax
movl %eax, 0x1c8(%rbx)
movq $0x0, 0x1c0(%rbx)
movl %eax, 0x200(%rbx)
testb $0x4, 0x11d(%rbx)
jne 0x2e8d8
movl 0x370(%rbx), %edx
testl %edx, %edx
je 0x2e8d1
movq 0x39d4d(%rip), %rax     # 0x68600
movss 0x2466d(%rip), %xmm0    # 0x52f28
movss 0x2464d(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl $0x0, 0x4c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: func_train_find
void func_train_find (edict_t *self)
{
	edict_t *ent;

	if (!self->target)
	{
		gi.dprintf ("train_find: no target\n");
		return;
	}
	ent = G_PickTarget (self->target);
	if (!ent)
	{
		gi.dprintf ("train_find: target %s not found\n", self->target);
		return;
	}
	self->target = ent->target;

	VectorSubtract (ent->s.origin, self->mins, self->s.origin);
	gi.linkentity (self);

	// if not triggered, start immediately
	if (!self->targetname)
		self->spawnflags |= TRAIN_START_ON;

	if (self->spawnflags & TRAIN_START_ON)
	{
		self->nextthink = level.time + FRAMETIME;
		self->think = train_next;
		self->activator = self;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x2ebdf
callq 0x18350
testq %rax, %rax
je 0x2ebf6
movq 0x150(%rax), %rcx
movq %rcx, 0x150(%rbx)
movss 0x4(%rax), %xmm0
subss 0xcc(%rbx), %xmm0
movss %xmm0, 0x4(%rbx)
movss 0x8(%rax), %xmm0
subss 0xd0(%rbx), %xmm0
movss %xmm0, 0x8(%rbx)
movss 0xc(%rax), %xmm0
subss 0xd4(%rbx), %xmm0
movss %xmm0, 0xc(%rbx)
movq 0x39a40(%rip), %rax     # 0x68600
movq %rbx, %rdi
callq *0x90(%rax)
cmpq $0x0, 0x158(%rbx)
movl 0x140(%rbx), %eax
je 0x2ec14
testb $0x1, %al
jne 0x2ec1d
jmp 0x2ec4e
movq 0x39a1a(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x27281(%rip), %rdi     # 0x55e72
xorl %eax, %eax
popq %rbx
jmpq *%rcx
movq 0x39a03(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
movq 0x150(%rbx), %rsi
leaq 0x2727a(%rip), %rdi     # 0x55e89
xorl %eax, %eax
popq %rbx
jmpq *%rcx
orl $0x1, %eax
movl %eax, 0x140(%rbx)
movq 0x3a17c(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x2465f(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq 0x39ca8(%rip), %rax     # 0x688e8
movq %rax, 0x210(%rbx)
movq %rbx, 0x2b0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: SP_func_train
void SP_func_train (edict_t *self)
{
	self->movetype = MOVETYPE_PUSH;

	VectorClear (self->s.angles);
	self->blocked = train_blocked;
	if (self->spawnflags & TRAIN_BLOCK_STOPS)
		self->dmg = 0;
	else
	{
		if (!self->dmg)
			self->dmg = 100;
	}
	self->solid = SOLID_BSP;
	gi.setmodel (self, self->model);

	if (st.noise)
		self->moveinfo.sound_middle = gi.soundindex  (st.noise);

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

	self->moveinfo.speed = self->speed;
	self->moveinfo.accel = self->moveinfo.decel = self->moveinfo.speed;

	self->use = train_use;

	gi.linkentity (self);

	if (self->target)
	{
		// start trains on the second frame, to make sure their targets have had
		// a chance to spawn
		self->nextthink = level.time + FRAMETIME;
		self->think = func_train_find;
	}
	else
	{
		gi.dprintf ("func_train without a target at %s\n", vtos(self->absmin));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, 0x118(%rdi)
movl $0x0, 0x18(%rdi)
movq $0x0, 0x10(%rdi)
movq 0x39f06(%rip), %rax     # 0x68bc8
movq %rax, 0x218(%rdi)
xorl %eax, %eax
testb $0x4, 0x140(%rdi)
jne 0x2ece2
cmpl $0x0, 0x280(%rbx)
jne 0x2ece8
movl $0x64, %eax
movl %eax, 0x280(%rbx)
movl $0x3, 0x108(%rbx)
movq 0x39907(%rip), %r14     # 0x68600
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
callq *0x58(%r14)
movq 0x3995a(%rip), %rax     # 0x68668
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x2ed21
callq *0x48(%r14)
movl %eax, 0x36c(%rbx)
movss 0x190(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2ed45
jp 0x2ed45
movl $0x42c80000, 0x190(%rbx) # imm = 0x42C80000
movss 0x26f07(%rip), %xmm0    # 0x55c4c
movss %xmm0, 0x378(%rbx)
movss %xmm0, 0x37c(%rbx)
movss %xmm0, 0x374(%rbx)
movq 0x396d4(%rip), %rax     # 0x68438
movq %rax, 0x228(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
cmpq $0x0, 0x150(%rbx)
je 0x2edb1
movq 0x3a01a(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x244fd(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq 0x39d9e(%rip), %rax     # 0x68b40
movq %rax, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %r14
addq $0xe4, %rbx
movq %rbx, %rdi
callq 0x190a0
leaq 0x270df(%rip), %rdi     # 0x55eaa
movq %rax, %rsi
xorl %eax, %eax
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: trigger_elevator_use
void trigger_elevator_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t *target;

	if (self->movetarget->nextthink)
	{
//		gi.dprintf("elevator busy\n");
		return;
	}

	if (!other->pathtarget)
	{
		gi.dprintf("elevator used with no pathtarget\n");
		return;
	}

	target = G_PickTarget (other->pathtarget);
	if (!target)
	{
		gi.dprintf("elevator used with bad pathtarget: %s\n", other->pathtarget);
		return;
	}

	self->movetarget->target_ent = target;
	train_resume (self->movetarget);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x1f0(%rdi), %rax
movss 0x200(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2edf9
jnp 0x2ee01
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq %rdi, %r14
movq 0x170(%rsi), %rdi
testq %rdi, %rdi
je 0x2ee37
callq 0x18350
testq %rax, %rax
je 0x2ee54
movq 0x1f0(%r14), %rdi
movq %rax, 0x188(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x198a0
movq 0x397c2(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x27084(%rip), %rdi     # 0x55ecd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movq 0x397a5(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
movq 0x170(%rbx), %rsi
leaq 0x27082(%rip), %rdi     # 0x55eef
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: trigger_elevator_init
void trigger_elevator_init (edict_t *self)
{
	if (!self->target)
	{
		gi.dprintf("trigger_elevator has no target\n");
		return;
	}
	self->movetarget = G_PickTarget (self->target);
	if (!self->movetarget)
	{
		gi.dprintf("trigger_elevator unable to find target %s\n", self->target);
		return;
	}
	if (strcmp(self->movetarget->classname, "func_train") != 0)
	{
		gi.dprintf("trigger_elevator target %s is not a train\n", self->target);
		return;
	}

	self->use = trigger_elevator_use;
	self->svflags = SVF_NOCLIENT;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x2eecb
callq 0x18350
movq %rax, 0x1f0(%rbx)
testq %rax, %rax
je 0x2eee2
movq 0x138(%rax), %rdi
leaq 0x270ba(%rip), %rsi     # 0x55f61
callq 0x18b20
testl %eax, %eax
je 0x2ef00
movq 0x39749(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
movq 0x150(%rbx), %rsi
leaq 0x270a3(%rip), %rdi     # 0x55f6c
jmp 0x2eefb
movq 0x3972e(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
leaq 0x27039(%rip), %rdi     # 0x55f16
xorl %eax, %eax
popq %rbx
jmpq *%rcx
movq 0x39717(%rip), %rax     # 0x68600
movq 0x8(%rax), %rcx
movq 0x150(%rbx), %rsi
leaq 0x2703b(%rip), %rdi     # 0x55f36
xorl %eax, %eax
popq %rbx
jmpq *%rcx
movq 0x39df1(%rip), %rax     # 0x68cf8
movq %rax, 0x228(%rbx)
movl $0x1, 0xc8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: func_timer_use
void func_timer_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->activator = activator;

	// if on, turn it off
	if (self->nextthink)
	{
		self->nextthink = 0;
		return;
	}

	// turn it on
	if (self->delay)
		self->nextthink = level.time + self->delay;
	else
		func_timer_think (self);
}

// Assembly:
movq %rdx, 0x2b0(%rdi)
movss 0x200(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2efe0
jnp 0x2efeb
movl $0x0, 0x200(%rdi)
retq
movss 0x2fc(%rdi), %xmm0
ucomiss %xmm1, %xmm0
jne 0x2effa
jnp 0x2f00f
movq 0x39d9f(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
retq
jmp 0x19aa8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: SP_func_timer
void SP_func_timer (edict_t *self)
{
	if (!self->wait)
		self->wait = 1.0;

	self->use = func_timer_use;
	self->think = func_timer_think;

	if (self->random >= self->wait)
	{
		self->random = self->wait - FRAMETIME;
		gi.dprintf("func_timer at %s has random >= wait\n", vtos(self->s.origin));
	}

	if (self->spawnflags & 1)
	{
		self->nextthink = level.time + 1.0 + st.pausetime + self->delay + self->wait + crandom() * self->random;
		self->activator = self;
	}

	self->svflags = SVF_NOCLIENT;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x2f8(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2f03f
jp 0x2f03f
movl $0x3f800000, 0x2f8(%rbx) # imm = 0x3F800000
movss 0x23ee9(%rip), %xmm0    # 0x52f28
movq 0x3959a(%rip), %rax     # 0x685e0
movq %rax, 0x228(%rbx)
movq 0x397c4(%rip), %rax     # 0x68818
movq %rax, 0x210(%rbx)
movss 0x300(%rbx), %xmm1
ucomiss %xmm0, %xmm1
jb 0x2f09b
addss 0x24bc0(%rip), %xmm0    # 0x53c30
movss %xmm0, 0x300(%rbx)
movq 0x39581(%rip), %rax     # 0x68600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x190a0
leaq 0x26f04(%rip), %rdi     # 0x55f97
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
testb $0x1, 0x140(%rbx)
je 0x2f148
movq 0x39cf1(%rip), %rax     # 0x68da0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rax), %xmm0
addsd 0x26c51(%rip), %xmm0    # 0x55d10
movq 0x395a2(%rip), %rax     # 0x68668
xorps %xmm1, %xmm1
cvtss2sd 0x38(%rax), %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd 0x2fc(%rbx), %xmm0
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x2f8(%rbx), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
callq 0x19a10
andl $0x7fff, %eax           # imm = 0x7FFF
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x2417a(%rip), %xmm0    # 0x53288
cvtss2sd %xmm0, %xmm0
addsd 0x26afe(%rip), %xmm0    # 0x55c18
addsd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x300(%rbx), %xmm1
mulsd %xmm0, %xmm1
addsd (%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, 0x200(%rbx)
movq %rbx, 0x2b0(%rbx)
movl $0x1, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: SP_func_conveyor
void SP_func_conveyor (edict_t *self)
{
	if (!self->speed)
		self->speed = 100;

	if (!(self->spawnflags & 1))
	{
		self->count = self->speed;
		self->speed = 0;
	}

	self->use = func_conveyor_use;

	gi.setmodel (self, self->model);
	self->solid = SOLID_BSP;
	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2f1bf
jp 0x2f1bf
movl $0x42c80000, 0x190(%rbx) # imm = 0x42C80000
movss 0x26a8d(%rip), %xmm0    # 0x55c4c
testb $0x1, 0x140(%rbx)
jne 0x2f1dc
cvttss2si %xmm0, %eax
movl %eax, 0x290(%rbx)
movl $0x0, 0x190(%rbx)
movq 0x39905(%rip), %rax     # 0x68ae8
movq %rax, 0x228(%rbx)
movq 0x3940f(%rip), %r14     # 0x68600
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
callq *0x58(%r14)
movl $0x3, 0x108(%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_func.c
// Function: door_secret_done
void door_secret_done (edict_t *self)
{
	if (!(self->targetname) || (self->spawnflags & SECRET_ALWAYS_SHOOT))
	{
		self->health = 0;
		self->takedamage = DAMAGE_YES;
	}
	door_use_areaportals (self, false);
}

// Assembly:
cmpq $0x0, 0x158(%rdi)
je 0x2f333
testb $0x1, 0x140(%rdi)
je 0x2f347
movl $0x0, 0x254(%rdi)
movl $0x1, 0x27c(%rdi)
xorl %esi, %esi
jmp 0x18230
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: FindItemByClassname
gitem_t	*FindItemByClassname (char *classname)
{
	int		i;
	gitem_t	*it;

	it = itemlist;
	for (i=0 ; i<game.num_items ; i++, it++)
	{
		if (!it->classname)
			continue;
		if (!Q_stricmp(it->classname, classname))
			return it;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x3964f(%rip), %r15     # 0x68d40
movl 0x61c(%r15), %eax
testl %eax, %eax
jle 0x2f730
movq %rdi, %r14
movq 0x3973a(%rip), %rbx     # 0x68e40
xorl %ebp, %ebp
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2f723
movq %r14, %rsi
callq 0x18690
testl %eax, %eax
je 0x2f732
movl 0x61c(%r15), %eax
incl %ebp
addq $0x88, %rbx
cmpl %eax, %ebp
jl 0x2f708
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: FindItem
gitem_t	*FindItem (char *pickup_name)
{
	int		i;
	gitem_t	*it;

	it = itemlist;
	for (i=0 ; i<game.num_items ; i++, it++)
	{
		if (!it->pickup_name)
			continue;
		if (!Q_stricmp(it->pickup_name, pickup_name))
			return it;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x395f2(%rip), %r15     # 0x68d40
movl 0x61c(%r15), %eax
testl %eax, %eax
jle 0x2f78e
movq %rdi, %r14
movq 0x396dd(%rip), %rbx     # 0x68e40
xorl %ebp, %ebp
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2f781
movq %r14, %rsi
callq 0x18690
testl %eax, %eax
je 0x2f790
movl 0x61c(%r15), %eax
incl %ebp
addq $0x88, %rbx
cmpl %eax, %ebp
jl 0x2f765
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: DoRespawn
void DoRespawn(edict_t* ent)
{
	if (!ent)
		return;

	if (ent->team)
	{
		edict_t* master;
		unsigned count;
		unsigned choice;

		master = ent->teammaster;
		if (master == NULL)
			return;

		count = 0;
		for (ent = master; ent; ent = ent->chain)
			count++;

		choice = count ? (rand() % count) : 0;

		count = 0;
		for (ent = master; count < choice; ent = ent->chain)
			count++;
	}

	if (ent)
	{
		ent->svflags &= ~SVF_NOCLIENT;
		ent->solid = SOLID_TRIGGER;
		gi.linkentity(ent);

		// send an effect
		ent->s.event = EV_ITEM_RESPAWN;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2f81e
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x168(%rdi)
je 0x2f7f3
movq 0x2d0(%rbx), %rbx
testq %rbx, %rbx
je 0x2f818
xorl %ebp, %ebp
movq %rbx, %rax
incl %ebp
movq 0x298(%rax), %rax
testq %rax, %rax
jne 0x2f7c4
testl %ebp, %ebp
je 0x2f7ee
callq 0x19a10
xorl %edx, %edx
divl %ebp
testl %edx, %edx
je 0x2f7ee
movq 0x298(%rbx), %rbx
decl %edx
jne 0x2f7e3
testq %rbx, %rbx
je 0x2f818
andb $-0x2, 0xc8(%rbx)
movl $0x1, %ebp
movl %ebp, 0x108(%rbx)
movq 0x38df4(%rip), %rax     # 0x68600
movq %rbx, %rdi
callq *0x90(%rax)
movl %ebp, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: SetRespawn
void SetRespawn (edict_t *ent, float delay)
{
	ent->flags |= FL_RESPAWN;
	ent->svflags |= SVF_NOCLIENT;
	ent->solid = SOLID_NOT;
	ent->nextthink = level.time + delay;
	ent->think = DoRespawn;
	gi.linkentity (ent);
}

// Assembly:
orb $-0x80, 0x11f(%rdi)
orb $0x1, 0xc8(%rdi)
movl $0x0, 0x108(%rdi)
movq 0x39562(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
movq 0x394fe(%rip), %rax     # 0x68d50
movq %rax, 0x210(%rdi)
movq 0x38da0(%rip), %rax     # 0x68600
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: Pickup_Powerup
qboolean Pickup_Powerup (edict_t *ent, edict_t *other)
{
	int		quantity;

	quantity = other->client->pers.inventory[ITEM_INDEX(ent->item)];
	if ((skill->value == 1 && quantity >= 2) || (skill->value >= 2 && quantity >= 1))
		return false;

	if ((coop->value) && (ent->item->flags & IT_STAY_COOP) && (quantity > 0))
		return false;

	other->client->pers.inventory[ITEM_INDEX(ent->item)]++;

	if (deathmatch->value)
	{
		if (!(ent->spawnflags & DROPPED_ITEM) )
			SetRespawn (ent, ent->item->quantity);
		if (((int)dmflags->value & DF_INSTANT_ITEMS) || ((ent->item->use == Use_Quad) && (ent->spawnflags & DROPPED_PLAYER_ITEM)))
		{
			if ((ent->item->use == Use_Quad) && (ent->spawnflags & DROPPED_PLAYER_ITEM))
				quad_drop_timeout_hack = (ent->nextthink - level.time) / FRAMETIME;
			ent->item->use (other, ent->item);
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x330(%rdi), %rsi
movq %rsi, %rdx
subq 0x395bf(%rip), %rdx     # 0x68e40
movq 0x58(%rbx), %rax
sarq $0x3, %rdx
movabsq $-0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F1
imulq %rdx, %rcx
movl 0x318(%rax,%rcx,4), %edx
movq 0x38e93(%rip), %rdi     # 0x68738
movq (%rdi), %rdi
movss 0x20(%rdi), %xmm0
xorl %ebp, %ebp
ucomiss 0x23672(%rip), %xmm0    # 0x52f28
jne 0x2f8c3
jp 0x2f8c3
cmpl $0x1, %edx
jg 0x2fa00
ucomiss 0x23ba2(%rip), %xmm0    # 0x5346c
jb 0x2f8d4
testl %edx, %edx
jg 0x2fa00
movq 0x39685(%rip), %rdi     # 0x68f60
movq (%rdi), %rdi
movss 0x20(%rdi), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0x2f8ed
jnp 0x2f8fb
testb $0x8, 0x68(%rsi)
je 0x2f8fb
testl %edx, %edx
jg 0x2fa00
incl %edx
movl %edx, 0x318(%rax,%rcx,4)
movq 0x395b5(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm1
movl $0x1, %ebp
ucomiss %xmm0, %xmm1
jne 0x2f923
jnp 0x2fa00
testb $0x1, 0x142(%r14)
jne 0x2f98d
xorps %xmm0, %xmm0
cvtsi2ssl 0x5c(%rsi), %xmm0
orl $0x80000000, 0x11c(%r14) # imm = 0x80000000
orb $0x1, 0xc8(%r14)
movl $0x0, 0x108(%r14)
movq 0x39446(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%r14)
movq 0x393e1(%rip), %rax     # 0x68d50
movq %rax, 0x210(%r14)
movq 0x38c83(%rip), %rax     # 0x68600
movq %r14, %rdi
callq *0x90(%rax)
movq 0x330(%r14), %rsi
movq 0x38c84(%rip), %rax     # 0x68618
movq (%rax), %rax
cvttss2si 0x20(%rax), %ecx
movq 0x10(%rsi), %rax
testb $0x10, %cl
jne 0x2f9ba
cmpq 0x38fcc(%rip), %rax     # 0x68978
jne 0x2fa00
testb $0x2, 0x142(%r14)
jne 0x2f9c3
jmp 0x2fa00
cmpq 0x38fb7(%rip), %rax     # 0x68978
jne 0x2f9fb
movq 0x38fae(%rip), %rax     # 0x68978
testb $0x2, 0x142(%r14)
je 0x2f9fb
movss 0x200(%r14), %xmm0
movq 0x393bc(%rip), %rcx     # 0x68da0
subss 0x4(%rcx), %xmm0
divss 0x2389f(%rip), %xmm0    # 0x53290
cvttss2si %xmm0, %ecx
movl %ecx, 0x43145(%rip)     # 0x72b40
movq %rbx, %rdi
callq *%rax
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: Use_Quad
void Use_Quad (edict_t *ent, gitem_t *item)
{
	int		timeout;

	ent->client->pers.inventory[ITEM_INDEX(item)]--;
	ValidateSelectedItem (ent);

	if (quad_drop_timeout_hack)
	{
		timeout = quad_drop_timeout_hack;
		quad_drop_timeout_hack = 0;
	}
	else
	{
		timeout = 300;
	}

	if (ent->client->quad_framenum > level.framenum)
		ent->client->quad_framenum += timeout;
	else
		ent->client->quad_framenum = level.framenum + timeout;

	gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage.wav"), 1, ATTN_NORM, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
subq 0x39427(%rip), %rsi     # 0x68e40
sarq $0x3, %rsi
movabsq $-0x3c3c3c3c3c3c3c3c, %rcx # imm = 0xC3C3C3C3C3C3C3C4
imulq %rsi, %rcx
decl 0x318(%rax,%rcx)
callq 0x18280
movl 0x43103(%rip), %eax     # 0x72b40
testl %eax, %eax
je 0x2fa4d
movl $0x0, 0x430f5(%rip)     # 0x72b40
jmp 0x2fa52
movl $0x12c, %eax            # imm = 0x12C
movq 0x58(%rbx), %rcx
movq 0x39343(%rip), %rdx     # 0x68da0
movl (%rdx), %edx
cvtsi2ss %edx, %xmm0
addl %eax, %edx
cvtsi2ss %edx, %xmm1
movss 0xf04(%rcx), %xmm2
cvtsi2ss %eax, %xmm3
addss %xmm2, %xmm3
cmpltss %xmm2, %xmm0
andps %xmm0, %xmm3
andnps %xmm1, %xmm0
orps %xmm3, %xmm0
movss %xmm0, 0xf04(%rcx)
movq 0x38b6a(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
leaq 0x26555(%rip), %rdi     # 0x55ff6
callq *0x48(%rax)
movss 0x2347c(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x3, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: Pickup_Adrenaline
qboolean Pickup_Adrenaline (edict_t *ent, edict_t *other)
{
	if (!deathmatch->value)
		other->max_health += 1;

	if (other->health < other->max_health)
		other->health = other->max_health;

	if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
		SetRespawn (ent, ent->item->quantity);

	return true;
}

// Assembly:
movq 0x391b3(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movl 0x258(%rsi), %eax
jne 0x2fd2d
jp 0x2fd2d
incl %eax
movl %eax, 0x258(%rsi)
cmpl %eax, 0x254(%rsi)
jge 0x2fd3b
movl %eax, 0x254(%rsi)
ucomiss %xmm1, %xmm0
jne 0x2fd42
jnp 0x2fdad
movl $0x10000, %eax          # imm = 0x10000
andl 0x140(%rdi), %eax
jne 0x2fdad
pushq %rax
movq 0x330(%rdi), %rax
xorps %xmm0, %xmm0
cvtsi2ssl 0x5c(%rax), %xmm0
orl $0x80000000, 0x11c(%rdi) # imm = 0x80000000
orb $0x1, 0xc8(%rdi)
movl $0x0, 0x108(%rdi)
movq 0x3901f(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
movq 0x38fbb(%rip), %rax     # 0x68d50
movq %rax, 0x210(%rdi)
movq 0x3885d(%rip), %rax     # 0x68600
callq *0x90(%rax)
addq $0x8, %rsp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: Pickup_AncientHead
qboolean Pickup_AncientHead (edict_t *ent, edict_t *other)
{
	other->max_health += 2;

	if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
		SetRespawn (ent, ent->item->quantity);

	return true;
}

// Assembly:
addl $0x2, 0x258(%rsi)
testb $0x1, 0x142(%rdi)
jne 0x2fe3a
movq 0x390f6(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2fddc
jnp 0x2fe3a
pushq %rax
movq 0x330(%rdi), %rax
xorps %xmm0, %xmm0
cvtsi2ssl 0x5c(%rax), %xmm0
orl $0x80000000, 0x11c(%rdi) # imm = 0x80000000
orb $0x1, 0xc8(%rdi)
movl $0x0, 0x108(%rdi)
movq 0x38f92(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rdi)
movq 0x38f2e(%rip), %rax     # 0x68d50
movq %rax, 0x210(%rdi)
movq 0x387d0(%rip), %rax     # 0x68600
callq *0x90(%rax)
addq $0x8, %rsp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: Pickup_Bandolier
qboolean Pickup_Bandolier (edict_t *ent, edict_t *other)
{
	gitem_t	*item;
	int		index;

	if (other->client->pers.max_bullets < 250)
		other->client->pers.max_bullets = 250;
	if (other->client->pers.max_shells < 150)
		other->client->pers.max_shells = 150;
	if (other->client->pers.max_cells < 250)
		other->client->pers.max_cells = 250;
	if (other->client->pers.max_slugs < 75)
		other->client->pers.max_slugs = 75;

	item = FindItem("Bullets");
	if (item)
	{
		index = ITEM_INDEX(item);
		other->client->pers.inventory[index] += item->quantity;
		if (other->client->pers.inventory[index] > other->client->pers.max_bullets)
			other->client->pers.inventory[index] = other->client->pers.max_bullets;
	}

	item = FindItem("Shells");
	if (item)
	{
		index = ITEM_INDEX(item);
		other->client->pers.inventory[index] += item->quantity;
		if (other->client->pers.inventory[index] > other->client->pers.max_shells)
			other->client->pers.inventory[index] = other->client->pers.max_shells;
	}

	if (!(ent->spawnflags & DROPPED_ITEM) && (deathmatch->value))
		SetRespawn (ent, ent->item->quantity);

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rsi), %rax
cmpl $0xf9, 0x718(%rax)
jg 0x2fe64
movl $0xfa, 0x718(%rax)
cmpl $0x95, 0x71c(%rax)
jg 0x2fe7a
movl $0x96, 0x71c(%rax)
cmpl $0xf9, 0x728(%rax)
jg 0x2fe90
movl $0xfa, 0x728(%rax)
cmpl $0x4a, 0x72c(%rax)
jg 0x2fea3
movl $0x4b, 0x72c(%rax)
leaq 0x26126(%rip), %rdi     # 0x55fd0
callq 0x189e0
testq %rax, %rax
je 0x2fef2
movq %rax, %rcx
subq 0x38f82(%rip), %rcx     # 0x68e40
shrq $0x3, %rcx
imull $0xf0f0f0f1, %ecx, %ecx # imm = 0xF0F0F0F1
movq 0x58(%r14), %rdx
movslq %ecx, %rcx
movl 0x318(%rdx,%rcx,4), %esi
addl 0x5c(%rax), %esi
movl %esi, 0x318(%rdx,%rcx,4)
movl 0x718(%rdx), %eax
cmpl %eax, %esi
cmovgel %eax, %esi
movl %esi, 0x318(%rdx,%rcx,4)
leaq 0x260df(%rip), %rdi     # 0x55fd8
callq 0x189e0
testq %rax, %rax
je 0x2ff41
movq %rax, %rcx
subq 0x38f33(%rip), %rcx     # 0x68e40
shrq $0x3, %rcx
imull $0xf0f0f0f1, %ecx, %ecx # imm = 0xF0F0F0F1
movq 0x58(%r14), %rdx
movslq %ecx, %rcx
movl 0x318(%rdx,%rcx,4), %esi
addl 0x5c(%rax), %esi
movl %esi, 0x318(%rdx,%rcx,4)
movl 0x71c(%rdx), %eax
cmpl %eax, %esi
cmovgel %eax, %esi
movl %esi, 0x318(%rdx,%rcx,4)
testb $0x1, 0x142(%rbx)
jne 0x2ffbf
movq 0x38f6f(%rip), %rax     # 0x68ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2ff63
jnp 0x2ffbf
movq 0x330(%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2ssl 0x5c(%rax), %xmm0
orl $0x80000000, 0x11c(%rbx) # imm = 0x80000000
orb $0x1, 0xc8(%rbx)
movl $0x0, 0x108(%rbx)
movq 0x38e0c(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x38da8(%rip), %rax     # 0x68d50
movq %rax, 0x210(%rbx)
movq 0x3864a(%rip), %rax     # 0x68600
movq %rbx, %rdi
callq *0x90(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_items.c
// Function: Use_Invulnerability
void	Use_Invulnerability (edict_t *ent, gitem_t *item)
{
	ent->client->pers.inventory[ITEM_INDEX(item)]--;
	ValidateSelectedItem (ent);

	if (ent->client->invincible_framenum > level.framenum)
		ent->client->invincible_framenum += 300;
	else
		ent->client->invincible_framenum = level.framenum + 300;

	gi.sound(ent, CHAN_ITEM, gi.soundindex("items/protect.wav"), 1, ATTN_NORM, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
subq 0x38a94(%rip), %rsi     # 0x68e40
sarq $0x3, %rsi
movabsq $-0x3c3c3c3c3c3c3c3c, %rcx # imm = 0xC3C3C3C3C3C3C3C4
imulq %rsi, %rcx
decl 0x318(%rax,%rcx)
callq 0x18280
movq 0x58(%rbx), %rax
movss 0xf08(%rax), %xmm0
movq 0x389c3(%rip), %rcx     # 0x68da0
movl (%rcx), %ecx
cvtsi2ss %ecx, %xmm1
addl $0x12c, %ecx            # imm = 0x12C
cvtsi2ss %ecx, %xmm2
cmpltss %xmm0, %xmm1
addss 0x25bc2(%rip), %xmm0    # 0x55fbc
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movss %xmm1, 0xf08(%rax)
movq 0x381ee(%rip), %rax     # 0x68600
movq 0x20(%rax), %r14
leaq 0x25bea(%rip), %rdi     # 0x56007
callq *0x48(%rax)
movss 0x22b00(%rip), %xmm0    # 0x52f28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0x3, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax