LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_skins.c
// Function: SkinValid
qboolean
SkinValid(edict_t *ent, char *input)
{
	int teamnum, i;
	qboolean	valid = false;
	char	skin[MAX_INFO_STRING] = { 0 };
	char	model[MAX_INFO_STRING] = { 0 };

	if (!ent->client)
		return false;

	if (!input)
		return false;

	// Parse our input skin and model
	if (sscanf(input, "%[^/]/%s", model, skin) != 2)
		return false; // Doesn't contain skin and model

	if (ent->client->ctf.teamnum == CTF_TEAM_RED)
		teamnum = SKIN_RED;
	else 
		teamnum = SKIN_BLUE;

	i = 0;
	while(skinlist[teamnum][i][SKIN_MODELNAME])
	{
		if (!strcmp(skinlist[teamnum][i][SKIN_SKINNAME], skin) &&
			!strcmp(skinlist[teamnum][i][SKIN_MODELNAME], model))
		{
			valid = true;
			break;
		}
		i++;
	}
	return valid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x188f0
leaq -0x430(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x188f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x25ca7
movl $0x0, -0x4(%rbp)
jmp 0x25db6
cmpq $0x0, -0x18(%rbp)
jne 0x25cba
movl $0x0, -0x4(%rbp)
jmp 0x25db6
movq -0x18(%rbp), %rdi
leaq -0x430(%rbp), %rdx
leaq -0x230(%rbp), %rcx
leaq 0x4ac83(%rip), %rsi     # 0x70956
movb $0x0, %al
callq 0x19180
cmpl $0x2, %eax
je 0x25ceb
movl $0x0, -0x4(%rbp)
jmp 0x25db6
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x1100(%rax)
jne 0x25d05
movl $0x0, -0x1c(%rbp)
jmp 0x25d0c
movl $0x1, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x1c(%rbp), %rcx
movq 0x5c85a(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x25db0
movslq -0x1c(%rbp), %rcx
movq 0x5c837(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
leaq -0x230(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x25da2
movslq -0x1c(%rbp), %rcx
movq 0x5c805(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq -0x430(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x25da2
movl $0x1, -0x24(%rbp)
jmp 0x25db0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x25d13
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_skins.c
// Function: SkinRandom
char *SkinRandom(edict_t *ent)
{
	int teamnum,i;
	static	char skin[MAX_INFO_STRING]; // Returned and used as a temp

	if (ent->client->ctf.teamnum == CTF_TEAM_RED)
		teamnum = SKIN_RED;
	else 
		teamnum = SKIN_BLUE;

	i = 0;
	while (skinlist[teamnum][i][SKIN_MODELNAME])
	{
		i++;
	}

	i = rand() % i;

	sprintf(skin, "%s/%s", skinlist[teamnum][i][SKIN_MODELNAME],
		skinlist[teamnum][i][SKIN_SKINNAME]);

	return skin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x1100(%rax)
jne 0x25e06
movl $0x0, -0xc(%rbp)
jmp 0x25e0d
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
movq 0x5c759(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x25e42
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25e14
callq 0x19c80
cltd
idivl -0x10(%rbp)
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
movq 0x5c71f(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movslq -0xc(%rbp), %rcx
movq 0x5c6ff(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq 0x6436a(%rip), %rdi     # 0x8a200
leaq 0x4aaeb(%rip), %rsi     # 0x70988
movb $0x0, %al
callq 0x19940
leaq 0x64355(%rip), %rax     # 0x8a200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_skins.c
// Function: SkinGetList
char **SkinGetList(edict_t *ent)
{
	int teamnum, i;
	static	char *skins[SKIN_MAXSKINS]; // Returned and used as a temp
	static  char storage[SKIN_MAXSKINS][30];
	
	if (ent->client->ctf.teamnum == CTF_TEAM_RED)
		teamnum = SKIN_RED;
	else 
		teamnum = SKIN_BLUE;

	i = 0;
	while (skinlist[teamnum][i][SKIN_MODELNAME])
	{
		sprintf(storage[i], "%s/%s", skinlist[teamnum][i][SKIN_MODELNAME],
			skinlist[teamnum][i][SKIN_SKINNAME]);
		skins[i] = storage[i];		
		i++;
	}
	skins[i] = NULL;

	return skins;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x1100(%rax)
jne 0x25ee6
movl $0x0, -0xc(%rbp)
jmp 0x25eed
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
movq 0x5c679(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x25fab
movslq -0x10(%rbp), %rax
leaq 0x64cda(%rip), %rdi     # 0x8ac00
imulq $0x1e, %rax, %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rcx
movq 0x5c640(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movslq -0xc(%rbp), %rcx
movq 0x5c620(%rip), %rax     # 0x82578
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
leaq 0x4aa13(%rip), %rsi     # 0x70988
movb $0x0, %al
callq 0x19940
movslq -0x10(%rbp), %rax
leaq 0x64c79(%rip), %rdx     # 0x8ac00
imulq $0x1e, %rax, %rax
addq %rax, %rdx
movslq -0x10(%rbp), %rcx
leaq 0x64467(%rip), %rax     # 0x8a400
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25ef4
movslq -0x10(%rbp), %rcx
leaq 0x6444a(%rip), %rax     # 0x8a400
movq $0x0, (%rax,%rcx,8)
leaq 0x6443b(%rip), %rax     # 0x8a400
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_tourney.c
// Function: Match_End
void Match_End(edict_t *ent)
{
    Victory();

    matchstate = MATCH_OVER;
    ent->count = 300; // five minutes
    game.teamslocked = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x19760
movq 0x5bf30(%rip), %rax     # 0x827d8
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
movl $0x12c, 0x290(%rax)     # imm = 0x12C
movq 0x5c47d(%rip), %rax     # 0x82d40
movl $0x0, 0x624(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_tourney.c
// Function: SetPause
void SetPause(qboolean state)
{
    edict_t *ent;
    char *message;
    int i;

    match_pause = state;

    if (state) {
    	if ((int)autolock->value) {
    		game.teamslocked = false;
    	}
        message = "Game Paused\n";
    } else {
    	if ((int)autolock->value) {
    		game.teamslocked = true;
    	}
        message = "Game Unpaused\n";
    }

    for (i=0 ; i<game.maxclients ; i++) {  // Go through everyone
        ent = g_edicts + 1 + i;            // Select the client entity from the list of ents.
        if (!ent->inuse) {                 // Not in game yet is what I think this means.
            continue;
        }
        gi.centerprintf(ent, message);
    }
    gi.dprintf(message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movq 0x5c0db(%rip), %rax     # 0x82aa0
movl %ecx, (%rax)
cmpl $0x0, -0x4(%rbp)
je 0x269ff
movq 0x5c33c(%rip), %rax     # 0x82d10
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
cmpl $0x0, %eax
je 0x269f2
movq 0x5c358(%rip), %rax     # 0x82d40
movl $0x0, 0x624(%rax)
leaq 0x4a082(%rip), %rax     # 0x70a7b
movq %rax, -0x18(%rbp)
jmp 0x26a2f
movq 0x5c30a(%rip), %rax     # 0x82d10
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
cmpl $0x0, %eax
je 0x26a24
movq 0x5c326(%rip), %rax     # 0x82d40
movl $0x1, 0x624(%rax)
leaq 0x4a05d(%rip), %rax     # 0x70a88
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq 0x5c300(%rip), %rcx     # 0x82d40
cmpl 0x610(%rcx), %eax
jge 0x26a98
movq 0x5bb09(%rip), %rax     # 0x82558
movq (%rax), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movslq -0x1c(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x26a76
jmp 0x26a8d
movq 0x5bb83(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb $0x0, %al
callq *%rcx
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26a36
movq 0x5bb61(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rdi
movb $0x0, %al
callq *%rcx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_tourney.c
// Function: KillMatch
void KillMatch()
{
    matchstate = MATCH_NONE;

    if (tourneyclock) {
        tourneyclock->think = G_FreeEdict;
        tourneyclock->nextthink = level.time + 1;
        tourneyclock = NULL;
    }

    if ((int)autolock->value) {
    	game.teamslocked = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x5b61d(%rip), %rax     # 0x827d8
movl $0x0, (%rax)
movq 0x5be20(%rip), %rax     # 0x82fe8
cmpq $0x0, (%rax)
je 0x2721a
movq 0x5be13(%rip), %rax     # 0x82fe8
movq (%rax), %rax
movq 0x5b251(%rip), %rcx     # 0x82430
movq %rcx, 0x210(%rax)
movss 0x48cfe(%rip), %xmm0    # 0x6feec
movq 0x5bbab(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq 0x5bde7(%rip), %rax     # 0x82fe8
movq (%rax), %rax
movss %xmm0, 0x200(%rax)
movq 0x5bdd5(%rip), %rax     # 0x82fe8
movq $0x0, (%rax)
movq 0x5baef(%rip), %rax     # 0x82d10
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
cmpl $0x0, %eax
je 0x2723f
movq 0x5bb0b(%rip), %rax     # 0x82d40
movl $0x0, 0x624(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_tourney.c
// Function: SpawnTourneyClock
void SpawnTourneyClock ()
{
    edict_t    *ent;

    if (!tourneyclock) {
        ent = G_Spawn();
        tourneyclock = ent;
    } else {
        ent = tourneyclock;
    }

    if (matchstate == MATCH_RAILGUN_COUNTDOWN) {
        ent->count = 16;
    } else {
        ent->count = (int)countdown_time->value;
        matchstate = MATCH_COUNTDOWN;
    }

    // game is about to start, lock teams if necessary
    if ((int)autolock->value) {
    	game.teamslocked = true;
    }

    ent->think = Tourney_Think;
    ent->nextthink = level.time + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5bd39(%rip), %rax     # 0x82fe8
cmpq $0x0, (%rax)
jne 0x272ce
callq 0x19950
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x5bd1f(%rip), %rax     # 0x82fe8
movq %rcx, (%rax)
jmp 0x272dc
movq 0x5bd13(%rip), %rax     # 0x82fe8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x5b4f5(%rip), %rax     # 0x827d8
cmpl $0x5, (%rax)
jne 0x272f8
movq -0x8(%rbp), %rax
movl $0x10, 0x290(%rax)
jmp 0x2731e
movq 0x5b5b1(%rip), %rax     # 0x828b0
movq (%rax), %rax
cvttss2si 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x290(%rax)
movq 0x5b4c0(%rip), %rax     # 0x827d8
movl $0x2, (%rax)
movq 0x5b9eb(%rip), %rax     # 0x82d10
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
cmpl $0x0, %eax
je 0x27343
movq 0x5ba07(%rip), %rax     # 0x82d40
movl $0x1, 0x624(%rax)
movq -0x8(%rbp), %rax
movq 0x5bbb2(%rip), %rcx     # 0x82f00
movq %rcx, 0x210(%rax)
movss 0x48b8f(%rip), %xmm0    # 0x6feec
movq 0x5ba3c(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/plasma.c
// Function: Spawn_Goop
edict_t *
Spawn_Goop
(edict_t *ent, vec3_t start) {
	edict_t *goop = G_Spawn();

	goop->owner=	ent;
	goop->clipmask=	MASK_SHOT;
	goop->solid=	SOLID_BBOX;
	goop->svflags=	SVF_DEADMONSTER;
	
	VectorCopy (start, goop->s.origin);
	goop->classname= "goop";

	//goop->s.effects|=	EF_BLUEHYPERBLASTER | EF_ANIM_ALLFAST;
	//bat to get rid of the blue flag effect
	goop->s.effects|=	EF_IONRIPPER | EF_ANIM_ALLFAST;
	goop->s.renderfx= 	RF_TRANSLUCENT;
	goop->s.modelindex=	gi.modelindex(PLASMA_SPRITE_FLY);
	goop->s.sound= 		gi.soundindex(PLASMA_SOUND_FLYBY);

	return goop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x19950
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x18(%rbp), %rax
movl $0x6000003, 0x10c(%rax) # imm = 0x6000003
movq -0x18(%rbp), %rax
movl $0x2, 0x108(%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0xc8(%rax)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq -0x18(%rbp), %rax
leaq 0x49235(%rip), %rcx     # 0x70c77
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x102000, %ecx         # imm = 0x102000
movl %ecx, 0x40(%rax)
movq -0x18(%rbp), %rax
movl $0x20, 0x44(%rax)
leaq 0x49211(%rip), %rdi     # 0x70c7c
movq 0x5ab8e(%rip), %rax     # 0x82600
callq *0x40(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
leaq 0x4920d(%rip), %rdi     # 0x70c92
movq 0x5ab74(%rip), %rax     # 0x82600
callq *0x48(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/plasma.c
// Function: fire_plasma_reflect
void
fire_plasma_reflect
(edict_t *self, vec3_t start, vec3_t dir) {
	self->movetype = MOVETYPE_REFLECT;	// new movetype (MOVETYPE_BOUNCE
						// without gravity and friction,
						// and does not stop projectile
						// when it hits a ground plane)

	VectorScale(dir, PLASMA_REFLECT_SPEED, self->velocity);
	VectorCopy(self->velocity, self->s.angles);	// needed for post touch

	//Not sure what this even does????
	//if (deathmatch->value)
	//	self->dmg = 15 * PLASMA_BOUNCE_DAMAGE;
	//else
	//	self->dmg = 20 * PLASMA_BOUNCE_DAMAGE;
	
	//-bat
	self->dmg = PLASMA_BOUNCE_DAMAGE;
	
	self->touch = plasma_reflect_touch;
	
	self->think = G_FreeEdict;			// change this to handle
	//self->nextthink = level.time + 3.0;		//  sprite animation?
	self->nextthink = level.time + 1.5;

	gi.linkentity(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0xa, 0x118(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1c0, %rsi            # imm = 0x1C0
movss 0x49123(%rip), %xmm0    # 0x70c0c
callq 0x18a80
movq -0x8(%rbp), %rax
movss 0x1c0(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movss 0x1c4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0x1c8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x27, 0x280(%rax)
movq -0x8(%rbp), %rax
movq 0x5a8e2(%rip), %rcx     # 0x82428
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rax
movq 0x5a8d8(%rip), %rcx     # 0x82430
movq %rcx, 0x210(%rax)
movq 0x5b23a(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x490a9(%rip), %xmm1    # 0x70c20
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq 0x5aa6e(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/plasma.c
// Function: fire_plasma
void
fire_plasma
(edict_t *ent, vec3_t start, vec3_t dir, int reflect) {
	edict_t *goop= Spawn_Goop(ent, start);

	// give it some thickness for the bounce
	VectorSet (goop->mins, -12,-12,-12);
	VectorSet (goop->maxs, 12,12,12);

	if(reflect)
	{
		fire_plasma_reflect (goop,start,dir);
		//bat
		ent->client->pers.inventory[ent->client->ammo_index] -= (PLASMA_CELLS_PER_SHOT -1);
	}
	else
	{
		fire_plasma_spread (goop,start,dir);
		//bat
		ent->client->pers.inventory[ent->client->ammo_index] -= (PLASMA_CELLS_PER_SHOT - 1);
	}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x188e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movss 0x48ca0(%rip), %xmm0    # 0x70c14
movss %xmm0, 0xcc(%rax)
movq -0x28(%rbp), %rax
movss 0x48c8c(%rip), %xmm0    # 0x70c14
movss %xmm0, 0xd0(%rax)
movq -0x28(%rbp), %rax
movss 0x48c78(%rip), %xmm0    # 0x70c14
movss %xmm0, 0xd4(%rax)
movq -0x28(%rbp), %rax
movss 0x47f44(%rip), %xmm0    # 0x6fef4
movss %xmm0, 0xd8(%rax)
movq -0x28(%rbp), %rax
movss 0x47f30(%rip), %xmm0    # 0x6fef4
movss %xmm0, 0xdc(%rax)
movq -0x28(%rbp), %rax
movss 0x47f1c(%rip), %xmm0    # 0x6fef4
movss %xmm0, 0xe0(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x28021
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x195e0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movslq 0xe38(%rcx), %rcx
movl 0x318(%rax,%rcx,4), %edx
subl $0x9, %edx
movl %edx, 0x318(%rax,%rcx,4)
jmp 0x2805a
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x18760
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movslq 0xe38(%rcx), %rcx
movl 0x318(%rax,%rcx,4), %edx
subl $0x9, %edx
movl %edx, 0x318(%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_chase.c
// Function: ChaseNext
void ChaseNext(edict_t *ent)
{
int i;
edict_t *e;
int Chase_Team; //-bat

	if(!ent->client->chase_target)
		return;

	Chase_Team = ent->client->ctf.teamnum;

	i = ent->client->chase_target - g_edicts;
	do 
	{
		i++;
		if (i > maxclients->value)
			i = 1;
		e = g_edicts + i;
		if(!e->inuse)
			continue;

		//bat
		if(((Chase_Team == CTF_TEAM_OBSERVER_RED) && (e->client->ctf.teamnum != CTF_TEAM_RED))
			|| ((Chase_Team == CTF_TEAM_OBSERVER_BLUE) && (e->client->ctf.teamnum != CTF_TEAM_BLUE)))
			continue;


		if (!e->client->resp.spectator)
			break;
	} while (e != ent->client->chase_target);

	ent->client->chase_target = e;
	ent->client->update_chase = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0xf30(%rax)
jne 0x28d7f
jmp 0x28e89
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1100(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0xf30(%rax), %rax
movq 0x597b2(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x4a8, %ecx            # imm = 0x4A8
cqto
idivq %rcx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cvtsi2ssl -0xc(%rbp), %xmm0
movq 0x59762(%rip), %rax     # 0x82530
movq (%rax), %rax
ucomiss 0x20(%rax), %xmm0
jbe 0x28dde
movl $0x1, -0xc(%rbp)
movq 0x59773(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x28e06
jmp 0x28e4b
cmpl $-0x3, -0x1c(%rbp)
jne 0x28e1d
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x1100(%rax)
jne 0x28e34
cmpl $-0x2, -0x1c(%rbp)
jne 0x28e36
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x2, 0x1100(%rax)
je 0x28e36
jmp 0x28e4b
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0xe04(%rax)
jne 0x28e49
jmp 0x28e64
jmp 0x28e4b
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0xf30(%rcx), %rax
jne 0x28db9
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0xf30(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0xf38(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_chase.c
// Function: ChasePrev
void ChasePrev(edict_t *ent)
{
int i;
edict_t *e;
int Chase_Team; //-bat
int Team_Observe_OK;

	if(!ent->client->chase_target)
		return;

	Chase_Team = ent->client->ctf.teamnum;

	if(Chase_Team == CTF_TEAM_OBSERVER_RED || Chase_Team == CTF_TEAM_OBSERVER_BLUE)
		Team_Observe_OK = false;
	else
		Team_Observe_OK = true;

	i = ent->client->chase_target - g_edicts;
	do 
	{
		i--;
		if(i < 1)
			i = maxclients->value;
		e = g_edicts + i;
		if(!e->inuse)
			continue;

		//bat
		if(((Chase_Team == CTF_TEAM_OBSERVER_RED) && (e->client->ctf.teamnum != CTF_TEAM_RED))
			|| ((Chase_Team == CTF_TEAM_OBSERVER_BLUE) && (e->client->ctf.teamnum != CTF_TEAM_BLUE)))
			continue;

		if(!e->client->resp.spectator)
		{
			Team_Observe_OK = true;
			break;
		}
	} while (e != ent->client->chase_target);

	if(Team_Observe_OK)
	{
		ent->client->chase_target = e;
		ent->client->update_chase = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0xf30(%rax)
jne 0x28eaf
jmp 0x28fde
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1100(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x3, -0x1c(%rbp)
je 0x28ecc
cmpl $-0x2, -0x1c(%rbp)
jne 0x28ed5
movl $0x0, -0x20(%rbp)
jmp 0x28edc
movl $0x1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0xf30(%rax), %rax
movq 0x59666(%rip), %rcx     # 0x82558
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x4a8, %ecx            # imm = 0x4A8
cqto
idivq %rcx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x28f26
movq 0x59615(%rip), %rax     # 0x82530
movq (%rax), %rax
cvttss2si 0x20(%rax), %eax
movl %eax, -0xc(%rbp)
movq 0x5962b(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x28f4e
jmp 0x28f9a
cmpl $-0x3, -0x1c(%rbp)
jne 0x28f65
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x1100(%rax)
jne 0x28f7c
cmpl $-0x2, -0x1c(%rbp)
jne 0x28f7e
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x2, 0x1100(%rax)
je 0x28f7e
jmp 0x28f9a
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0xe04(%rax)
jne 0x28f98
movl $0x1, -0x20(%rbp)
jmp 0x28fb3
jmp 0x28f9a
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
cmpq 0xf30(%rcx), %rax
jne 0x28f05
cmpl $0x0, -0x20(%rbp)
je 0x28fde
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0xf30(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0xf38(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_chase.c
// Function: Team_Observer_OK
int Team_Observer_OK(int Team_To_View, edict_t *ent)
{
	if(Num_Of_Players(ent, Team_To_View) > 0)
		return(true);
	
	if(Team_To_View == CTF_TEAM_RED)
		gi.centerprintf(ent, "No red players to chase.");
	else
		gi.centerprintf(ent, "No blue players to chase.");

	return(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x19830
cmpl $0x0, %eax
jle 0x29009
movl $0x1, -0x4(%rbp)
jmp 0x2904c
cmpl $0x1, -0x8(%rbp)
jne 0x2902b
movq 0x595ea(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdi
leaq 0x47d07(%rip), %rsi     # 0x70d2c
movb $0x0, %al
callq *%rcx
jmp 0x29045
movq 0x595ce(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdi
leaq 0x47d04(%rip), %rsi     # 0x70d45
movb $0x0, %al
callq *%rcx
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_chase.c
// Function: GetChaseTarget
void GetChaseTarget(edict_t *ent)
{
int i;
edict_t *other;
int Chase_Team; //-bat

	Chase_Team = ent->client->ctf.teamnum;

	for(i = 1; i <= maxclients->value; i++) 
	{
		//other is the guy we are chasing
		other = g_edicts + i;

		//-bat
		if(((Chase_Team == CTF_TEAM_OBSERVER_RED) && (other->client->ctf.teamnum != CTF_TEAM_RED))
			|| ((Chase_Team == CTF_TEAM_OBSERVER_BLUE) && (other->client->ctf.teamnum != CTF_TEAM_BLUE)))
			continue;

		if(other->inuse && !other->client->resp.spectator) 
		{
			ent->client->chase_target = other;
			ent->client->update_chase = true;
			UpdateChaseCam(ent);
			return;
		}
	}

	gi.centerprintf(ent, "No other players to chase.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x1100(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x1, -0xc(%rbp)
cvtsi2ssl -0xc(%rbp), %xmm1
movq 0x594a0(%rip), %rax     # 0x82530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x29148
movq 0x594b0(%rip), %rax     # 0x82558
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpl $-0x3, -0x1c(%rbp)
jne 0x290d4
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x1, 0x1100(%rax)
jne 0x290eb
cmpl $-0x2, -0x1c(%rbp)
jne 0x290ed
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x2, 0x1100(%rax)
je 0x290ed
jmp 0x2913a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x29138
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
cmpl $0x0, 0xe04(%rax)
jne 0x29138
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rcx, 0xf30(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x1, 0xf38(%rax)
movq -0x8(%rbp), %rdi
callq 0x19c30
jmp 0x29162
jmp 0x2913a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29084
movq 0x594b1(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rdi
leaq 0x47c01(%rip), %rsi     # 0x70d5f
movb $0x0, %al
callq *%rcx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: stats_log_reset
void stats_log_reset()
{
	stats_player_s * p_current_player;

	p_current_player = p_start_player;
	while (p_current_player != NULL)
	{
		p_start_player = p_start_player->pNext;
		gi.TagFree(p_current_player);
		p_current_player = p_start_player;
	}

	stats_log_init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x59799(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x291ec
movq 0x59784(%rip), %rax     # 0x82938
movq (%rax), %rax
movq 0x280(%rax), %rcx
movq 0x59773(%rip), %rax     # 0x82938
movq %rcx, (%rax)
movq 0x59431(%rip), %rax     # 0x82600
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq 0x59755(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x291a6
callq 0x185d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: stats_find_dropped_player
stats_player_s* stats_find_dropped_player(char* name)
{
	stats_player_s *p_current_player = p_start_player;
	
	while (p_current_player != NULL)
	{
		if ((strcmp(p_current_player->info.name, name) == 0) &&
			p_current_player->dropped)
			break;
		else
			p_current_player = p_current_player->pNext;
	}

	return p_current_player;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x59725(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29253
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x29242
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x29242
jmp 0x29253
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2921a
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: stats_new_player
stats_player_s* stats_new_player(char* name)
{
	stats_player_s* p_player;
	
	p_player = (stats_player_s *) gi.TagMalloc(sizeof(stats_player_s), TAG_GAME);
	if (!p_player) {
		gi.error(ERR_FATAL, "LMCTF: allocation failed in %s", __func__);
		return NULL;
	}

	stats_init_player(p_player);
	p_player->dropped = false;
	p_player->info.teamnum = CTF_TEAM_UNDEFINED;
	strcpy(p_player->info.name, name);

	//attach the player to the front of the list
	p_player->pNext = p_start_player;
	p_start_player = p_player;

	return p_player;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x288, %edi            # imm = 0x288
movl $0x2fd, %esi            # imm = 0x2FD
movq 0x59343(%rip), %rax     # 0x82600
callq *0x108(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x292f6
xorl %eax, %eax
movl %eax, %edi
leaq 0x47aa1(%rip), %rsi     # 0x70d7a
leaq 0x47ab9(%rip), %rdx     # 0x70d99
movq 0x59319(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x38(%rcx)
movq $0x0, -0x8(%rbp)
jmp 0x29353
movq -0x18(%rbp), %rdi
callq 0x191c0
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x204(%rax)
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
callq 0x182c0
movq 0x59609(%rip), %rax     # 0x82938
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x280(%rax)
movq -0x18(%rbp), %rcx
movq 0x595f0(%rip), %rax     # 0x82938
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: stats_cleanup
void stats_cleanup()
{
	stats_player_s *p_current_player, *p_prev_player;

	// clear out dropped players from start and
	// adjust start if needed
	p_current_player = p_start_player;
	while ( p_current_player && (p_current_player->dropped))
	{
		p_start_player = p_current_player->pNext;
		gi.TagFree(p_current_player);
		p_current_player = p_start_player;

	}

	// case when everyone is gone
	if (p_start_player == NULL)
	{
		return;
	}

	stats_init_player(p_start_player);

	// clear out dropped players and reinitialize stats
	p_current_player = p_start_player->pNext; // When the start is valid
	p_prev_player = p_start_player;

	while (p_current_player)
	{
		if (p_current_player->dropped)
		{
			p_prev_player->pNext = p_current_player->pNext;
			gi.TagFree(p_current_player);
		}
		else
		{
			stats_init_player(p_current_player);
			p_prev_player = p_current_player;
		}
		p_current_player = p_prev_player->pNext;

	}
	
	if (p_current_player)
		p_current_player->pNext = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x59579(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x293df
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x293e8
jmp 0x29421
movq -0x8(%rbp), %rax
movq 0x280(%rax), %rcx
movq 0x5953e(%rip), %rax     # 0x82938
movq %rcx, (%rax)
movq 0x591fc(%rip), %rax     # 0x82600
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq 0x59520(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x293c6
movq 0x59510(%rip), %rax     # 0x82938
cmpq $0x0, (%rax)
jne 0x29433
jmp 0x294d9
movq 0x594fe(%rip), %rax     # 0x82938
movq (%rax), %rdi
callq 0x191c0
movq 0x594ef(%rip), %rax     # 0x82938
movq (%rax), %rax
movq 0x280(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x594da(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x294c3
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x294a1
movq -0x8(%rbp), %rax
movq 0x280(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x280(%rax)
movq 0x5916e(%rip), %rax     # 0x82600
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x294b2
movq -0x8(%rbp), %rdi
callq 0x191c0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29465
cmpq $0x0, -0x8(%rbp)
je 0x294d9
movq -0x8(%rbp), %rax
movq $0x0, 0x280(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: stats_clear
void stats_clear(edict_t *ent)
{
	if (!ent || !ent->client || !ent->client->p_stats_player)
		return;

	stats_init_player(ent->client->p_stats_player);
	ent->client->resp.score = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29630
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x29630
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
cmpq $0x0, 0x9138(%rax)
jne 0x29632
jmp 0x29658
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x9138(%rax), %rdi
callq 0x191c0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl $0x0, 0xdf4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: Cmd_PlayerStats_f
void Cmd_PlayerStats_f (edict_t *ent)
{
	edict_t *temp, *target;
	stats_player_s *p_player;
	int i;
	char *p;
	char lowerstr[MAX_INFO_STRING];

	p = gi.args();

	if (p && strlen(p))
	{
		LowerCase(p);
		target = NULL;
		for (i=0 ; i<game.maxclients ; i++)
		{
			temp = g_edicts + 1 + i;
			strcpy(lowerstr, temp->client->pers.netname);
			LowerCase(lowerstr);
			if (strstr(lowerstr, p))
			{
				target = temp;
				break;
			}
		}
	}
	else
		target = ent;

	if (!target)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Cannot find a matching player.\n");
		return;
	}

	p_player = target->client->p_stats_player;
	stats_output(ent, p_player);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq 0x58c7a(%rip), %rax     # 0x82600
callq *0x148(%rax)
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x29a5e
movq -0x30(%rbp), %rdi
callq 0x186e0
cmpq $0x0, %rax
je 0x29a5e
movq -0x30(%rbp), %rdi
callq 0x18e60
movq $0x0, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq 0x59370(%rip), %rcx     # 0x82d40
cmpl 0x610(%rcx), %eax
jge 0x29a5c
movq 0x58b75(%rip), %rax     # 0x82558
movq (%rax), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movslq -0x24(%rbp), %rcx
imulq $0x4a8, %rcx, %rcx      # imm = 0x4A8
addq %rcx, %rax
movq %rax, -0x10(%rbp)
leaq -0x230(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
addq $0xc0, %rsi
addq $0x200, %rsi            # imm = 0x200
callq 0x182c0
leaq -0x230(%rbp), %rdi
callq 0x18e60
leaq -0x230(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x19bf0
cmpq $0x0, %rax
je 0x29a4c
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x29a5c
jmp 0x29a4e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x299c6
jmp 0x29a66
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x29a84
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x4740a(%rip), %rdx     # 0x70e87
callq 0x18f20
jmp 0x29aa4
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x9138(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19b30
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/p_stats.c
// Function: Cmd_StatsAll_f
void Cmd_StatsAll_f (edict_t *ent)
{
	stats_player_s *p_player;

	p_player = p_start_player;
	while (p_player != NULL)
	{
		stats_output(ent, p_player);
		p_player = p_player->pNext;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x58e75(%rip), %rax     # 0x82938
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29aef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19b30
movq -0x10(%rbp), %rax
movq 0x280(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x29aca
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_MaybeOpenFile
static int _sl_MaybeOpenFile( game_import_t  *gi )
{
    if( NULL == logfile )
        logfile = gi->cvar( "stdlogfile", "0", CVAR_SERVERINFO );

    if( (NULL != logfile) && (logfile->value != 0) )
    {
        if( NULL == StdLogFile )
        {
            cvar_t   *filename  = gi->cvar( "stdlogname", "StdLog.log", CVAR_SERVERINFO );
            char     *pName     = "StdLog.log";

            // Open File
            if( filename )
                pName = filename->string;

            StdLogFile = fopen( pName, "a+t" );

            if( NULL == StdLogFile )
            {
                gi->error( "Couldn't open %s", pName );
            }
        }
    }

    return (NULL != StdLogFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq 0x62f1b(%rip), %rax     # 0x8ca50
jne 0x29b5b
movq -0x8(%rbp), %rax
leaq 0x47365(%rip), %rdi     # 0x70ea7
leaq 0x4e167(%rip), %rsi     # 0x77cb0
movl $0x4, %edx
callq *0x120(%rax)
movq %rax, 0x62ef5(%rip)     # 0x8ca50
xorl %eax, %eax
cmpq 0x62eec(%rip), %rax     # 0x8ca50
je 0x29c0c
movq 0x62edf(%rip), %rax     # 0x8ca50
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x29b85
jp 0x29b85
jmp 0x29c0c
xorl %eax, %eax
cmpq 0x62eca(%rip), %rax     # 0x8ca58
jne 0x29c0a
movq -0x8(%rbp), %rax
leaq 0x46d20(%rip), %rdi     # 0x708bb
leaq 0x47310(%rip), %rsi     # 0x70eb2
movl $0x4, %edx
callq *0x120(%rax)
movq %rax, -0x10(%rbp)
leaq 0x472fa(%rip), %rax     # 0x70eb2
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29bcf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x472e3(%rip), %rsi     # 0x70ebd
callq 0x196a0
movq %rax, 0x62e72(%rip)     # 0x8ca58
xorl %eax, %eax
cmpq 0x62e69(%rip), %rax     # 0x8ca58
jne 0x29c08
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rsi
leaq 0x472bd(%rip), %rdi     # 0x70ec1
movb $0x0, %al
callq *%rcx
jmp 0x29c0a
jmp 0x29c0c
xorl %eax, %eax
cmpq 0x62e43(%rip), %rax     # 0x8ca58
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_MaybeCloseFile
static void _sl_MaybeCloseFile( void )
{
    if( logfile && StdLogFile) // LM_JORM -- was "if ( NULL != logfile)"
    {
        fclose( StdLogFile );
    }

    StdLogFile = NULL;
    logfile    = NULL;
    logstyle   = NULL;
    uiLogstyle  = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x62e04(%rip)     # 0x8ca50
je 0x29c64
cmpq $0x0, 0x62e02(%rip)     # 0x8ca58
je 0x29c64
movq 0x62df9(%rip), %rdi     # 0x8ca58
callq 0x18600
movq $0x0, 0x62de9(%rip) # 0x8ca58
movq $0x0, 0x62dd6(%rip) # 0x8ca50
movq $0x0, 0x62ddb(%rip) # 0x8ca60
movl $0x0, 0x62db9(%rip)     # 0x8ca48
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_SetStyle
static __inline void _sl_SetStyle( game_import_t  *gi )
{
    if( NULL == logstyle )
    {
        logstyle = gi->cvar( "stdlogstyle", "0", CVAR_SERVERINFO );
        if( logstyle )
        {
            uiLogstyle = (unsigned int)logstyle->value;
            if( uiLogstyle >= (sizeof(_sl_LogStyles)/sizeof(_sl_LogStyles[0])) )
                uiLogstyle = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq 0x62d5b(%rip), %rax     # 0x8ca60
jne 0x29d62
movq -0x8(%rbp), %rax
leaq 0x471c0(%rip), %rdi     # 0x70ed2
leaq 0x4df97(%rip), %rsi     # 0x77cb0
movl $0x4, %edx
callq *0x120(%rax)
movq %rax, 0x62d35(%rip)     # 0x8ca60
cmpq $0x0, 0x62d2d(%rip)     # 0x8ca60
je 0x29d60
movq 0x62d24(%rip), %rax     # 0x8ca60
cvttss2si 0x20(%rax), %rax
movl %eax, 0x62d00(%rip)     # 0x8ca48
movl 0x62cfa(%rip), %eax     # 0x8ca48
cmpq $0x1, %rax
jb 0x29d5e
movl $0x0, 0x62cea(%rip)     # 0x8ca48
jmp 0x29d60
jmp 0x29d62
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_LogScore
void sl_LogScore( game_import_t  *gi,
                  char           *pKillerName,
                  char           *pTargetName,
                  char           *pScoreType,
                  char           *pWeaponName,
                  int             iScore,
                  float           timeInSeconds )
{
    if (!Match_CanScore())
        return;

    if( _sl_MaybeOpenFile( gi ) )
    {
        _sl_SetStyle( gi );
        _sl_LogStyles[uiLogstyle].pLogScore( pKillerName, pTargetName, pScoreType, pWeaponName, iScore, timeInSeconds );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movss %xmm0, -0x30(%rbp)
movb $0x0, %al
callq 0x191a0
cmpl $0x0, %eax
jne 0x29f93
jmp 0x29fdf
movq -0x8(%rbp), %rdi
callq 0x29b20
cmpl $0x0, %eax
je 0x29fdf
movq -0x8(%rbp), %rdi
callq 0x29cf0
movl 0x62a98(%rip), %eax     # 0x8ca48
movl %eax, %ecx
leaq 0x5ac47(%rip), %rax     # 0x84c00
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movss -0x30(%rbp), %xmm0
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_LogDate
static void _sl_LogDate( void )
{
    time_t t;

    /* Get the time */
    t = time(NULL);
    if( -1 != t )
    {
        struct tm  *ptm;

        ptm = localtime( &t );
        if( NULL != ptm )
        {
            char        date[MAX_DATE_STRLEN+1] = {0};

            strftime( &date[0],
                      (sizeof(date)/sizeof(date[0]))-1,
                      "%d %b %Y",
                      ptm );

            fprintf( StdLogFile, "\t\tLogDate\t%s\n", &date[0] );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x18f70
movq %rax, -0x8(%rbp)
movq $-0x1, %rax
cmpq -0x8(%rbp), %rax
je 0x2a2fb
leaq -0x8(%rbp), %rdi
callq 0x181a0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x2a2f9
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x16, %edx
callq 0x188f0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x15, %esi
leaq 0x46c2f(%rip), %rdx     # 0x70f0a
callq 0x194d0
movq 0x62771(%rip), %rdi     # 0x8ca58
leaq -0x30(%rbp), %rdx
leaq 0x46c21(%rip), %rsi     # 0x70f13
movb $0x0, %al
callq 0x18cf0
jmp 0x2a2fb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_LogTime
static void _sl_LogTime( void )
{
    time_t t;

    /* Get the time */
    t = time(NULL);
    if( -1 != t )
    {
        struct tm  *ptm;

        ptm = localtime( &t );
        if( NULL != ptm )
        {
            char        time[MAX_TIME_STRLEN+1] = {0};

            strftime( &time[0],
                      (sizeof(time)/sizeof(time[0]))-1,
                      "%H:%M:%S",
                      ptm );

            fprintf( StdLogFile, "\t\tLogTime\t%s\n", &time[0] );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x18f70
movq %rax, -0x8(%rbp)
movq $-0x1, %rax
cmpq -0x8(%rbp), %rax
je 0x2a38b
leaq -0x8(%rbp), %rdi
callq 0x181a0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x2a389
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x13, %edx
callq 0x188f0
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x12, %esi
leaq 0x46bb6(%rip), %rdx     # 0x70f21
callq 0x194d0
movq 0x626e1(%rip), %rdi     # 0x8ca58
leaq -0x30(%rbp), %rdx
leaq 0x46ba8(%rip), %rsi     # 0x70f2a
movb $0x0, %al
callq 0x18cf0
jmp 0x2a38b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/stdlog.c
// Function: sl_LogScore
static void _sl_LogScore( char *pKillerName,
                          char *pTargetName,
                          char *pScoreType,
                          char *pWeaponName,
                          int   iScore,
                          float timeInSeconds )
{
    /* Killer Name */
    if( NULL != pKillerName )
        fprintf( StdLogFile, "%s", pKillerName );
    fprintf( StdLogFile, "\t" );

    /* Target Name */
    if( NULL != pTargetName )
        fprintf( StdLogFile, "%s", pTargetName );
    fprintf( StdLogFile, "\t" );

    /* Score Type */
    if( NULL != pScoreType )
        fprintf( StdLogFile, "%s", pScoreType );
    fprintf( StdLogFile, "\t" );

    /* Weapon Name */
    if( NULL != pWeaponName )
        fprintf( StdLogFile, "%s", pWeaponName );
    fprintf( StdLogFile, "\t" );

    /* Score & Time */
    fprintf( StdLogFile, "%d\t%.1f\n", iScore, timeInSeconds );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movss %xmm0, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x2a4b2
movq 0x625b8(%rip), %rdi     # 0x8ca58
movq -0x8(%rbp), %rdx
leaq 0x454f2(%rip), %rsi     # 0x6f99d
movb $0x0, %al
callq 0x18cf0
movq 0x6259f(%rip), %rdi     # 0x8ca58
leaq 0x46abf(%rip), %rsi     # 0x70f7f
movb $0x0, %al
callq 0x18cf0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x2a4e8
movq 0x62582(%rip), %rdi     # 0x8ca58
movq -0x10(%rbp), %rdx
leaq 0x454bc(%rip), %rsi     # 0x6f99d
movb $0x0, %al
callq 0x18cf0
movq 0x62569(%rip), %rdi     # 0x8ca58
leaq 0x46a89(%rip), %rsi     # 0x70f7f
movb $0x0, %al
callq 0x18cf0
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2a51e
movq 0x6254c(%rip), %rdi     # 0x8ca58
movq -0x18(%rbp), %rdx
leaq 0x45486(%rip), %rsi     # 0x6f99d
movb $0x0, %al
callq 0x18cf0
movq 0x62533(%rip), %rdi     # 0x8ca58
leaq 0x46a53(%rip), %rsi     # 0x70f7f
movb $0x0, %al
callq 0x18cf0
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x2a554
movq 0x62516(%rip), %rdi     # 0x8ca58
movq -0x20(%rbp), %rdx
leaq 0x45450(%rip), %rsi     # 0x6f99d
movb $0x0, %al
callq 0x18cf0
movq 0x624fd(%rip), %rdi     # 0x8ca58
leaq 0x46a1d(%rip), %rsi     # 0x70f7f
movb $0x0, %al
callq 0x18cf0
movq 0x624e8(%rip), %rdi     # 0x8ca58
movl -0x24(%rbp), %edx
movss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x469fe(%rip), %rsi     # 0x70f81
movb $0x1, %al
callq 0x18cf0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/gslog.c
// Function: sl_Logging
int sl_Logging( game_import_t  *gi,
                char           *pPatchName )
{
    int fFileOpen = sl_OpenLogFile( gi );

    if( fFileOpen && !fWasAlreadyOpen )
    {
        cvar_t *deathflags = gi->cvar( "dmflags", "0", CVAR_SERVERINFO );

        sl_LogVers( gi );
        
        pPatch = pPatchName;
        sl_LogPatch( gi, pPatchName );

        sl_LogDate( gi );
        sl_LogTime( gi );
        sl_LogDeathFlags( gi, (unsigned long)deathflags->value );

        fWasAlreadyOpen = fFileOpen;
    }

    return fFileOpen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18060
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2a84b
cmpl $0x0, 0x622bb(%rip)     # 0x8ca68
jne 0x2a84b
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rax
leaq 0x44d42(%rip), %rdi     # 0x6f507
leaq 0x4d4e4(%rip), %rsi     # 0x77cb0
movl $0x4, %edx
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19910
movq -0x10(%rbp), %rax
movq %rax, 0x62285(%rip)     # 0x8ca70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18380
movq -0x8(%rbp), %rdi
callq 0x18260
movq -0x8(%rbp), %rdi
callq 0x190c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movss 0x20(%rax), %xmm0
movss 0x46835(%rip), %xmm2    # 0x71054
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rax
cvttss2si %xmm0, %rsi
movq %rsi, %rcx
sarq $0x3f, %rcx
andq %rcx, %rax
orq %rax, %rsi
callq 0x19b90
movl -0x14(%rbp), %eax
movl %eax, 0x6221d(%rip)     # 0x8ca68
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)