LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: Write_Highscore_Table
void Write_Highscore_Table(void)
{
edict_t     *cl_ent;
char Buf[512];
FILE *fp;
int i;
size_t Obj_Read;

	if(maplistindex < 0)
		return;

	sprintf(Buf, "%s/%s.scr", gamedir->string, level.mapname);


	fp = fopen(Buf, "rb");

	if(fp == 0)
		Create_New_File();
	else
	{
		Obj_Read = fread(Highscore_Table, sizeof(HIGHSCORE_STATS_TYPE), MAX_HIGHSCORE_ENTRIES, fp);
		if(Obj_Read < MAX_HIGHSCORE_ENTRIES)
		{
			fclose(fp);
			Create_New_File();
		}
	}

	fp = fopen(Buf, "wb");
	if(fp == 0)
		return;


    for(i = 0; i < game.maxclients; i++)
    {
        cl_ent = g_edicts + 1 + i;
		Check_Made_Table(cl_ent);
    }

	
	fwrite(Highscore_Table, sizeof(HIGHSCORE_STATS_TYPE), MAX_HIGHSCORE_ENTRIES, fp);
	fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq 0x37118(%rip), %rax     # 0x66dd8
cmpl $0x0, (%rax)
js 0x2fd88
movq 0x371e0(%rip), %rax     # 0x66eb0
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq 0x370c2(%rip), %rcx     # 0x66da0
addq $0x48, %rcx
leaq 0x235aa(%rip), %rsi     # 0x53293
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x198c0
leaq 0x235a0(%rip), %rsi     # 0x5329d
movq %rbx, %rdi
callq 0x19620
testq %rax, %rax
je 0x2fd30
movq %rax, %rbx
movq 0x36d94(%rip), %rdi     # 0x66aa8
pushq $0x28
popq %rsi
pushq $0x7
popq %rdx
movq %rax, %rcx
callq 0x18420
cmpq $0x6, %rax
ja 0x2fd35
movq %rbx, %rdi
callq 0x185e0
callq 0x19340
leaq 0x23564(%rip), %rsi     # 0x532a0
movq %rsp, %rdi
callq 0x19620
testq %rax, %rax
je 0x2fd88
movq %rax, %rbx
movl $0x4a8, %r14d           # imm = 0x4A8
xorl %r15d, %r15d
movq 0x36fe4(%rip), %r12     # 0x66d40
movq 0x367f5(%rip), %r13     # 0x66558
movslq 0x610(%r12), %rax
cmpq %rax, %r15
jge 0x2fd99
movq (%r13), %rdi
addq %r14, %rdi
callq 0x18610
incq %r15
addq $0x4a8, %r14            # imm = 0x4A8
jmp 0x2fd63
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x36d08(%rip), %rdi     # 0x66aa8
pushq $0x28
popq %rsi
pushq $0x7
popq %rdx
movq %rbx, %rcx
callq 0x198e0
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x185e0
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: Declare_Railgun_Victor
edict_t *Declare_Railgun_Victor(void)
{
int Highscore = -9999;
edict_t *Winner;
edict_t *cl_ent;
int i;
int score;
    
	Winner = g_edicts + 1;

	for(i = 0; i < game.maxclients; i++)
    {
        cl_ent = g_edicts + 1 + i;

		if(cl_ent->health <= 0)
			continue;

		score = stats_get(cl_ent, STATS_SCORE);

    	if(score > Highscore)
		{
			Winner = cl_ent;
			Highscore = score;
		}
    }

	return(Winner);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x36712(%rip), %r15     # 0x66558
movl $0x4a8, %r12d           # imm = 0x4A8
movq (%r15), %rbx
addq %r12, %rbx
movq 0x36ee7(%rip), %rax     # 0x66d40
movl 0x610(%rax), %ecx
movl $0xffffd8f1, %ebp       # imm = 0xFFFFD8F1
xorl %r13d, %r13d
movslq %ecx, %rax
cmpq %rax, %r13
jge 0x2feaf
movq (%r15), %r14
cmpl $0x0, 0x254(%r14,%r12)
jle 0x2fea3
addq %r12, %r14
movq %r14, %rdi
pushq $0x3
popq %rsi
callq 0x18030
cmpl %eax, %ebp
cmovlq %r14, %rbx
cmovgl %ebp, %eax
movq 0x36ea5(%rip), %rcx     # 0x66d40
movl 0x610(%rcx), %ecx
movl %eax, %ebp
incq %r13
addq $0x4a8, %r12            # imm = 0x4A8
jmp 0x2fe67
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: CheckNeedPass
void CheckNeedPass (void)
{
	int need;

	// if password or spectator_password has changed, update needpass
	// as needed
	if (password->modified || spectator_password->modified) 
	{
		password->modified = spectator_password->modified = false;

		need = 0;

		if (*password->string && Q_stricmp(password->string, "none"))
			need |= 1;
		if (*spectator_password->string && Q_stricmp(spectator_password->string, "none"))
			need |= 2;

		gi.cvar_set("needpass", va("%d", need));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x367c3(%rip), %rax     # 0x66858
movq (%rax), %rcx
cmpl $0x0, 0x1c(%rcx)
movq 0x36b85(%rip), %r14     # 0x66c28
movq (%r14), %rax
jne 0x300ae
cmpl $0x0, 0x1c(%rax)
je 0x3012c
andl $0x0, 0x1c(%rax)
andl $0x0, 0x1c(%rcx)
movq 0x8(%rcx), %rdi
cmpb $0x0, (%rdi)
je 0x300d7
leaq 0x231eb(%rip), %rsi     # 0x532b1
callq 0x186d0
xorl %ebx, %ebx
testl %eax, %eax
setne %bl
movq (%r14), %rax
jmp 0x300d9
xorl %ebx, %ebx
movq 0x8(%rax), %rdi
cmpb $0x0, (%rdi)
je 0x300f8
leaq 0x231c8(%rip), %rsi     # 0x532b1
callq 0x186d0
leal 0x2(%rbx), %ecx
testl %eax, %eax
cmovel %ebx, %ecx
movl %ecx, %ebx
movq 0x36501(%rip), %rax     # 0x66600
movq 0x128(%rax), %r14
leaq 0x1e779(%rip), %rdi     # 0x4e886
movl %ebx, %esi
xorl %eax, %eax
callq 0x194e0
leaq 0x23199(%rip), %rdi     # 0x532b6
movq %rax, %rsi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_main.c
// Function: ExitLevel
void ExitLevel (void)
{
	int		i;
	edict_t	*ent;
	char	command [MAX_INFO_STRING];

	Com_sprintf (command, sizeof(command), "gamemap \"%s\"\n", level.changemap);

	gi.AddCommandString (command);
	level.changemap = NULL;
	level.exitintermission = 0;
	level.intermissiontime = 0;
	ClientEndServerFrames ();

	// clear some things before going to next level
	for (i = 0; i < maxclients->value; i++)
	{
		ent = g_edicts + 1 + i;
		if (ent && ent->inuse)
		{
			if (ent->health > ent->client->pers.max_health)
				ent->health = ent->client->pers.max_health;
		}
	}

	// clean up stats before start of next level
	stats_cleanup(); // STATS - LM_Hati
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq 0x36982(%rip), %r14     # 0x66da0
movq 0xd0(%r14), %rcx
leaq 0x1f4c7(%rip), %rdx     # 0x4f8f3
xorl %ebp, %ebp
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
callq 0x18f30
movq 0x361b9(%rip), %rax     # 0x66600
movq %rbx, %rdi
callq *0x150(%rax)
andq $0x0, 0xd0(%r14)
andl $0x0, 0xd8(%r14)
andl $0x0, 0xc8(%r14)
callq 0x190c0
movq 0x360bc(%rip), %rax     # 0x66530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
movq 0x360d5(%rip), %rcx     # 0x66558
movl $0x6fc, %eax            # imm = 0x6FC
addq (%rcx), %rax
cvtsi2ss %ebp, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x304ba
cmpl $0x0, -0x1f4(%rax)
je 0x304b0
movq -0x1fc(%rax), %rcx
movl 0x30c(%rcx), %ecx
cmpl %ecx, (%rax)
jle 0x304b0
movl %ecx, (%rax)
addq $0x4a8, %rax            # imm = 0x4A8
incl %ebp
jmp 0x3048b
xorl %eax, %eax
callq 0x19090
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: VelocityForDamage
void VelocityForDamage (int damage, vec3_t v)
{
	v[0] = 100.0 * crandom();
	v[1] = 100.0 * crandom();
	v[2] = 200.0 + 100.0 * random();

	if (damage < 50)
		VectorScale (v, 0.7f, v);
	else 
		VectorScale (v, 1.2f, v);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
cmpl $0x32, %edi
setl %r14b
callq 0x19bf0
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1ed52(%rip), %xmm0    # 0x4f288
cvtss2sd %xmm0, %xmm0
addsd 0x216b6(%rip), %xmm0    # 0x51bf8
addsd %xmm0, %xmm0
mulsd 0x22dd2(%rip), %xmm0    # 0x53320
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx)
callq 0x19bf0
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1ed1f(%rip), %xmm0    # 0x4f288
cvtss2sd %xmm0, %xmm0
addsd 0x21683(%rip), %xmm0    # 0x51bf8
addsd %xmm0, %xmm0
mulsd 0x22d9f(%rip), %xmm0    # 0x53320
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rbx)
callq 0x19bf0
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1eceb(%rip), %xmm0    # 0x4f288
cvtss2sd %xmm0, %xmm0
mulsd 0x22d77(%rip), %xmm0    # 0x53320
addsd 0x22d77(%rip), %xmm0    # 0x53328
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rbx)
leaq 0x22d6f(%rip), %rax     # 0x53330
movss (%rax,%r14,4), %xmm0
movq %rbx, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x18a70
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ClipGibVelocity
void ClipGibVelocity (edict_t *ent)
{
	if (ent->velocity[0] < -300)
		ent->velocity[0] = -300;
	else if (ent->velocity[0] > 300)
		ent->velocity[0] = 300;
	if (ent->velocity[1] < -300)
		ent->velocity[1] = -300;
	else if (ent->velocity[1] > 300)
		ent->velocity[1] = 300;
	if (ent->velocity[2] < 200)
		ent->velocity[2] = 200;	// always some upwards
	else if (ent->velocity[2] > 500)
		ent->velocity[2] = 500;
}

// Assembly:
movss 0x1c0(%rdi), %xmm1
movss 0x22d26(%rip), %xmm0    # 0x5330c
ucomiss %xmm1, %xmm0
ja 0x305f8
movss 0x219a9(%rip), %xmm0    # 0x51f9c
ucomiss %xmm0, %xmm1
jbe 0x30600
movss %xmm0, 0x1c0(%rdi)
movss 0x1c4(%rdi), %xmm1
movss 0x22cfc(%rip), %xmm0    # 0x5330c
ucomiss %xmm1, %xmm0
ja 0x30622
movss 0x2197f(%rip), %xmm0    # 0x51f9c
ucomiss %xmm0, %xmm1
jbe 0x3062a
movss %xmm0, 0x1c4(%rdi)
movss 0x1c8(%rdi), %xmm1
movss 0x1ec6a(%rip), %xmm0    # 0x4f2a4
ucomiss %xmm1, %xmm0
ja 0x3064c
movss 0x22cc9(%rip), %xmm0    # 0x53310
ucomiss %xmm0, %xmm1
jbe 0x30654
movss %xmm0, 0x1c8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: gib_think
void gib_think (edict_t *self)
{
	self->s.frame++;
	self->nextthink = level.time + FRAMETIME;

	if (self->s.frame == 10)
	{
		self->think = G_FreeEdict;
		self->nextthink = level.time + 8 + random()*10;
	}
}

// Assembly:
movl 0x38(%rdi), %eax
incl %eax
movl %eax, 0x38(%rdi)
movq 0x3673c(%rip), %rcx     # 0x66da0
movss 0x4(%rcx), %xmm1
movss 0x1ec1f(%rip), %xmm0    # 0x4f290
addss %xmm1, %xmm0
movss %xmm0, 0x200(%rdi)
cmpl $0xa, %eax
jne 0x306d7
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x35d9f(%rip), %rax     # 0x66430
movq %rax, 0x210(%rdi)
addss 0x1e858(%rip), %xmm1    # 0x4eef8
movss %xmm1, 0xc(%rsp)
callq 0x19bf0
andl $0x7fff, %eax           # imm = 0x7FFF
cvtsi2ss %eax, %xmm0
divss 0x1ebcc(%rip), %xmm0    # 0x4f288
mulss 0x1e850(%rip), %xmm0    # 0x4ef14
addss 0xc(%rsp), %xmm0
movss %xmm0, 0x200(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: gib_touch
void gib_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	vec3_t	normal_angles, right;

	if (!self->groundentity)
		return;

	self->touch = NULL;

	if (plane)
	{
		gi.sound (self, CHAN_VOICE, gi.soundindex ("misc/fhit3.wav"), 1, ATTN_NORM, 0);

		vectoangles (plane->normal, normal_angles);
		AngleVectors (normal_angles, NULL, right, NULL);
		vectoangles (right, self->s.angles);

		if (self->s.modelindex == sm_meat_index)
		{
			self->s.frame++;
			self->think = gib_think;
			self->nextthink = level.time + FRAMETIME;
		}
	}
}

// Assembly:
cmpq $0x0, 0x2b8(%rdi)
je 0x307a8
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
andq $0x0, 0x220(%rdi)
testq %rdx, %rdx
je 0x3079f
movq 0x35ef3(%rip), %rax     # 0x66600
movq 0x20(%rax), %r15
leaq 0x22df8(%rip), %rdi     # 0x53510
callq *0x48(%rax)
pushq $0x2
popq %rsi
movss 0x1e802(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r15
leaq 0x14(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x19240
leaq 0x8(%rsp), %r14
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x183d0
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x19240
movl 0x28(%rbx), %eax
movq 0x36882(%rip), %rcx     # 0x66ff0
cmpl (%rcx), %eax
jne 0x3079f
incl 0x38(%rbx)
movq 0x3649c(%rip), %rax     # 0x66c18
movq %rax, 0x210(%rbx)
movq 0x36616(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1eaf9(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ThrowHead
void ThrowHead (edict_t *self, char *gibname, int damage, int type)
{
	vec3_t	vd;
	float	vscale;

	self->s.skinnum = 0;
	self->s.frame = 0;
	VectorClear (self->mins);
	VectorClear (self->maxs);

	self->s.modelindex2 = 0;
	gi.setmodel (self, gibname);
	self->solid = SOLID_NOT;
	self->s.effects |= EF_GIB;
	self->s.effects &= ~EF_FLIES;
	self->s.sound = 0;
	self->flags |= FL_NO_KNOCKBACK;
	self->svflags &= ~SVF_MONSTER;
	self->takedamage = DAMAGE_YES;
	self->die = gib_die;

	if (type == GIB_ORGANIC)
	{
		self->movetype = MOVETYPE_TOSS;
		self->touch = gib_touch;
		vscale = 0.5;
	}
	else
	{
		self->movetype = MOVETYPE_BOUNCE;
		vscale = 1.0;
	}

	VelocityForDamage (damage, vd);
	VectorMA (self->velocity, vscale, vd, self->velocity);
	ClipGibVelocity (self);

	self->avelocity[YAW] = crandom()*600;

	self->think = G_FreeEdict;
	self->nextthink = level.time + 10 + random()*10;

	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andq $0x0, 0x38(%rdi)
movl %ecx, %r14d
andl $0x0, 0x2c(%rdi)
movl %edx, %ebp
xorps %xmm0, %xmm0
movups %xmm0, 0xcc(%rdi)
andq $0x0, 0xdc(%rdi)
movq 0x35b4d(%rip), %r15     # 0x66600
callq *0x58(%r15)
andl $0x0, 0x108(%rbx)
movl $0xffffbffd, %eax       # imm = 0xFFFFBFFD
andl 0x40(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x40(%rbx)
andl $0x0, 0x4c(%rbx)
orb $0x8, 0x11d(%rbx)
andb $-0x5, 0xc8(%rbx)
movl $0x1, 0x27c(%rbx)
movq 0x36149(%rip), %rax     # 0x66c38
movq %rax, 0x238(%rbx)
testl %r14d, %r14d
je 0x30b0d
movss 0x1e425(%rip), %xmm0    # 0x4ef28
movss %xmm0, 0x8(%rsp)
pushq $0x9
jmp 0x30b2b
movq 0x35b14(%rip), %rax     # 0x66628
movq %rax, 0x220(%rbx)
movss 0x1f8dd(%rip), %xmm0    # 0x50400
movss %xmm0, 0x8(%rsp)
pushq $0x7
popq %rax
movl %eax, 0x118(%rbx)
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x197c0
leaq 0x1c0(%rbx), %rdi
movss 0x8(%rsp), %xmm0
movq %r14, %rsi
movq %rdi, %rdx
callq 0x19940
movq %rbx, %rdi
callq 0x19170
callq 0x19bf0
movl $0x7fff, %ebp           # imm = 0x7FFF
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1e70f(%rip), %xmm0    # 0x4f288
cvtss2sd %xmm0, %xmm0
addsd 0x21073(%rip), %xmm0    # 0x51bf8
addsd %xmm0, %xmm0
mulsd 0x227a7(%rip), %xmm0    # 0x53338
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1d0(%rbx)
movq 0x3588c(%rip), %rax     # 0x66430
movq %rax, 0x210(%rbx)
movq 0x361ee(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1e355(%rip), %xmm0    # 0x4ef14
movss %xmm0, 0x8(%rsp)
callq 0x19bf0
andl %ebp, %eax
cvtsi2ss %eax, %xmm0
divss 0x1e6b0(%rip), %xmm0    # 0x4f288
mulss 0x1e334(%rip), %xmm0    # 0x4ef14
addss 0x8(%rsp), %xmm0
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
callq *0x90(%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: ThrowClientHead
void ThrowClientHead (edict_t *self, int damage)
{
	vec3_t	vd;
	char	*gibname;

	if (rand()&1)
	{
		gibname = "models/objects/gibs/head2/tris.md2";
		self->s.skinnum = 1;		// second skin is player
	}
	else
	{
		gibname = "models/objects/gibs/skull/tris.md2";
		self->s.skinnum = 0;
	}

	self->s.origin[2] += 32;
	self->s.frame = 0;
	gi.setmodel (self, gibname);
	VectorSet (self->mins, -16, -16, 0);
	VectorSet (self->maxs, 16, 16, 16);

	self->takedamage = DAMAGE_NO;
	self->solid = SOLID_NOT;
	self->s.effects = EF_GIB;
	self->s.sound = 0;
	self->flags |= FL_NO_KNOCKBACK;

	self->movetype = MOVETYPE_BOUNCE;
	VelocityForDamage (damage, vd);
	VectorAdd (self->velocity, vd, self->velocity);

	if (self->client)	// bodies in the queue don't have a client anymore
	{
		self->client->anim_priority = ANIM_DEATH;
		self->client->anim_end = self->s.frame;
	}
	else
	{
		self->think = NULL;
		self->nextthink = 0;
	}

	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x19bf0
andl $0x1, %eax
leaq 0x22921(%rip), %rcx     # 0x53542
leaq 0x228f7(%rip), %rsi     # 0x5351f
cmoveq %rcx, %rsi
movl %eax, 0x3c(%rbx)
movss 0xc(%rbx), %xmm0
addss 0x1e810(%rip), %xmm0    # 0x4f44c
movss %xmm0, 0xc(%rbx)
andl $0x0, 0x38(%rbx)
movq 0x359b4(%rip), %r15     # 0x66600
movq %rbx, %rdi
callq *0x58(%r15)
movaps 0x226f6(%rip), %xmm0    # 0x53350
movups %xmm0, 0xcc(%rbx)
movsd 0x226f7(%rip), %xmm0    # 0x53360
movsd %xmm0, 0xdc(%rbx)
andl $0x0, 0x27c(%rbx)
andl $0x0, 0x108(%rbx)
movl $0x2, 0x40(%rbx)
andl $0x0, 0x4c(%rbx)
orb $0x8, 0x11d(%rbx)
movl $0x9, 0x118(%rbx)
leaq 0x8(%rsp), %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0x197c0
movsd 0x1c0(%rbx), %xmm0
movsd (%r14), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, 0x1c0(%rbx)
movss 0x1c8(%rbx), %xmm0
addss 0x8(%r14), %xmm0
movss %xmm0, 0x1c8(%rbx)
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x30cf5
movl $0x5, 0xef8(%rax)
movl 0x38(%rbx), %ecx
movl %ecx, 0xef4(%rax)
jmp 0x30d04
andq $0x0, 0x210(%rbx)
andl $0x0, 0x200(%rbx)
movq %rbx, %rdi
callq *0x90(%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: BecomeExplosion1
void BecomeExplosion1 (edict_t *self)
{
	if (!self->dontfree)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_EXPLOSION1);
		gi.WritePosition (self->s.origin);
		gi.multicast (self->s.origin, MULTICAST_PVS);
		
		G_FreeEdict (self);
	}
}

// Assembly:
cmpl $0x0, 0x49c(%rdi)
je 0x30f40
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x356b1(%rip), %r15     # 0x66600
pushq $0x3
popq %rdi
callq *0xc8(%r15)
pushq $0x5
popq %rdi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: BecomeExplosion2
void BecomeExplosion2 (edict_t *self)
{
	if (!self->dontfree)
	{
		gi.WriteByte (svc_temp_entity);
		gi.WriteByte (TE_EXPLOSION2);
		gi.WritePosition (self->s.origin);
		gi.multicast (self->s.origin, MULTICAST_PVS);

		G_FreeEdict (self);
	}
}

// Assembly:
cmpl $0x0, 0x49c(%rdi)
je 0x30f95
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3565c(%rip), %r15     # 0x66600
pushq $0x3
popq %rdi
callq *0xc8(%r15)
pushq $0x6
popq %rdi
callq *0xc8(%r15)
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq *0xf0(%r15)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq *0xb0(%r15)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: path_corner_touch
void path_corner_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	vec3_t		v;
	edict_t		*next;

	if (other->movetarget != self)
		return;
	
	if (other->enemy)
		return;

	if (self->pathtarget)
	{
		char *savetarget;

		savetarget = self->target;
		self->target = self->pathtarget;
		G_UseTargets (self, other);
		self->target = savetarget;
	}

	if (self->target)
		next = G_PickTarget(self->target);
	else
		next = NULL;

	if ((next) && (next->spawnflags & 1))
	{
		VectorCopy (next->s.origin, v);
		v[2] += next->mins[2];
		v[2] -= other->mins[2];
		VectorCopy (v, other->s.origin);
		next = G_PickTarget(next->target);
		other->s.event = EV_OTHER_TELEPORT;
	}

	other->goalentity = other->movetarget = next;

	if (self->wait)
	{
		other->monsterinfo.pausetime = level.time + self->wait;
		other->monsterinfo.stand (other);
		return;
	}

	if (!other->movetarget)
	{
		other->monsterinfo.pausetime = level.time + 100000000;
		other->monsterinfo.stand (other);
	}
	else
	{
		VectorSubtract (other->goalentity->s.origin, other->s.origin, v);
		other->ideal_yaw = vectoyaw (v);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq %rdi, 0x1f0(%rsi)
jne 0x30ffc
cmpq $0x0, 0x2a0(%rsi)
je 0x31006
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdi, %rbx
movq 0x150(%rdi), %r14
movq 0x170(%rdi), %rax
testq %rax, %rax
je 0x31038
movq %rax, 0x150(%rbx)
movq %rbx, %rdi
movq %rsi, %r15
callq 0x19ac0
movq %r15, %rsi
movq %r14, 0x150(%rbx)
testq %r14, %r14
je 0x3109f
movq %rsi, %r15
movq %r14, %rdi
callq 0x18380
testq %rax, %rax
je 0x310a3
testb $0x1, 0x140(%rax)
movq %r15, %rsi
je 0x310a8
movss 0xc(%rax), %xmm0
addss 0xd4(%rax), %xmm0
movaps %xmm0, %xmm1
subss 0xd4(%rsi), %xmm1
movsd 0x4(%rax), %xmm2
movss %xmm0, 0x8(%rsp)
movsd %xmm2, 0x4(%rsi)
movss %xmm1, 0xc(%rsi)
movq 0x150(%rax), %rdi
callq 0x18380
movq %r15, %rsi
movl $0x7, 0x50(%r15)
jmp 0x310a8
xorl %eax, %eax
jmp 0x310a8
xorl %eax, %eax
movq %r15, %rsi
movq %rax, 0x1f0(%rsi)
movq %rax, 0x1e8(%rsi)
movss 0x2f8(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x310c8
jnp 0x310ee
movq 0x35cd1(%rip), %rax     # 0x66da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x420(%rsi)
movq %rsi, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x3d0(%rsi)
testq %rax, %rax
je 0x3112a
movsd 0x4(%rax), %xmm0
movsd 0x4(%rsi), %xmm1
subps %xmm1, %xmm0
movq %rsp, %rdi
movlps %xmm0, (%rdi)
movss 0xc(%rax), %xmm0
subss 0xc(%rsi), %xmm0
movss %xmm0, 0x8(%rdi)
movq %rsi, %rbx
callq 0x18070
movss %xmm0, 0x1fc(%rbx)
jmp 0x30ffc
movq 0x35c6f(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x221da(%rip), %xmm0    # 0x53318
jmp 0x310d4
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_path_corner
void SP_path_corner (edict_t *self)
{
	if (!self->targetname)
	{
		gi.dprintf ("path_corner with no targetname at %s\n", vtos(self->s.origin));
		G_FreeEdict (self);
		return;
	}

	self->solid = SOLID_TRIGGER;
	self->touch = path_corner_touch;
	VectorSet (self->mins, -8, -8, -8);
	VectorSet (self->maxs, 8, 8, 8);
	self->svflags |= SVF_NOCLIENT;
	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x158(%rdi)
je 0x311a5
movl $0x1, 0x108(%rbx)
movq 0x35c8e(%rip), %rax     # 0x66df0
movq %rax, 0x220(%rbx)
movaps 0x22240(%rip), %xmm0    # 0x533b0
movups %xmm0, 0xcc(%rbx)
movsd 0x22241(%rip), %xmm0    # 0x533c0
movsd %xmm0, 0xdc(%rbx)
orb $0x1, 0xc8(%rbx)
movq 0x3546b(%rip), %rax     # 0x66600
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
movq 0x35454(%rip), %rax     # 0x66600
movq 0x8(%rax), %r14
leaq 0x4(%rbx), %rdi
callq 0x19200
leaq 0x223ac(%rip), %rdi     # 0x5356c
movq %rax, %rsi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19c50
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: point_combat_touch
void point_combat_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	edict_t	*activator;

	if (other->movetarget != self)
		return;

	if (self->target)
	{
		other->target = self->target;
		other->goalentity = other->movetarget = G_PickTarget(other->target);
		if (!other->goalentity)
		{
			gi.dprintf("%s at %s target %s does not exist\n", self->classname, vtos(self->s.origin), self->target);
			other->movetarget = self;
		}
		self->target = NULL;
	}
	else if ((self->spawnflags & 1) && !(other->flags & (FL_SWIM|FL_FLY)))
	{
		other->monsterinfo.pausetime = level.time + 100000000;
		other->monsterinfo.aiflags |= AI_STAND_GROUND;
		other->monsterinfo.stand (other);
	}

	if (other->movetarget == self)
	{
		other->target = NULL;
		other->movetarget = NULL;
		other->goalentity = other->enemy;
		other->monsterinfo.aiflags &= ~AI_COMBAT_POINT;
	}

	if (self->pathtarget)
	{
		char *savetarget;

		savetarget = self->target;
		self->target = self->pathtarget;
		if (other->enemy && other->enemy->client)
			activator = other->enemy;
		else if (other->oldenemy && other->oldenemy->client)
			activator = other->oldenemy;
		else if (other->activator && other->activator->client)
			activator = other->activator;
		else
			activator = other;
		G_UseTargets (self, activator);
		self->target = savetarget;
	}
}

// Assembly:
cmpq %rdi, 0x1f0(%rsi)
je 0x311e1
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0x31267
movq %rdi, 0x150(%r14)
callq 0x18380
movq %rax, 0x1f0(%r14)
movq %rax, 0x1e8(%r14)
testq %rax, %rax
jne 0x31258
movq 0x353df(%rip), %rax     # 0x66600
movq 0x8(%rax), %r12
movq 0x138(%rbx), %r15
leaq 0x4(%rbx), %rdi
callq 0x19200
movq 0x150(%rbx), %rcx
leaq 0x2234f(%rip), %rdi     # 0x53592
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq *%r12
movq %rbx, 0x1f0(%r14)
movq %rbx, %rax
andq $0x0, 0x150(%rbx)
cmpq %rbx, %rax
jne 0x312a4
jmp 0x3127e
testb $0x1, 0x140(%rbx)
je 0x3127e
testb $0x3, 0x11c(%r14)
je 0x31315
andq $0x0, 0x150(%r14)
andq $0x0, 0x1f0(%r14)
movq 0x2a0(%r14), %rax
movq %rax, 0x1e8(%r14)
andb $-0x11, 0x3c1(%r14)
movq 0x170(%rbx), %rax
testq %rax, %rax
je 0x31309
movq 0x150(%rbx), %r15
movq %rax, 0x150(%rbx)
movq 0x2a0(%r14), %rsi
testq %rsi, %rsi
je 0x312d1
cmpq $0x0, 0x58(%rsi)
jne 0x312fa
movq 0x2a8(%r14), %rsi
testq %rsi, %rsi
je 0x312e4
cmpq $0x0, 0x58(%rsi)
jne 0x312fa
movq 0x2b0(%r14), %rsi
testq %rsi, %rsi
je 0x312f7
cmpq $0x0, 0x58(%rsi)
jne 0x312fa
movq %r14, %rsi
movq %rbx, %rdi
callq 0x19ac0
movq %r15, 0x150(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x35a84(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x21fef(%rip), %xmm0    # 0x53318
movss %xmm0, 0x420(%r14)
orb $0x1, 0x3c0(%r14)
movq %r14, %rdi
callq *0x3d0(%r14)
movq 0x1f0(%r14), %rax
jmp 0x31260
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_point_combat
void SP_point_combat (edict_t *self)
{
	if (deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}
	self->solid = SOLID_TRIGGER;
	self->touch = point_combat_touch;
	VectorSet (self->mins, -8, -8, -16);
	VectorSet (self->maxs, 8, 8, 16);
	self->svflags = SVF_NOCLIENT;
	gi.linkentity (self);
}

// Assembly:
movq 0x35b69(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x31369
jnp 0x3136e
jmp 0x19c50
pushq $0x1
popq %rax
movl %eax, 0x108(%rdi)
movq 0x35b0a(%rip), %rcx     # 0x66e88
movq %rcx, 0x220(%rdi)
movaps 0x22044(%rip), %xmm0    # 0x533d0
movups %xmm0, 0xcc(%rdi)
movsd 0x22045(%rip), %xmm0    # 0x533e0
movsd %xmm0, 0xdc(%rdi)
movl %eax, 0xc8(%rdi)
movq 0x35250(%rip), %rax     # 0x66600
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_viewthing
void SP_viewthing(edict_t *ent)
{
	gi.dprintf ("viewthing spawned\n");

	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	ent->s.renderfx = RF_FRAMELERP;
	VectorSet (ent->mins, -16, -16, -24);
	VectorSet (ent->maxs, 16, 16, 32);
	ent->s.modelindex = gi.modelindex ("models/objects/banner/tris.md2");
	gi.linkentity (ent);
	ent->nextthink = level.time + 0.5;
	ent->think = TH_viewthing;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x35211(%rip), %r14     # 0x66600
leaq 0x221bf(%rip), %rdi     # 0x535b5
xorl %eax, %eax
callq *0x8(%r14)
andl $0x0, 0x118(%rbx)
movl $0x2, 0x108(%rbx)
movl $0x40, 0x44(%rbx)
movaps 0x21fd5(%rip), %xmm0    # 0x533f0
movups %xmm0, 0xcc(%rbx)
movsd 0x21fd6(%rip), %xmm0    # 0x53400
movsd %xmm0, 0xdc(%rbx)
leaq 0x2218f(%rip), %rdi     # 0x535c8
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movq %rbx, %rdi
callq *0x90(%r14)
movq 0x3594f(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1efa2(%rip), %xmm0    # 0x50400
movss %xmm0, 0x200(%rbx)
movq 0x34fdb(%rip), %rax     # 0x66448
movq %rax, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_light
void SP_light (edict_t *self)
{
	// no targeted lights in deathmatch, because they cause global messages
	if (!self->targetname || deathmatch->value)
	{
		G_FreeEdict (self);
		return;
	}

	if (self->style >= 32)
	{
		self->use = light_use;
		if (self->spawnflags & START_OFF)
			gi.configstring (CS_LIGHTS+self->style, "a");
		else
			gi.configstring (CS_LIGHTS+self->style, "m");
	}
}

// Assembly:
cmpq $0x0, 0x158(%rdi)
je 0x19c50
movq 0x35a08(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x314ca
jnp 0x314cf
jmp 0x19c50
movl 0x32c(%rdi), %eax
cmpl $0x20, %eax
jl 0x3150a
leaq 0x35(%rip), %rcx        # 0x31516
movq %rcx, 0x228(%rdi)
addl $0x320, %eax            # imm = 0x320
testb $0x1, 0x140(%rdi)
movq 0x35105(%rip), %rcx     # 0x66600
movq 0x30(%rcx), %rcx
jne 0x3150b
leaq 0x1cd57(%rip), %rsi     # 0x4e25f
jmp 0x31512
retq
leaq 0x1d1b6(%rip), %rsi     # 0x4e6c8
movl %eax, %edi
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: light_use
static void light_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->spawnflags & START_OFF)
	{
		gi.configstring (CS_LIGHTS+self->style, "m");
		self->spawnflags &= ~START_OFF;
	}
	else
	{
		gi.configstring (CS_LIGHTS+self->style, "a");
		self->spawnflags |= START_OFF;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x320, %edi            # imm = 0x320
movq 0x350da(%rip), %rax     # 0x66600
movq 0x30(%rax), %rax
addl 0x32c(%rbx), %edi
testb $0x1, 0x140(%rbx)
jne 0x3154d
leaq 0x1d188(%rip), %rsi     # 0x4e6c8
callq *%rax
movl 0x140(%rbx), %eax
orl $0x1, %eax
jmp 0x3155f
leaq 0x1cd0b(%rip), %rsi     # 0x4e25f
callq *%rax
movl 0x140(%rbx), %eax
andl $-0x2, %eax
movl %eax, 0x140(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_wall_use
void func_wall_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (self->solid == SOLID_NOT)
	{
		self->solid = SOLID_BSP;
		self->svflags &= ~SVF_NOCLIENT;
		KillBox (self);
	}
	else
	{
		self->solid = SOLID_NOT;
		self->svflags |= SVF_NOCLIENT;
	}
	gi.linkentity (self);

	if (!(self->spawnflags & 2))
		self->use = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x108(%rdi)
je 0x31584
andl $0x0, 0x108(%rbx)
orb $0x1, 0xc8(%rbx)
jmp 0x3159d
movl $0x3, 0x108(%rbx)
andb $-0x2, 0xc8(%rbx)
movq %rbx, %rdi
callq 0x18b30
movq 0x3505c(%rip), %rax     # 0x66600
movq %rbx, %rdi
callq *0x90(%rax)
testb $0x2, 0x140(%rbx)
jne 0x315be
andq $0x0, 0x228(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_wall
void SP_func_wall (edict_t *self)
{
	self->movetype = MOVETYPE_PUSH;
	gi.setmodel (self, self->model);

	if (self->spawnflags & 8)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 16)
		self->s.effects |= EF_ANIM_ALLFAST;

	// just a wall
	if ((self->spawnflags & 7) == 0)
	{
		self->solid = SOLID_BSP;
		gi.linkentity (self);
		return;
	}

	// it must be TRIGGER_SPAWN
	if (!(self->spawnflags & 1))
	{
//		gi.dprintf("func_wall missing TRIGGER_SPAWN\n");
		self->spawnflags |= 1;
	}

	// yell if the spawnflags are odd
	if (self->spawnflags & 4)
	{
		if (!(self->spawnflags & 2))
		{
			gi.dprintf("func_wall START_ON without TOGGLE\n");
			self->spawnflags |= 2;
		}
	}

	self->use = func_wall_use;
	if (self->spawnflags & 4)
	{
		self->solid = SOLID_BSP;
	}
	else
	{
		self->solid = SOLID_NOT;
		self->svflags |= SVF_NOCLIENT;
	}
	gi.linkentity (self);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x118(%rdi)
movq 0x35028(%rip), %rax     # 0x66600
movq 0x120(%rdi), %rsi
movq %rax, %r14
callq *0x58(%rax)
movl 0x140(%rbx), %eax
testb $0x8, %al
je 0x315f3
orb $0x10, 0x41(%rbx)
testb $0x10, %al
je 0x315fb
orb $0x20, 0x41(%rbx)
pushq $0x3
popq %rbp
testb $0x7, %al
je 0x31650
testb $0x1, %al
jne 0x3160f
orl $0x1, %eax
movl %eax, 0x140(%rbx)
movl %eax, %ecx
andl $0x6, %ecx
cmpl $0x4, %ecx
jne 0x31635
leaq 0x21fc7(%rip), %rdi     # 0x535e7
xorl %eax, %eax
callq *0x8(%r14)
movl 0x140(%rbx), %eax
orl $0x2, %eax
movl %eax, 0x140(%rbx)
movq 0x34ddc(%rip), %rcx     # 0x66418
movq %rcx, 0x228(%rbx)
testb $0x4, %al
jne 0x31650
orb $0x1, 0xc8(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x108(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_object_touch
void func_object_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	// only squash thing we fall on top of
	if (!plane)
		return;
	if (plane->normal[2] < 1.0)
		return;
	if (other->takedamage == DAMAGE_NO)
		return;
	T_Damage (other, self, self, vec3_origin, self->s.origin, vec3_origin, self->dmg, 1, 0, MOD_CRUSH);
}

// Assembly:
testq %rdx, %rdx
je 0x316b6
movss 0x1d8b5(%rip), %xmm0    # 0x4ef28
ucomiss 0x8(%rdx), %xmm0
ja 0x316b6
cmpl $0x0, 0x27c(%rsi)
je 0x316b6
pushq %rax
movq %rdi, %rax
leaq 0x4(%rdi), %r8
movl 0x280(%rdi), %r10d
movq 0x350d0(%rip), %rcx     # 0x66768
movq %rsi, %rdi
movq %rax, %rsi
movq %rax, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq %r10
callq 0x19260
addq $0x20, %rsp
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_object_use
void func_object_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->use = NULL;
	KillBox (self);
	func_object_release (self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3, 0x108(%rdi)
andb $-0x2, 0xc8(%rdi)
andq $0x0, 0x228(%rdi)
callq 0x18b30
movl $0x7, 0x118(%rbx)
movq 0x3582d(%rip), %rax     # 0x66f30
movq %rax, 0x220(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_object
void SP_func_object (edict_t *self)
{
	gi.setmodel (self, self->model);

	self->mins[0] += 1;
	self->mins[1] += 1;
	self->mins[2] += 1;
	self->maxs[0] -= 1;
	self->maxs[1] -= 1;
	self->maxs[2] -= 1;

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

	if (self->spawnflags == 0)
	{
		self->solid = SOLID_BSP;
		self->movetype = MOVETYPE_PUSH;
		self->think = func_object_release;
		self->nextthink = level.time + 2 * FRAMETIME;
	}
	else
	{
		self->solid = SOLID_NOT;
		self->movetype = MOVETYPE_PUSH;
		self->use = func_object_use;
		self->svflags |= SVF_NOCLIENT;
	}

	if (self->spawnflags & 2)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 4)
		self->s.effects |= EF_ANIM_ALLFAST;

	self->clipmask = MASK_MONSTERSOLID;

	gi.linkentity (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x34ee6(%rip), %rax     # 0x66600
movq 0x120(%rdi), %rsi
movq %rax, %r14
callq *0x58(%rax)
movups 0xcc(%rbx), %xmm0
addps 0x21cdb(%rip), %xmm0    # 0x53410
movups %xmm0, 0xcc(%rbx)
movsd 0xdc(%rbx), %xmm0
addps 0x21cd5(%rip), %xmm0    # 0x53420
movlps %xmm0, 0xdc(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x31765
movl $0x64, 0x280(%rbx)
movl 0x140(%rbx), %eax
testl %eax, %eax
je 0x317a7
andl $0x0, 0x108(%rbx)
movl $0x2, 0x118(%rbx)
movq 0x355d1(%rip), %rcx     # 0x66d58
movq %rcx, 0x228(%rbx)
orb $0x1, 0xc8(%rbx)
testb $0x2, %al
je 0x3179d
orb $0x10, 0x41(%rbx)
testb $0x4, %al
je 0x317e5
orb $0x20, 0x41(%rbx)
jmp 0x317e5
movl $0x3, 0x108(%rbx)
movl $0x2, 0x118(%rbx)
movq 0x34e26(%rip), %rax     # 0x665e8
movq %rax, 0x210(%rbx)
movq 0x355d0(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x207cb(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rbx)
movl $0x2020003, 0x10c(%rbx) # imm = 0x2020003
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_explosive_respawn
void func_explosive_respawn (edict_t *self)
{
	gi.sound (self, CHAN_AUTO, gi.soundindex ("tank/thud.wav"), 1, ATTN_NORM, 0);
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->takedamage = DAMAGE_YES;
	self->think = 0;
	KillBox (self);
	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x34def(%rip), %rax     # 0x66600
movq 0x20(%rax), %r14
movq %rax, %r15
leaq 0x21deb(%rip), %rdi     # 0x5360a
callq *0x48(%rax)
movss 0x1d6fe(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movaps %xmm0, %xmm1
callq *%r14
movl $0x3, 0x108(%rbx)
andb $-0x2, 0xc8(%rbx)
movl $0x1, 0x27c(%rbx)
andq $0x0, 0x210(%rbx)
movq %rbx, %rdi
callq 0x18b30
movq %rbx, %rdi
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: func_explosive_spawn
void func_explosive_spawn (edict_t *self, edict_t *other, edict_t *activator)
{
	self->solid = SOLID_BSP;
	self->svflags &= ~SVF_NOCLIENT;
	self->use = NULL;
	KillBox (self);
	gi.linkentity (self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3, 0x108(%rdi)
andb $-0x2, 0xc8(%rdi)
andq $0x0, 0x228(%rdi)
callq 0x18b30
movq 0x349f1(%rip), %rax     # 0x66600
movq %rbx, %rdi
popq %rbx
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_func_explosive
void SP_func_explosive (edict_t *self)
{
	/*
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (self);
		return;
	}
	*/

	// LM_JORM
	if (!self->speed)
	{	// auto-remove for deathmatch
		G_FreeEdict (self);
		return;
	}
	// LM_JORM

	self->movetype = MOVETYPE_PUSH;

	gi.modelindex ("models/objects/debris1/tris.md2");
	gi.modelindex ("models/objects/debris2/tris.md2");

	gi.setmodel (self, self->model);

	if (self->spawnflags & 1)
	{
		self->svflags |= SVF_NOCLIENT;
		self->solid = SOLID_NOT;
		self->use = func_explosive_spawn;
	}
	else
	{
		self->solid = SOLID_BSP;
		if (self->targetname)
			self->use = func_explosive_use;
	}

	if (self->spawnflags & 2)
		self->s.effects |= EF_ANIM_ALL;
	if (self->spawnflags & 4)
		self->s.effects |= EF_ANIM_ALLFAST;

	if (self->use != func_explosive_use)
	{
//		if (!self->health)
		//surt health might be less than 0 on respawn
		if (self->health <= 0)
			self->health = 100;
		self->die = func_explosive_explode;
		self->takedamage = DAMAGE_YES;
	}

	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movss 0x190(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x31c33
jnp 0x31c92
movl $0x2, 0x118(%rbx)
movq 0x349bc(%rip), %r15     # 0x66600
leaq 0x219cd(%rip), %rdi     # 0x53618
callq *0x40(%r15)
leaq 0x20b4b(%rip), %rdi     # 0x527a1
callq *0x40(%r15)
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %r14
callq *0x58(%r15)
movl 0x140(%rbx), %eax
testb $0x1, %al
jne 0x31c9f
movl $0x3, 0x108(%rbx)
cmpq $0x0, 0x158(%rbx)
je 0x31cbb
movq 0x35070(%rip), %rcx     # 0x66d00
jmp 0x31cb4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
orb $0x1, 0xc8(%rbx)
andl $0x0, 0x108(%rbx)
movq 0x35074(%rip), %rcx     # 0x66d28
movq %rcx, 0x228(%rbx)
testb $0x2, %al
je 0x31cc3
orb $0x10, 0x41(%rbx)
testb $0x4, %al
je 0x31ccb
orb $0x20, 0x41(%rbx)
movq 0x228(%rbx), %rax
cmpq 0x35027(%rip), %rax     # 0x66d00
je 0x31d06
cmpl $0x0, 0x254(%rbx)
jg 0x31cee
movl $0x64, 0x254(%rbx)
movq 0x3498b(%rip), %rax     # 0x66680
movq %rax, 0x238(%rbx)
movl $0x1, 0x27c(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: barrel_touch
void barrel_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)

{
	float	ratio;
	vec3_t	v;

	if ((!other->groundentity) || (other->groundentity == self))
		return;

	ratio = (float)other->mass / (float)self->mass;
	VectorSubtract (self->s.origin, other->s.origin, v);
	M_walkmove (self, vectoyaw(v), 20 * ratio * FRAMETIME);
}

// Assembly:
movq 0x2b8(%rsi), %rax
testq %rax, %rax
sete %cl
cmpq %rdi, %rax
sete %al
orb %cl, %al
jne 0x31d9c
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtsi2ssl 0x1d8(%rsi), %xmm1
cvtsi2ssl 0x1d8(%rdi), %xmm0
divss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movsd 0x4(%rdi), %xmm0
movsd 0x4(%rsi), %xmm1
subps %xmm1, %xmm0
leaq 0x10(%rsp), %rdi
movlps %xmm0, (%rdi)
movss 0xc(%rbx), %xmm0
subss 0xc(%rsi), %xmm0
movss %xmm0, 0x8(%rdi)
callq 0x18070
movss 0xc(%rsp), %xmm1
mulss 0x1deb9(%rip), %xmm1    # 0x4fc40
mulss 0x1d501(%rip), %xmm1    # 0x4f290
movq %rbx, %rdi
callq 0x184c0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: barrel_delay
void barrel_delay (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	self->takedamage = DAMAGE_NO;
	self->nextthink = level.time + 2 * FRAMETIME;
	self->think = barrel_explode;
	self->activator = attacker;
}

// Assembly:
andl $0x0, 0x27c(%rdi)
movq 0x344c7(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1f6c2(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rdi)
movq 0x34223(%rip), %rax     # 0x66b18
movq %rax, 0x210(%rdi)
movq %rdx, 0x2b0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_explobox
void SP_misc_explobox (edict_t *self)
{
	if (deathmatch->value)
	{	// auto-remove for deathmatch
		G_FreeEdict (self);
		return;
	}

	gi.modelindex ("models/objects/debris1/tris.md2");
	gi.modelindex ("models/objects/debris2/tris.md2");
	gi.modelindex ("models/objects/debris3/tris.md2");

	self->solid = SOLID_BBOX;
	self->movetype = MOVETYPE_STEP;

	self->model = "models/objects/barrels/tris.md2";
	self->s.modelindex = gi.modelindex (self->model);
	VectorSet (self->mins, -16, -16, 0);
	VectorSet (self->maxs, 16, 16, 40);

	if (!self->mass)
		self->mass = 400;
	if (!self->health)
		self->health = 10;
	if (!self->dmg)
		self->dmg = 150;

	self->die = barrel_delay;
	self->takedamage = DAMAGE_YES;
	self->monsterinfo.aiflags = AI_NOSTEP;

	self->touch = barrel_touch;

#ifdef MONSTERS_OK
	self->think = M_droptofloor;
#endif
	self->nextthink = level.time + 2 * FRAMETIME;

	gi.linkentity (self);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x345ad(%rip), %rax     # 0x66ec0
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32925
jnp 0x32932
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x19c50
movq 0x33cc7(%rip), %r15     # 0x66600
leaq 0x20cd8(%rip), %rdi     # 0x53618
callq *0x40(%r15)
leaq 0x1fe56(%rip), %rdi     # 0x527a1
callq *0x40(%r15)
leaq 0x20ce2(%rip), %rdi     # 0x53638
callq *0x40(%r15)
movl $0x2, 0x108(%rbx)
movl $0x5, 0x118(%rbx)
leaq 0x20ce3(%rip), %rdi     # 0x53658
movq %rdi, 0x120(%rbx)
movq %r15, %r14
callq *0x40(%r15)
movl %eax, 0x28(%rbx)
movaps 0x209c3(%rip), %xmm0    # 0x53350
movups %xmm0, 0xcc(%rbx)
movsd 0x20a94(%rip), %xmm0    # 0x53430
movsd %xmm0, 0xdc(%rbx)
cmpl $0x0, 0x1d8(%rbx)
jne 0x329b7
movl $0x190, 0x1d8(%rbx)     # imm = 0x190
cmpl $0x0, 0x254(%rbx)
jne 0x329ca
movl $0xa, 0x254(%rbx)
cmpl $0x0, 0x280(%rbx)
jne 0x329dd
movl $0x96, 0x280(%rbx)
movq 0x33f9c(%rip), %rax     # 0x66980
movq %rax, 0x238(%rbx)
movl $0x1, 0x27c(%rbx)
movl $0x400, 0x3c0(%rbx)     # imm = 0x400
movq 0x34502(%rip), %rax     # 0x66f08
movq %rax, 0x220(%rbx)
movq 0x3438c(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1f587(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_blackhole
void SP_misc_blackhole (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_NOT;
	VectorSet (ent->mins, -64, -64, 0);
	VectorSet (ent->maxs, 64, 64, 8);
	ent->s.modelindex = gi.modelindex ("models/objects/black/tris.md2");
	ent->s.renderfx = RF_TRANSLUCENT;
	ent->use = misc_blackhole_use;
	ent->think = misc_blackhole_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
andl $0x0, 0x108(%rdi)
movaps 0x209b7(%rip), %xmm0    # 0x53440
movups %xmm0, 0xcc(%rdi)
movsd 0x209b8(%rip), %xmm0    # 0x53450
movsd %xmm0, 0xdc(%rdi)
movq 0x33b59(%rip), %r14     # 0x66600
leaq 0x20bca(%rip), %rdi     # 0x53678
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0x20, 0x44(%rbx)
movq 0x33ae5(%rip), %rax     # 0x665a8
movq %rax, 0x228(%rbx)
movq 0x343bf(%rip), %rax     # 0x66e90
movq %rax, 0x210(%rbx)
movq 0x342c1(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1f4bc(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_eastertank
void SP_misc_eastertank (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -32, -32, -16);
	VectorSet (ent->maxs, 32, 32, 32);
	ent->s.modelindex = gi.modelindex ("models/monsters/tank/tris.md2");
	ent->s.frame = 254;
	ent->think = misc_eastertank_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x20907(%rip), %xmm0    # 0x53460
movups %xmm0, 0xcc(%rdi)
movsd 0x20908(%rip), %xmm0    # 0x53470
movsd %xmm0, 0xdc(%rdi)
movq 0x33a89(%rip), %r14     # 0x66600
leaq 0x20b18(%rip), %rdi     # 0x53696
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0xfe, 0x38(%rbx)
movq 0x33f2d(%rip), %rax     # 0x66ac0
movq %rax, 0x210(%rbx)
movq 0x341ff(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1f3fa(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_easterchick
void SP_misc_easterchick (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -32, -32, 0);
	VectorSet (ent->maxs, 32, 32, 32);
	ent->s.modelindex = gi.modelindex ("models/monsters/bitch/tris.md2");
	ent->s.frame = 208;
	ent->think = misc_easterchick_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x20865(%rip), %xmm0    # 0x53480
movups %xmm0, 0xcc(%rdi)
movsd 0x20846(%rip), %xmm0    # 0x53470
movsd %xmm0, 0xdc(%rdi)
movq 0x339c7(%rip), %r14     # 0x66600
leaq 0x20a74(%rip), %rdi     # 0x536b4
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0xd0, 0x38(%rbx)
movq 0x33b63(%rip), %rax     # 0x667b8
movq %rax, 0x210(%rbx)
movq 0x3413d(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1f338(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: SP_misc_easterchick2
void SP_misc_easterchick2 (edict_t *ent)
{
	ent->movetype = MOVETYPE_NONE;
	ent->solid = SOLID_BBOX;
	VectorSet (ent->mins, -32, -32, 0);
	VectorSet (ent->maxs, 32, 32, 32);
	ent->s.modelindex = gi.modelindex ("models/monsters/bitch/tris.md2");
	ent->s.frame = 248;
	ent->think = misc_easterchick2_think;
	ent->nextthink = level.time + 2 * FRAMETIME;
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x118(%rdi)
movl $0x2, 0x108(%rdi)
movaps 0x207a3(%rip), %xmm0    # 0x53480
movups %xmm0, 0xcc(%rdi)
movsd 0x20784(%rip), %xmm0    # 0x53470
movsd %xmm0, 0xdc(%rdi)
movq 0x33905(%rip), %r14     # 0x66600
leaq 0x209b2(%rip), %rdi     # 0x536b4
callq *0x40(%r14)
movl %eax, 0x28(%rbx)
movl $0xf8, 0x38(%rbx)
movq 0x336e1(%rip), %rax     # 0x663f8
movq %rax, 0x210(%rbx)
movq 0x3407b(%rip), %rax     # 0x66da0
movss 0x4(%rax), %xmm0
addss 0x1f276(%rip), %xmm0    # 0x51fa8
movss %xmm0, 0x200(%rbx)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O2/QwazyWabbitWOS[P]lmctf60/g_misc.c
// Function: commander_body_think
void commander_body_think (edict_t *self)
{
	if (++self->s.frame < 24)
		self->nextthink = level.time + FRAMETIME;
	else
		self->nextthink = 0;

	if (self->s.frame == 22)
		gi.sound (self, CHAN_BODY, gi.soundindex ("tank/thud.wav"), 1, ATTN_NORM, 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x38(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x38(%rdi)
cmpl $0x17, %ecx
jge 0x32dba
movq 0x34037(%rip), %rcx     # 0x66da0
movss 0x4(%rcx), %xmm0
addss 0x1c51a(%rip), %xmm0    # 0x4f290
movss %xmm0, 0x200(%rbx)
cmpl $0x16, %eax
jne 0x32dc1
movq 0x33876(%rip), %rax     # 0x66600
movq 0x20(%rax), %r14
leaq 0x20875(%rip), %rdi     # 0x5360a
callq *0x48(%rax)
pushq $0x4
popq %rsi
movss 0x1c185(%rip), %xmm0    # 0x4ef28
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl %eax, %edx
movaps %xmm0, %xmm1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
andl $0x0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq