LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_hud.c
// Function: HelpComputer
void HelpComputer (edict_t *ent)
{
	char	string[1024];
	char	*sk;

	if (skill->value == 0)
		sk = "easy";
	else if (skill->value == 1)
		sk = "medium";
	else if (skill->value == 2)
		sk = "hard";
	else
		sk = "hard+";

	// send the layout
	Com_sprintf (string, sizeof(string),
		"xv 32 yv 8 picn help "			// background
		"xv 202 yv 12 string2 \"%s\" "		// skill
		"xv 0 yv 24 cstring2 \"%s\" "		// level name
		"xv 0 yv 54 cstring2 \"%s\" "		// help 1
		"xv 0 yv 110 cstring2 \"%s\" "		// help 2
		"xv 50 yv 164 string2 \" kills     goals    secrets\" "
		"xv 50 yv 172 string2 \"%3i/%3i     %i/%i       %i/%i\" ", 
		sk,
		level.level_name,
		game.helpmessage1,
		game.helpmessage2,
		level.killed_monsters, level.total_monsters, 
		level.found_goals, level.total_goals,
		level.found_secrets, level.total_secrets);

	gi.WriteByte (svc_layout);
	gi.WriteString (string);
	gi.unicast (ent, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x28(%rbp)
movq 0x2222b(%rip), %rax     # 0x82738
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6052f
jp 0x6052f
leaq 0x171bf(%rip), %rax     # 0x776e5
movq %rax, -0x438(%rbp)
jmp 0x6059d
movq 0x22202(%rip), %rax     # 0x82738
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movss 0xf9a6(%rip), %xmm1     # 0x6feec
ucomiss %xmm1, %xmm0
jne 0x6055d
jp 0x6055d
leaq 0x17196(%rip), %rax     # 0x776ea
movq %rax, -0x438(%rbp)
jmp 0x6059b
movq 0x221d4(%rip), %rax     # 0x82738
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movss 0xf974(%rip), %xmm1     # 0x6fee8
ucomiss %xmm1, %xmm0
jne 0x6058b
jp 0x6058b
leaq 0x12b18(%rip), %rax     # 0x7309a
movq %rax, -0x438(%rbp)
jmp 0x60599
leaq 0x1715f(%rip), %rax     # 0x776f1
movq %rax, -0x438(%rbp)
jmp 0x6059b
jmp 0x6059d
leaq -0x430(%rbp), %rdi
movq -0x438(%rbp), %rcx
movq 0x227ee(%rip), %rax     # 0x82da0
movl 0x144(%rax), %r15d
movq 0x227e0(%rip), %rax     # 0x82da0
movl 0x140(%rax), %r14d
movq 0x227d2(%rip), %rax     # 0x82da0
movl 0x13c(%rax), %ebx
movq 0x227c5(%rip), %rax     # 0x82da0
movl 0x138(%rax), %r11d
movq 0x227b7(%rip), %rax     # 0x82da0
movl 0x134(%rax), %r10d
movq 0x227a9(%rip), %rax     # 0x82da0
movl 0x130(%rax), %eax
movl $0x400, %esi            # imm = 0x400
leaq 0x170ee(%rip), %rdx     # 0x776f7
movq 0x22790(%rip), %r8      # 0x82da0
addq $0x8, %r8
movq 0x22725(%rip), %r9      # 0x82d40
movq %r9, %r12
addq $0x200, %r12            # imm = 0x200
movq %r12, (%rsp)
movl %r15d, 0x8(%rsp)
movl %r14d, 0x10(%rsp)
movl %ebx, 0x18(%rsp)
movl %r11d, 0x20(%rsp)
movl %r10d, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movb $0x0, %al
callq 0x18f90
movl $0x4, %edi
movq 0x21fa8(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x21f9b(%rip), %rax     # 0x82600
movq 0xe8(%rax), %rax
leaq -0x430(%rbp), %rdi
callq *%rax
movq 0x21f84(%rip), %rax     # 0x82600
movq 0xb8(%rax), %rax
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq *%rax
addq $0x450, %rsp            # imm = 0x450
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_hud.c
// Function: Cmd_Help_f
void Cmd_Help_f (edict_t *ent)
{
	// this is for backwards compatability
	if (deathmatch->value)
	{
		Cmd_Score_f (ent);
		return;
	}

	ent->client->showinventory = false;
	ent->client->showscores = false;
    ent->client->showctfhud = false;
    ent->client->showmod = false;
    ent->client->showmenu = false;
	ent->client->showsquadboard = false; // ADC

	if (ent->client->showhelp && (ent->client->pers.game_helpchanged == game.helpchanged))
	{
		ent->client->showhelp = false;
		return;
	}

	ent->client->showhelp = true;
	ent->client->pers.helpchanged = 0;
	HelpComputer (ent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2280d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x606c7
jp 0x606c7
jmp 0x606d5
movq -0x8(%rbp), %rdi
callq 0x19700
jmp 0x607b0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xe28(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xe24(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xf78(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xf74(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xf80(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xe34(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0xe2c(%rax)
je 0x60783
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x748(%rax), %eax
movq 0x225d9(%rip), %rcx     # 0x82d40
cmpl 0x400(%rcx), %eax
jne 0x60783
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xe2c(%rax)
jmp 0x607b0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0xe2c(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0x74c(%rax)
movq -0x8(%rbp), %rdi
callq 0x181c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_hud.c
// Function: G_CheckChaseStats
void G_CheckChaseStats (edict_t *ent)
{
	int i;
	gclient_t *cl;

	for (i = 1; i <= maxclients->value; i++) {
		cl = g_edicts[i].client;
		if (!g_edicts[i].inuse || cl->chase_target != ent)
			continue;
		memcpy(cl->ps.stats, ent->client->ps.stats, sizeof(cl->ps.stats));
		G_SetSpectatorStats(g_edicts + i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cvtsi2ssl -0xc(%rbp), %xmm1
movq 0x20da1(%rip), %rax     # 0x82530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x6183a
movq 0x20db1(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x20d91(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
cmpl $0x0, 0x60(%rax)
je 0x617ef
movq -0x18(%rbp), %rax
movq 0xf30(%rax), %rax
cmpq -0x8(%rbp), %rax
je 0x617f1
jmp 0x6182c
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
addq $0x78, %rsi
movl $0x40, %edx
callq 0x18dc0
movq 0x20d42(%rip), %rax     # 0x82558
movq (%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x4a8, %rax, %rax      # imm = 0x4A8
addq %rax, %rdi
callq 0x196f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x61783
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_hud.c
// Function: G_SetSpectatorStats
void G_SetSpectatorStats (edict_t *ent)
{
	gclient_t *cl = ent->client;

	if (!cl->chase_target)
		G_SetStats (ent);

	cl->ps.stats[STAT_SPECTATOR] = 1;

	// layouts are independant in spectator
	cl->ps.stats[STAT_LAYOUTS] = 0;
	//if (cl->pers.health <= 0 || level.intermissiontime || cl->showscores)
//	if (cl->pers.health <= 0 || level.intermissiontime || cl->showscores || cl->showmenu)
	
	//bat - I think that cl->pers.health is only supposed to be checked in deathmatch
	
	if(level.intermissiontime || cl->showscores || cl->showmenu)
		cl->ps.stats[STAT_LAYOUTS] |= 1;
	if (cl->showinventory && cl->pers.health > 0)
		cl->ps.stats[STAT_LAYOUTS] |= 2;

	if (cl->chase_target && cl->chase_target->inuse)
		cl->ps.stats[STAT_CHASE] = CS_PLAYERSKINS + 
			(cl->chase_target - g_edicts) - 1;
	else
		cl->ps.stats[STAT_CHASE] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf30(%rax)
jne 0x6186f
movq -0x8(%rbp), %rdi
callq 0x19a60
movq -0x10(%rbp), %rax
movw $0x1, 0x9a(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x92(%rax)
movq 0x21510(%rip), %rax     # 0x82da0
movss 0xc8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x618bc
jp 0x618bc
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe24(%rax)
jne 0x618bc
movq -0x10(%rbp), %rax
cmpl $0x0, 0xf80(%rax)
je 0x618d1
movq -0x10(%rbp), %rax
movswl 0x92(%rax), %ecx
orl $0x1, %ecx
movw %cx, 0x92(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe28(%rax)
je 0x61900
movq -0x10(%rbp), %rax
cmpl $0x0, 0x308(%rax)
jle 0x61900
movq -0x10(%rbp), %rax
movswl 0x92(%rax), %ecx
orl $0x2, %ecx
movw %cx, 0x92(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf30(%rax)
je 0x6195b
movq -0x10(%rbp), %rax
movq 0xf30(%rax), %rax
cmpl $0x0, 0x60(%rax)
je 0x6195b
movq -0x10(%rbp), %rax
movq 0xf30(%rax), %rax
movq 0x20c27(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x4a8, %ecx            # imm = 0x4A8
cqto
idivq %rcx
addq $0x520, %rax            # imm = 0x520
subq $0x1, %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x98(%rax)
jmp 0x61968
movq -0x10(%rbp), %rax
movw $0x0, 0x98(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_trail.c
// Function: PlayerTrail_Init
void PlayerTrail_Init (void)
{
	int		n;

	if (deathmatch->value /* FIXME || coop */)
		return;

	for (n = 0; n < TRAIL_LENGTH; n++)
	{
		trail[n] = G_Spawn();
		trail[n]->classname = "player_trail";
	}

	trail_head = 0;
	trail_active = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x21541(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x61993
jp 0x61993
jmp 0x61995
jmp 0x619fb
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x619e1
callq 0x19950
movq %rax, %rdx
movslq -0x4(%rbp), %rcx
movq 0x21143(%rip), %rax     # 0x82af8
movq %rdx, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
movq 0x21134(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
leaq 0x15e30(%rip), %rcx     # 0x777ff
movq %rcx, 0x138(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x6199c
movq 0x215f0(%rip), %rax     # 0x82fd8
movl $0x0, (%rax)
movq 0x213eb(%rip), %rax     # 0x82de0
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_trail.c
// Function: PlayerTrail_Add
void PlayerTrail_Add (vec3_t spot)
{
	vec3_t	temp;

	if (!trail_active)
		return;

	VectorCopy (spot, trail[trail_head]->s.origin);

	trail[trail_head]->timestamp = level.time;

	VectorSubtract (spot, trail[PREV(trail_head)]->s.origin, temp);
	trail[trail_head]->s.angles[1] = vectoyaw (temp);

	trail_head = NEXT(trail_head);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x213bd(%rip), %rax     # 0x82de0
cmpl $0x0, (%rax)
jne 0x61a2d
jmp 0x61b88
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq 0x2159c(%rip), %rax     # 0x82fd8
movslq (%rax), %rcx
movq 0x210b2(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq 0x21579(%rip), %rax     # 0x82fd8
movslq (%rax), %rcx
movq 0x2108f(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq 0x21556(%rip), %rax     # 0x82fd8
movslq (%rax), %rcx
movq 0x2106c(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss %xmm0, 0xc(%rax)
movq 0x21304(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq 0x21530(%rip), %rax     # 0x82fd8
movslq (%rax), %rcx
movq 0x21046(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss %xmm0, 0x144(%rax)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movq 0x2150b(%rip), %rax     # 0x82fd8
movl (%rax), %eax
subl $0x1, %eax
andl $0x7, %eax
movslq %eax, %rcx
movq 0x21019(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
subss 0x4(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq 0x214db(%rip), %rax     # 0x82fd8
movl (%rax), %eax
subl $0x1, %eax
andl $0x7, %eax
movslq %eax, %rcx
movq 0x20fe9(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
subss 0x8(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq 0x214ab(%rip), %rax     # 0x82fd8
movl (%rax), %eax
subl $0x1, %eax
andl $0x7, %eax
movslq %eax, %rcx
movq 0x20fb9(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x18070
movq 0x2147b(%rip), %rax     # 0x82fd8
movslq (%rax), %rcx
movq 0x20f91(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss %xmm0, 0x14(%rax)
movq 0x21461(%rip), %rax     # 0x82fd8
movl (%rax), %ecx
addl $0x1, %ecx
andl $0x7, %ecx
movq 0x21452(%rip), %rax     # 0x82fd8
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_trail.c
// Function: PlayerTrail_New
void PlayerTrail_New (vec3_t spot)
{
	if (!trail_active)
		return;

	PlayerTrail_Init ();
	PlayerTrail_Add (spot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2123d(%rip), %rax     # 0x82de0
cmpl $0x0, (%rax)
jne 0x61baa
jmp 0x61bb8
callq 0x18bb0
movq -0x8(%rbp), %rdi
callq 0x18670
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_trail.c
// Function: PlayerTrail_PickFirst
edict_t *PlayerTrail_PickFirst (edict_t *self)
{
	int		marker;
	int		n;

	if (!trail_active)
		return NULL;

	for (marker = trail_head, n = TRAIL_LENGTH; n; n--)
	{
		if(trail[marker]->timestamp <= self->monsterinfo.trail_time)
			marker = NEXT(marker);
		else
			break;
	}

#ifdef MONSTERS_OK
	if (visible(self, trail[marker]))
	{
		return trail[marker];
	}

	if (visible(self, trail[PREV(marker)]))
	{
		return trail[PREV(marker)];
	}
#endif
	return trail[marker];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x21211(%rip), %rax     # 0x82de0
cmpl $0x0, (%rax)
jne 0x61bde
movq $0x0, -0x8(%rbp)
jmp 0x61c4f
movq 0x213f3(%rip), %rax     # 0x82fd8
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x8, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x61c3c
movslq -0x14(%rbp), %rcx
movq 0x20ef6(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss 0x144(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x438(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x61c2d
movl -0x14(%rbp), %eax
addl $0x1, %eax
andl $0x7, %eax
movl %eax, -0x14(%rbp)
jmp 0x61c2f
jmp 0x61c3c
jmp 0x61c31
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61bf1
movslq -0x14(%rbp), %rcx
movq 0x20eb1(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_trail.c
// Function: PlayerTrail_PickNext
edict_t *PlayerTrail_PickNext (edict_t *self)
{
	int		marker;
	int		n;

	if (!trail_active)
		return NULL;

	for (marker = trail_head, n = TRAIL_LENGTH; n; n--)
	{
		if(trail[marker]->timestamp <= self->monsterinfo.trail_time)
			marker = NEXT(marker);
		else
			break;
	}

	return trail[marker];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x21171(%rip), %rax     # 0x82de0
cmpl $0x0, (%rax)
jne 0x61c7e
movq $0x0, -0x8(%rbp)
jmp 0x61cef
movq 0x21353(%rip), %rax     # 0x82fd8
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x8, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x61cdc
movslq -0x14(%rbp), %rcx
movq 0x20e56(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movss 0x144(%rax), %xmm1
movq -0x10(%rbp), %rax
movss 0x438(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x61ccd
movl -0x14(%rbp), %eax
addl $0x1, %eax
andl $0x7, %eax
movl %eax, -0x14(%rbp)
jmp 0x61ccf
jmp 0x61cdc
jmp 0x61cd1
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61c91
movslq -0x14(%rbp), %rcx
movq 0x20e11(%rip), %rax     # 0x82af8
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_view.c
// Function: SV_CalcRoll
float SV_CalcRoll (vec3_t angles, vec3_t velocity)
{
	float	sign;
	float	side;
	float	value;
	
	side = DotProduct (velocity, right);
	sign = side < 0 ? -1 : 1;
	side = fabs(side);
	
	value = sv_rollangle->value;

	if (side < sv_rollspeed->value)
		side = side * value / sv_rollspeed->value;
	else
		side = value;
	
	return side*sign;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
movss 0x514cc(%rip), %xmm2    # 0xb3218
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss 0x514bf(%rip), %xmm0    # 0xb321c
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0x514aa(%rip), %xmm2    # 0xb3220
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm1
xorps %xmm0, %xmm0
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
ucomiss %xmm1, %xmm0
cmoval %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x10dec(%rip), %xmm1    # 0x72ba0
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movq 0x20d80(%rip), %rax     # 0x82b48
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x18(%rbp), %xmm1
movq 0x20fd7(%rip), %rax     # 0x82db8
movq (%rax), %rax
movss 0x20(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x61e0e
movss -0x18(%rbp), %xmm0
mulss -0x1c(%rbp), %xmm0
movq 0x20fb9(%rip), %rax     # 0x82db8
movq (%rax), %rax
divss 0x20(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
jmp 0x61e18
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_view.c
// Function: SV_AddBlend
void SV_AddBlend (float r, float g, float b, float a, float *v_blend)
{
	float	a2, a3;

	if (a <= 0)
		return;
	a2 = v_blend[3] + (1-v_blend[3])*a;	// new total alpha
	a3 = v_blend[3]/a2;		// fraction of color from old

	v_blend[0] = v_blend[0]*a3 + r*(1-a3);
	v_blend[1] = v_blend[1]*a3 + g*(1-a3);
	v_blend[2] = v_blend[2]*a3 + b*(1-a3);
	v_blend[3] = a2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jb 0x62f1a
jmp 0x63004
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0xcfbd(%rip), %xmm0     # 0x6feec
subss 0xc(%rax), %xmm0
movss -0x10(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
divss -0x1c(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss -0x20(%rbp), %xmm2
movss -0x4(%rbp), %xmm1
movss 0xcf79(%rip), %xmm3     # 0x6feec
subss -0x20(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movss -0x20(%rbp), %xmm2
movss -0x8(%rbp), %xmm1
movss 0xcf45(%rip), %xmm3     # 0x6feec
subss -0x20(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x20(%rbp), %xmm2
movss -0xc(%rbp), %xmm1
movss 0xcf10(%rip), %xmm3     # 0x6feec
subss -0x20(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_view.c
// Function: G_SetClientEvent
void G_SetClientEvent (edict_t *ent)
{
	if (ent->s.event)
		return;

	if ( ent->groundentity && xyspeed > 225)
	{
		if ( (int)(current_client->bobtime+bobmove) != bobcycle )
			ent->s.event = EV_FOOTSTEP;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x64724
jmp 0x64780
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2b8(%rax)
je 0x64780
movq 0x1e80f(%rip), %rax     # 0x82f48
movss (%rax), %xmm0
movss 0x130ff(%rip), %xmm1    # 0x77844
ucomiss %xmm1, %xmm0
jbe 0x64780
movq 0x4eb07(%rip), %rax     # 0xb3258
movss 0xec8(%rax), %xmm0
movq 0x1e6e8(%rip), %rax     # 0x82e48
addss (%rax), %xmm0
cvttss2si %xmm0, %eax
movq 0x1e421(%rip), %rcx     # 0x82b90
cmpl (%rcx), %eax
je 0x6477e
movq -0x8(%rbp), %rax
movl $0x2, 0x50(%rax)
jmp 0x64780
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_view.c
// Function: Client_Show_High_Scores
void Client_Show_High_Scores(edict_t *ent)
{
 char	string[5000];

	strcpy(string, "I am the big dawg");

 	gi.WriteByte (svc_layout);
 	gi.WriteString (string);
 	gi.unicast (ent, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1390, %rsp           # imm = 0x1390
movq %rdi, -0x8(%rbp)
leaq -0x1390(%rbp), %rdi
leaq 0x11dc6(%rip), %rsi     # 0x77913
callq 0x182c0
movl $0x4, %edi
movq 0x1caa2(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x1ca95(%rip), %rax     # 0x82600
movq 0xe8(%rax), %rax
leaq -0x1390(%rbp), %rdi
callq *%rax
movq 0x1ca7e(%rip), %rax     # 0x82600
movq 0xb8(%rax), %rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x1390, %rsp           # imm = 0x1390
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Think_Weapon
void Think_Weapon (edict_t *ent)
{
	is_quad = (ent->client->quad_framenum > level.framenum);

	// if just died, put the weapon away
	if (ent->health < 1)
	{
		ent->client->newweapon = NULL;
		ChangeWeapon (ent);
	}

	// call active weapon think routine
	if (ent->client->pers.weapon && ent->client->pers.weapon->weaponthink)
	{
		if (ent->client->silencer_shots)
			is_silenced = MZ_SILENCED;
		else
			is_silenced = 0;
		ent->client->pers.weapon->weaponthink (ent);
		RuneWeaponThinkHook (ent);
		
		// LM_JORM -- Switch to next weapon if out of ammo

		/*
		if (ent->client->ammo_index && 
			ent->client->pers.inventory[ent->client->ammo_index] < ent->client->pers.weapon->quantity)
		{
			if (level.time >= ent->pain_debounce_time)
			{
				gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
				ent->pain_debounce_time = level.time + 1;
			}
			//NoAmmoWeaponChange (ent);
			Cmd_WeapNext_f(ent);
		}
		*/

		// LM_JORM -- Speed up all weapons!

		/*
		if (!(level.framenum % 4))
		{
			if (ent->client->ps.gunframe)
				ent->client->pers.weapon->weaponthink (ent);
		}
		*/
		// END -- LM_JORM
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movss 0xf04(%rax), %xmm0
movq 0x1c28d(%rip), %rax     # 0x82da0
cvtsi2ssl (%rax), %xmm1
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4c73c(%rip)     # 0xb3264
movq -0x8(%rbp), %rax
cmpl $0x1, 0x254(%rax)
jge 0x66b51
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq $0x0, 0xe50(%rax)
movq -0x8(%rbp), %rdi
callq 0x18820
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0x730(%rax)
je 0x66bbc
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x730(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x66bbc
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0xf1c(%rax)
je 0x66b93
movb $-0x80, 0x4c6d7(%rip)   # 0xb3268
jmp 0x66b9a
movb $0x0, 0x4c6ce(%rip)     # 0xb3268
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x730(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x193e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Use_Weapon
void Use_Weapon (edict_t *ent, gitem_t *item)
{
	int			ammo_index;
	gitem_t		*ammo_item;
	char message[MAX_INFO_STRING];

	// see if we're already using it
	if (item == ent->client->pers.weapon)
		return;

	if (item->ammo && !g_select_empty->value && !(item->flags & IT_AMMO))
	{
		ammo_item = FindItem(item->ammo);
		ammo_index = ITEM_INDEX(ammo_item);

		if (!ent->client->pers.inventory[ammo_index])
		{
			sprintf(message, "No %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
			ctf_SafePrint(ent, PRINT_HIGH, message);
			return;
		}

		if (ent->client->pers.inventory[ammo_index] < item->quantity)
		{
			sprintf(message, "Not enough %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
			ctf_SafePrint(ent, PRINT_HIGH, message);
			return;
		}
	}

	// change to this weapon when down
	ent->client->newweapon = item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x730(%rcx), %rax
jne 0x66bfd
jmp 0x66d2b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x66d18
movq 0x1b935(%rip), %rax     # 0x82548
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x66d18
jp 0x66d18
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x66d18
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x18a90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x1c1e4(%rip), %rcx     # 0x82e40
subq %rcx, %rax
movl $0x88, %ecx
cqto
idivq %rcx
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, 0x318(%rax,%rcx,4)
jne 0x66cbe
leaq -0x220(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
leaq 0xa029(%rip), %rsi      # 0x70cc9
movb $0x0, %al
callq 0x19940
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
jmp 0x66d2b
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
movl 0x318(%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
cmpl 0x5c(%rcx), %eax
jge 0x66d16
leaq -0x220(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
leaq 0x9fe0(%rip), %rsi      # 0x70cd8
movb $0x0, %al
callq 0x19940
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rdx
movl $0x2, %esi
callq 0x18f20
jmp 0x66d2b
jmp 0x66d18
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0xe50(%rax)
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Drop_Weapon
void Drop_Weapon (edict_t *ent, gitem_t *item)
{
	int		index;

	if ((int)(dmflags->value) & DF_WEAPONS_STAY)
		return;

	index = ITEM_INDEX(item);
	// see if we're already using it
	if ( ((item == ent->client->pers.weapon) || (item == ent->client->newweapon))&& (ent->client->pers.inventory[index] == 1) )
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Can't drop current weapon\n");
		return;
	}

	Drop_Item (ent, item);
	ent->client->pers.inventory[index]--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1b8c1(%rip), %rax     # 0x82618
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x66d6c
jmp 0x66e08
movq -0x10(%rbp), %rax
movq 0x1c0c9(%rip), %rcx     # 0x82e40
subq %rcx, %rax
movl $0x88, %ecx
cqto
idivq %rcx
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0x730(%rcx), %rax
je 0x66db1
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0xe50(%rcx), %rax
jne 0x66dde
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x1, 0x318(%rax,%rcx,4)
jne 0x66dde
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0xc0e5(%rip), %rdx      # 0x72ebc
callq 0x18f20
jmp 0x66e08
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x184a0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x14(%rbp), %rcx
movl 0x318(%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, 0x318(%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: P_ProjectSource
static void P_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
{
	vec3_t	_distance;

	VectorCopy (distance, _distance);
	if (client->pers.hand == LEFT_HANDED)
		_distance[1] *= -1;
	else if (client->pers.hand == CENTER_HANDED)
		_distance[1] = 0;
	G_ProjectSource (point, _distance, forward, right, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x300(%rax)
jne 0x675fa
movss 0xb59a(%rip), %xmm0     # 0x72b88
mulss -0x38(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x67611
movq -0x8(%rbp), %rax
cmpl $0x2, 0x300(%rax)
jne 0x6760f
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
jmp 0x67611
movq -0x10(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x19140
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Weapon_Blaster_Fire
void Weapon_Blaster_Fire (edict_t *ent)
{
	int		damage;

	if (deathmatch->value)
		damage = 15;
	else
		damage = 10;
	Blaster_Fire (ent, vec3_origin, damage, false, EF_BLASTER);

#ifdef WEAP_BALANCE_OK	
	if ((int)ctfflags->value & CTF_WEAP_BALANCE)
	{
		if (ent->client->ps.gunframe == 5) // First frame
			ent->client->ps.gunframe+=2;
		else
		{
			ent->client->ps.gunframe++;
		}
	}
	else
	{
		ent->client->ps.gunframe++;
	}
#else
	ent->client->ps.gunframe++;
#endif

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1ad0d(%rip), %rax     # 0x82ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x681c7
jp 0x681c7
jmp 0x681d0
movl $0xf, -0xc(%rbp)
jmp 0x681d7
movl $0xa, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq 0x1a583(%rip), %rsi     # 0x82768
xorl %ecx, %ecx
movl $0x8, %r8d
callq 0x19c00
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Grapple_Bolt_Think
void Grapple_Bolt_Think(edict_t *self)
{
	if (!self->hook_target && self->owner->client->hooklength > 126)
	{
		//in flight sound
		gi.sound(self, CHAN_AUTO, gi.soundindex("weapons/grapple/gflyair.wav"), 1, ATTN_NORM, 0);
		self->nextthink = level.time + 0.4;
		self->think = Grapple_Bolt_Think;
	}
	else if (self->owner->client->hooklength > 126)
	{
		//retracting sound
		gi.sound(self, CHAN_AUTO, gi.soundindex("weapons/grapple/gpulling.wav"), 1, ATTN_NORM, 0);
		self->nextthink = level.time + 0.8;
		self->think = Grapple_Bolt_Think;
	}
	else
	{
		//no sound
		self->nextthink = 0;
		self->think = NULL;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x480(%rax)
jne 0x6abc1
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq 0x58(%rax), %rax
cmpl $0x7e, 0xf5c(%rax)
jle 0x6abc1
movq 0x17abf(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xd01b(%rip), %rdi      # 0x77b73
movq 0x17aa1(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x18(%rbp), %rdi
movl %eax, %edx
movq -0x10(%rbp), %rax
xorl %esi, %esi
movss 0x5376(%rip), %xmm1     # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
movq 0x1821b(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xcefa(%rip), %xmm1     # 0x77a90
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x18313(%rip), %rcx     # 0x82ec8
movq %rcx, 0x210(%rax)
jmp 0x6ac81
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq 0x58(%rax), %rax
cmpl $0x7e, 0xf5c(%rax)
jle 0x6ac61
movq 0x17a1c(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xcf94(%rip), %rdi      # 0x77b8f
movq 0x179fe(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x28(%rbp), %rdi
movl %eax, %edx
movq -0x20(%rbp), %rax
xorl %esi, %esi
movss 0x52d3(%rip), %xmm1     # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
movq 0x18178(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xce5f(%rip), %xmm1     # 0x77a98
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x18270(%rip), %rcx     # 0x82ec8
movq %rcx, 0x210(%rax)
jmp 0x6ac7f
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x210(%rax)
jmp 0x6ac81
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Draw_Hook
void Draw_Hook (edict_t *ent, vec3_t start, vec3_t end)
{
	vec3_t	dir, mins, maxs;
	vec3_t	offset;
	float		*v;

	v = tv(-15,-15,-15);
	_VectorCopy (v, mins);
	v = tv(15,15,15);
	_VectorCopy (v, maxs);

	VectorSubtract(end, start, dir);
	VectorSet(offset, 0, 0, 0);

	// Only display the grapple line if it isn't short
	if (VectorLength(dir) > 64)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_GRAPPLE_CABLE);
		gi.WriteShort (ent - g_edicts);
		gi.WritePosition (start);
		gi.WritePosition (end);
		gi.WritePosition (offset);
		gi.multicast (ent->s.origin, MULTICAST_PVS);
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss 0x5290(%rip), %xmm2     # 0x7029c
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x19740
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x19c40
movss 0x5268(%rip), %xmm2     # 0x70298
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x19740
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x19c40
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
subss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x4(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0x8(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x194e0
movss 0x4e5c(%rip), %xmm1     # 0x6ff14
ucomiss %xmm1, %xmm0
jbe 0x6b176
movl $0x3, %edi
movq 0x17533(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movl $0x18, %edi
movq 0x17521(%rip), %rax     # 0x82600
callq *0xc8(%rax)
movq 0x17514(%rip), %rax     # 0x82600
movq 0xd0(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x17456(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x4a8, %ecx            # imm = 0x4A8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x58(%rbp), %rax
movl %ecx, %edi
callq *%rax
movq 0x174dc(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq 0x174c8(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq 0x174b4(%rip), %rax     # 0x82600
movq 0xf0(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
movq 0x174a0(%rip), %rax     # 0x82600
movq 0xb0(%rax), %rax
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movl $0x2, %esi
callq *%rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_weapon.c
// Function: Weapon_Hook
void Weapon_Hook (edict_t *ent)
{
	static int	pause_frames[]	= {14, 18, 26, 30, 0};
	static int	fire_frames[]	= {8, 9, 10, 11,0};

	//if (ent->client->weaponstate == WEAPON_READY)
	//		ent->client->hookstate = 0;
	
	if (ent->client->weaponstate == WEAPON_ACTIVATING)
	{
		// Speed up activation
		ent->client->ps.gunframe+=1;
	}

	if (ent->client->newweapon && ent->client->weaponstate != WEAPON_DROPPING)
	{
		ent->client->weaponstate = WEAPON_DROPPING;
		ent->client->ps.gunframe = 36; //FRAME_DEACTIVATE_FIRST;
		return;
	}
	
	if ( !((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK))
	{
		ctf_hook_abort(ent);
	}
	
	Weapon_Generic (ent, 9, 13, 34, 38, pause_frames, fire_frames, Weapon_Hook_Fire);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0xe78(%rax)
jne 0x6b78e
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0xe50(%rax)
je 0x6b7d4
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x2, 0xe78(%rax)
je 0x6b7d4
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x2, 0xe78(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x24, 0x5c(%rax)
jmp 0x6b83d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0xe44(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
orl 0xe3c(%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x6b801
movq -0x8(%rbp), %rdi
callq 0x18690
movq -0x8(%rbp), %rdi
movl $0x9, %esi
movl $0xd, %edx
movl $0x22, %ecx
movl $0x26, %r8d
leaq 0x1c95f(%rip), %r9      # 0x88180
leaq 0x1c978(%rip), %r10     # 0x881a0
movq 0x17239(%rip), %rax     # 0x82a68
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x18490
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: PerpendicularVector
void PerpendicularVector( vec3_t dst, const vec3_t src )
{
	int	pos;
	int i;
	float minelem = 1.0F;
	vec3_t tempvec;

	/*
	** find the smallest magnitude axially aligned vector
	*/
	for ( pos = 0, i = 0; i < 3; i++ )
	{
		if ( fabs( src[i] ) < minelem )
		{
			pos = i;
			minelem = fabs( src[i] );
		}
	}
	tempvec[0] = tempvec[1] = tempvec[2] = 0.0F;
	tempvec[pos] = 1.0F;

	/*
	** project the point onto the plane defined by src
	*/
	ProjectPointOnPlane( dst, tempvec, src );

	/*
	** normalize the result
	*/
	VectorNormalize( dst );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss 0x3fa4(%rip), %xmm0     # 0x6feec
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jge 0x6bfc4
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movaps 0x6c27(%rip), %xmm0     # 0x72ba0
pand %xmm0, %xmm1
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6bfb7
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movaps 0x6bf6(%rip), %xmm1     # 0x72ba0
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x6bfb9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6bf5b
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movslq -0x14(%rbp), %rax
movss 0x3f04(%rip), %xmm0     # 0x6feec
movss %xmm0, -0x28(%rbp,%rax,4)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x19510
movq -0x8(%rbp), %rdi
callq 0x183d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: ProjectPointOnPlane
void ProjectPointOnPlane( vec3_t dst, const vec3_t p, const vec3_t normal )
{
	float d;
	vec3_t n;
	float inv_denom;

	inv_denom = 1.0F / DotProduct( normal, normal );

	d = DotProduct( normal, p ) * inv_denom;

	n[0] = normal[0] * inv_denom;
	n[1] = normal[1] * inv_denom;
	n[2] = normal[2] * inv_denom;

	dst[0] = p[0] - d * n[0];
	dst[1] = p[1] - d * n[1];
	dst[2] = p[2] - d * n[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss (%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rbp), %rax
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0x37b0(%rip), %xmm0     # 0x6feec
divss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movq -0x10(%rbp), %rax
movss (%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
mulss -0x2c(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x28(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x24(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm1
movss -0x1c(%rbp), %xmm0
movss -0x20(%rbp), %xmm2
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: VectorNormalize
vec_t VectorNormalize (vec3_t v)
{
	float	length, ilength;

	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
	length = sqrt (length);		// FIXME

	if (length)
	{
		ilength = 1/length;
		v[0] *= ilength;
		v[1] *= ilength;
		v[2] *= ilength;
	}
		
	return length;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19aa0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6c8dd
jp 0x6c8dd
jmp 0x6c926
movss 0x3607(%rip), %xmm0     # 0x6feec
divss -0xc(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movss -0xc(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: LerpAngle
float LerpAngle (float a2, float a1, float frac)
{
	if (a1 - a2 > 180)
		a1 -= 360;
	if (a1 - a2 < -180)
		a1 += 360;
	return a2 + frac * (a1 - a2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
subss -0x4(%rbp), %xmm0
movss 0x969f(%rip), %xmm1     # 0x763e4
ucomiss %xmm1, %xmm0
jbe 0x6cd60
movss -0x8(%rbp), %xmm0
movss 0x3fcd(%rip), %xmm1     # 0x70d24
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm1
subss -0x4(%rbp), %xmm1
movss 0x966e(%rip), %xmm0     # 0x763e0
ucomiss %xmm1, %xmm0
jbe 0x6cd89
movss 0x3fa5(%rip), %xmm0     # 0x70d24
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
movss -0x8(%rbp), %xmm2
subss -0x4(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: BoxOnPlaneSide2
int BoxOnPlaneSide2 (vec3_t emins, vec3_t emaxs, struct cplane_s *p)
{
	int		i;
	float	dist1, dist2;
	int		sides;
	vec3_t	corners[2];

	for (i=0 ; i<3 ; i++)
	{
		if (p->normal[i] < 0)
		{
			corners[0][i] = emins[i];
			corners[1][i] = emaxs[i];
		}
		else
		{
			corners[1][i] = emins[i];
			corners[0][i] = emaxs[i];
		}
	}
	dist1 = DotProduct (p->normal, corners[0]) - p->dist;
	dist2 = DotProduct (p->normal, corners[1]) - p->dist;
	sides = 0;
	if (dist1 >= 0)
		sides = 1;
	if (dist2 < 0)
		sides |= 2;

	return sides;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x6ce9c
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x6ce5e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movslq -0x1c(%rbp), %rax
movss %xmm0, -0x40(%rbp,%rax,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movslq -0x1c(%rbp), %rax
movss %xmm0, -0x34(%rbp,%rax,4)
jmp 0x6ce8c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movslq -0x1c(%rbp), %rax
movss %xmm0, -0x34(%rbp,%rax,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movslq -0x1c(%rbp), %rax
movss %xmm0, -0x40(%rbp,%rax,4)
jmp 0x6ce8e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ce17
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss -0x40(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss -0x3c(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x38(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm1
movss -0x34(%rbp), %xmm2
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss -0x30(%rbp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
movss -0x2c(%rbp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movss -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x6cf45
movl $0x1, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x6cf57
movl -0x28(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: AddPointToBounds
void AddPointToBounds (vec3_t v, vec3_t mins, vec3_t maxs)
{
	int		i;
	vec_t	val;

	for (i=0 ; i<3 ; i++)
	{
		val = v[i];
		if (val < mins[i])
			mins[i] = val;
		if (val > maxs[i])
			maxs[i] = val;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x6d66a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x6d638
movss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x6d65d
movss -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
jmp 0x6d65f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6d5f7
popq %rbp
retq
nopl (%rax)