LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Referee_f
void Cmd_Referee_f (edict_t *ent)
{
	char *p;

	p = gi.args();

	// check for a password
	//surt adjusted this so that a blank ref password doesn't deny access to rcon,
	//and created rcon access mode
	if (strcmp(rconpassword->string, p) == 0)
	{
		//deny access if password is blank on server
		if (!strlen(rconpassword->string))
		{
			ctf_SafePrint(ent, PRINT_HIGH, "Rcon Mode is off\n");
			return;
		}

		ctf_SafePrint(ent, PRINT_HIGH, "You are now an Rcon\n");
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_REFEREE;
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_RCON;
		Ctf_Menu(ent);
	}

	else if (strcmp(refpassword->string, p) == 0)
	{
		//deny access if password is blank on server
		if (!strlen(refpassword->string))
		{
			ctf_SafePrint(ent, PRINT_HIGH, "Referee Mode is off\n");
			return;
		}
		ctf_SafePrint(ent, PRINT_HIGH, "You are now a Referee\n");
		ent->client->ctf.extra_flags |= CTF_EXTRAFLAGS_REFEREE;
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_RCON;
		Ctf_Menu(ent);
	}
	else
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Incorrect Referee Password\n");
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_REFEREE;
		ent->client->ctf.extra_flags &= ~CTF_EXTRAFLAGS_RCON;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x3f28b(%rip), %rax     # 0x68600
callq *0x148(%rax)
movq %rax, %r14
movq 0x3f6d3(%rip), %rax     # 0x68a58
movq (%rax), %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18b20
testl %eax, %eax
je 0x293dd
movq 0x3f26e(%rip), %rax     # 0x68610
movq (%rax), %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x18b20
testl %eax, %eax
je 0x29404
leaq 0x2be1b(%rip), %rdx     # 0x551da
movl $0x2, %esi
movq %rbx, %rdi
callq 0x18da0
movq 0x58(%rbx), %rax
andl $-0x7, 0x1108(%rax)
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x0, (%r15)
je 0x29441
leaq 0x2bdaf(%rip), %rdx     # 0x55199
movl $0x2, %esi
movq %rbx, %rdi
callq 0x18da0
movq 0x58(%rbx), %rax
orl $0x6, 0x1108(%rax)
jmp 0x29434
cmpb $0x0, (%r15)
je 0x2944a
leaq 0x2bdb2(%rip), %rdx     # 0x551c3
movl $0x2, %esi
movq %rbx, %rdi
callq 0x18da0
movq 0x58(%rbx), %rax
movl 0x1108(%rax), %ecx
andl $-0x7, %ecx
orl $0x2, %ecx
movl %ecx, 0x1108(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x197d0
leaq 0x2bd3f(%rip), %rdx     # 0x55187
jmp 0x29451
leaq 0x2bd5d(%rip), %rdx     # 0x551ae
movl $0x2, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x18da0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_GotoMap_f
void Cmd_GotoMap_f (edict_t *ent)
{
	char *p;
	int i;
	char message[MAX_INFO_STRING];

	if (!(ent->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee.\n");
		return;
	}


	p = gi.args();

	if (strlen(p))
	{
		// convert to lower case for comparison
		for (i = 0; i < (int)strlen(p); i++)
			p[i] = tolower(p[i]);

		for (i=0; maplist[i].mapname; i++)
		{
			if (!strcmp(maplist[i].mapname, p))
			{
				ctf_ChangeMap(p, false);
				return;
			}
		}
		sprintf(message, "%s is not a map from the maplist.\n", p);
		ctf_SafePrint(ent, PRINT_HIGH, message);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x294a3
leaq 0x2bd6e(%rip), %rdx     # 0x551f6
movl $0x2, %esi
movq %rbx, %rdi
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18da0
movq 0x3f156(%rip), %rax     # 0x68600
callq *0x148(%rax)
cmpb $0x0, (%rax)
je 0x29546
movq %rax, %r14
movq %rax, %rdi
callq 0x18680
testl %eax, %eax
jle 0x294f4
xorl %r12d, %r12d
callq 0x19a20
movq %rax, %r15
movq (%r15), %rax
movsbq (%r14,%r12), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%r14,%r12)
incq %r12
movq %r14, %rdi
callq 0x18680
cltq
cmpq %rax, %r12
jl 0x294d3
movq 0x3f2cd(%rip), %r15     # 0x687c8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2951f
addq $0x18, %r15
movq %r14, %rsi
callq 0x18b20
testl %eax, %eax
je 0x29555
movq (%r15), %rdi
addq $0x18, %r15
testq %rdi, %rdi
jne 0x29507
leaq 0x2bce8(%rip), %rsi     # 0x5520e
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x196f0
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18da0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
xorl %esi, %esi
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19740
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Users_f
void Cmd_Users_f (edict_t *ent)
{
//	int		i;
//	int		count=0;
//	char	small[64];
//	char	large[1280];

	char message[MAX_INFO_STRING];
	char status[MAX_INFO_STRING];

	// print information
	edict_t * player = NULL;
	player = ctf_findplayer(NULL, NULL, CTF_TEAM_IGNORETEAM);
	while (player)
	{
		strcpy(status, "");
		if (player->client->ctf.extra_flags & CTF_EXTRAFLAGS_RCON)
			strcat(status, "[RCON] ");
		else if (player->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE)
			strcat(status, "(REF)  ");
		else
			strcat(status, "PLAYER ");
		sprintf(message, " id: %lu %s frags: %d\n",
			player->client->ctf.ctfid,
			player->client->pers.netname,
			player->client->ps.stats[STAT_FRAGS]);
		strcat(status, message);
		ctf_SafePrint(ent, PRINT_HIGH, status);

		player = ctf_findplayer(player, NULL, CTF_TEAM_IGNORETEAM);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
testq %rax, %rax
je 0x29657
movq %rax, %r14
movq %rsp, %r15
leaq 0x2bc8c(%rip), %r12     # 0x55231
leaq 0x200(%rsp), %r13
movb $0x0, (%rsp)
movq 0x58(%r14), %rax
movl 0x1108(%rax), %ebp
movq %r15, %rdi
testb $0x4, %bpl
jne 0x295db
callq 0x18680
testb $0x2, %bpl
jne 0x295ec
movabsq $0x20524559414c50, %rcx # imm = 0x20524559414C50
jmp 0x295f6
callq 0x18680
movabsq $0x205d4e4f43525b, %rcx # imm = 0x205D4E4F43525B
jmp 0x295f6
movabsq $0x20202946455228, %rcx # imm = 0x20202946455228
movq %rcx, (%rsp,%rax)
movq 0x58(%r14), %rcx
movq 0x9120(%rcx), %rdx
movswl 0x94(%rcx), %r8d
addq $0x2c0, %rcx            # imm = 0x2C0
movq %r13, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x196f0
movq %r15, %rdi
movq %r13, %rsi
callq 0x19640
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18da0
movq %r14, %rdi
xorl %esi, %esi
movl $0xfffffffc, %edx       # imm = 0xFFFFFFFC
callq 0x19170
movq %rax, %r14
testq %rax, %rax
jne 0x295ad
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_QuadTime_f
void Cmd_QuadTime_f (edict_t *ent) {
        unsigned long i=0;
        char *p;
        gitem_t * target = NULL;

        if (!(ent->client->ctf.extra_flags & (CTF_EXTRAFLAGS_REFEREE | CTF_EXTRAFLAGS_RCON)))
        {
                ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee or Rcon\n");
                return;
        }

        p = gi.args();
        if (!sscanf(p, "%lu", &i))
        {
                ctf_SafePrint(ent, PRINT_HIGH, "Usage: quadtime <seconds>\n");
                return;
        }

	target = FindItem("Quad Damage");
	if (target && i > 0 && i < 1200) {
		target->quantity = i;
                ctf_SafePrint(ent, PRINT_HIGH, "Quad respawn updated\n");
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq 0x58(%rdi), %rax
testb $0x6, 0x1108(%rax)
je 0x2985d
movq 0x3edfe(%rip), %rax     # 0x68600
callq *0x148(%rax)
leaq 0x295b0(%rip), %rsi     # 0x52dbf
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x18fe0
testl %eax, %eax
je 0x29876
leaq 0x28f6e(%rip), %rdi     # 0x52797
callq 0x189e0
testq %rax, %rax
setne %dl
movq 0x8(%rsp), %rcx
leaq -0x1(%rcx), %rsi
cmpq $0x4af, %rsi            # imm = 0x4AF
setb %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x2988a
movl %ecx, 0x5c(%rax)
leaq 0x2bb1f(%rip), %rdx     # 0x5537a
jmp 0x2987d
leaq 0x2badc(%rip), %rdx     # 0x55340
movl $0x2, %esi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x18da0
leaq 0x2bae2(%rip), %rdx     # 0x5535f
movl $0x2, %esi
movq %rbx, %rdi
callq 0x18da0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Match_f
void Cmd_Match_f (edict_t *ent)
{
	char *p;
	int i;
	char message[MAX_INFO_STRING];

	if (!(ent->client->ctf.extra_flags & CTF_EXTRAFLAGS_REFEREE))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "You are not a Referee\n");
		return;
	}

	p = gi.args();

	if (!p || !strlen(p))
	{
		ctf_SafePrint(ent, PRINT_HIGH, "USAGE: match <mapname>\n");
		return;
	}
	else
	{
		for (i=0; maplist[i].mapname; i++)
		{
			if (!strcmp(maplist[i].mapname, p))
			{
				ctf_SafePrint(ent, PRINT_HIGH, "Match countdown beginning.\n");
				StartMatch (p);
				return;
			}
		}
		sprintf(message, "%s is not a map from the maplist.\n", p);
		ctf_SafePrint(ent, PRINT_HIGH, message);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x29a6c
leaq 0x2b308(%rip), %rdx     # 0x54d6f
jmp 0x29aec
movq 0x3eb8d(%rip), %rax     # 0x68600
callq *0x148(%rax)
testq %rax, %rax
je 0x29ae5
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x29ae5
movq 0x3ed3b(%rip), %r15     # 0x687c8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29ab1
addq $0x18, %r15
movq %r14, %rsi
callq 0x18b20
testl %eax, %eax
je 0x29b05
movq (%r15), %rdi
addq $0x18, %r15
testq %rdi, %rdi
jne 0x29a99
leaq 0x2b756(%rip), %rsi     # 0x5520e
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x196f0
movl $0x2, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x18da0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b953(%rip), %rdx     # 0x5543f
movl $0x2, %esi
movq %rbx, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x18da0
leaq 0x2b94b(%rip), %rdx     # 0x55457
movl $0x2, %esi
movq %rbx, %rdi
callq 0x18da0
movq %r14, %rdi
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
jmp 0x18320
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_PingAlert_f
void Cmd_PingAlert_f (edict_t *ent)
{
	char *p;
	int i, j;

	i = j = 0;

	p = gi.args();
	if (sscanf(p, "%d %d", &i, &j) < 1)
	{
		ctf_SafePrint(ent, PRINT_HIGH, "Usage: pingalert <floor> <ceiling>\nUse zero to set no alert for that value.\n");
		return;
	}
	ent->client->ctf.pingalertfloor = i;
	ent->client->ctf.pingalertceiling = j;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movl %eax, (%r14)
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movq 0x3eaae(%rip), %rax     # 0x68600
callq *0x148(%rax)
leaq 0x291c0(%rip), %rsi     # 0x52d1f
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x18fe0
testl %eax, %eax
jle 0x29b8d
movl 0xc(%rsp), %eax
movq 0x58(%rbx), %rcx
movl %eax, 0x1110(%rcx)
movl 0x8(%rsp), %eax
movl %eax, 0x1114(%rcx)
jmp 0x29ba1
leaq 0x2b8df(%rip), %rdx     # 0x55473
movl $0x2, %esi
movq %rbx, %rdi
callq 0x18da0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_PlayerList_f
void Cmd_PlayerList_f(edict_t *ent)
{
	int i;
	char st[80];
	char text[MAX_MSGLEN];
	edict_t *e2;

	// connect time, ping, score, name
	*text = 0;
	for (i = 0, e2 = g_edicts + 1; i < maxclients->value; i++, e2++) {
		if (!e2->inuse)
			continue;

		Com_sprintf(st, sizeof(st), "%02d:%02d %4d %3d %s%s id: %i\n",
			(level.framenum - e2->client->resp.enterframe) / 600,
			((level.framenum - e2->client->resp.enterframe) % 600)/10,
			e2->client->ping,
			e2->client->resp.score,
			e2->client->pers.netname,
			e2->client->resp.spectator ? " (spectator)" : "",
			e2->client->ctf.ctfid);
		if (strlen(text) + strlen(st) > sizeof(text) - 50) {
			sprintf(text+strlen(text), "And more...\n");
			gi.cprintf(ent, PRINT_HIGH, "%s", text);
			return;
		}
		strcat(text, st);
	}
	gi.cprintf(ent, PRINT_HIGH, "%s", text);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5d8, %rsp            # imm = 0x5D8
movq %rdi, 0x8(%rsp)
movb $0x0, 0x60(%rsp)
movq 0x3e656(%rip), %rax     # 0x68530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x2a025
movq 0x3e663(%rip), %rcx     # 0x68558
movl $0x508, %ebx            # imm = 0x508
addq (%rcx), %rbx
movl $0x1, %r14d
leaq 0x10(%rsp), %r15
leaq 0x60(%rsp), %r12
cmpl $0x0, (%rbx)
je 0x29fe5
movq 0x3ee83(%rip), %rax     # 0x68da0
movl (%rax), %eax
movq -0x8(%rbx), %r10
subl 0xdf0(%r10), %eax
cltq
imulq $0x1b4e81b5, %rax, %rcx # imm = 0x1B4E81B5
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
imull $0x258, %ecx, %edx      # imm = 0x258
subl %edx, %eax
cwtl
imull $0x6667, %eax, %r8d     # imm = 0x6667
movl %r8d, %eax
shrl $0x1f, %eax
sarl $0x12, %r8d
addl %eax, %r8d
movl 0xb8(%r10), %r9d
movl 0xdf4(%r10), %r11d
cmpl $0x0, 0xe04(%r10)
leaq 0x2c0(%r10), %r13
leaq 0x2b58f(%rip), %rbp     # 0x55510
leaq 0x29fbd(%rip), %rax     # 0x53f45
cmoveq %rax, %rbp
movq %r15, %rdi
movl $0x50, %esi
leaq 0x2b556(%rip), %rdx     # 0x554f1
xorl %eax, %eax
pushq 0x9120(%r10)
pushq %rbp
pushq %r13
pushq %r11
callq 0x18e10
addq $0x20, %rsp
movq %r12, %rdi
callq 0x18680
movq %rax, %r13
movq %r15, %rdi
callq 0x18680
addq %r13, %rax
cmpq $0x547, %rax            # imm = 0x547
jae 0x2a007
movq %r12, %rdi
movq %r15, %rsi
callq 0x19640
movq 0x3e54e(%rip), %rax     # 0x68530
movq (%rax), %rax
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
movss 0x20(%rax), %xmm1
addq $0x4a8, %rbx            # imm = 0x4A8
incl %r14d
ucomiss %xmm0, %xmm1
ja 0x29f0d
jmp 0x2a025
movabsq $0xa2e2e2e65726f, %rax  # imm = 0xA2E2E2E65726F
movq %rax, 0x65(%rsp,%r13)
movabsq $0x65726f6d20646e41, %rax # imm = 0x65726F6D20646E41
movq %rax, 0x60(%rsp,%r13)
movq 0x3e5d4(%rip), %r8      # 0x68600
leaq 0x2897a(%rip), %rdx     # 0x529ad
leaq 0x60(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
callq *0x10(%r8)
addq $0x5d8, %rsp            # imm = 0x5D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_Observe_f
void Cmd_Observe_f(edict_t *ent, int Observer_Type)
{
int i;
int numspec;

	//first check to see if the maxspectator var is set.
	for(i = 1, numspec = 0; i <= maxclients->value; i++)
		if(g_edicts[i].inuse && g_edicts[i].client->pers.spectator)
			numspec++;

	if (numspec >= maxspectators->value)
	{
		gi.cprintf(ent, PRINT_HIGH, "Server spectator limit is full.");
		return;
	}



	if(Observer_Type == CTF_TEAM_OBSERVER_BLUE)
	{
		if(!Team_Observer_OK(CTF_TEAM_BLUE, ent))
			return;

		//gi.bprintf (PRINT_HIGH, "%s is watching the blue team\n", ent->client->pers.netname);
	}
	else if(Observer_Type == CTF_TEAM_OBSERVER_RED)
	{
		if(!Team_Observer_OK(CTF_TEAM_RED, ent))
			return;

		//gi.bprintf (PRINT_HIGH, "%s is watching the red team\n", ent->client->pers.netname);
	}
	//else
		//gi.bprintf (PRINT_HIGH, "%s has moved to the sidelines\n", ent->client->pers.netname);


	Drop_All(ent);
	ent->client->ctf.teamnum = Observer_Type;
	ent->client->chase_target = NULL;
	//ent->client->pers.spectator = 1;
	//ent->client->resp.spectator = 1;
	ForceCommand(ent, "spectator 1");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x3e4c7(%rip), %rax     # 0x68530
movq (%rax), %rax
movss 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss 0x28ead(%rip), %xmm0    # 0x52f28
jb 0x2a0c1
movq 0x3e4d4(%rip), %rcx     # 0x68558
movl $0x508, %eax            # imm = 0x508
addq (%rcx), %rax
xorl %ecx, %ecx
movl $0x2, %edx
cmpl $0x0, (%rax)
je 0x2a0a6
movq -0x8(%rax), %rsi
cmpl $0x1, 0x750(%rsi)
sbbl $-0x1, %ecx
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
addq $0x4a8, %rax            # imm = 0x4A8
incl %edx
ucomiss %xmm1, %xmm0
jae 0x2a093
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movq 0x3ee70(%rip), %rax     # 0x68f38
movq (%rax), %rax
ucomiss 0x20(%rax), %xmm1
jae 0x2a0e2
cmpl $-0x3, %ebp
je 0x2a106
cmpl $-0x2, %ebp
jne 0x2a117
movl $0x2, %edi
jmp 0x2a10b
movq 0x3e517(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2b436(%rip), %rdx     # 0x5552a
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rcx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x19720
testl %eax, %eax
je 0x2a149
movq %rbx, %rdi
callq 0x195d0
movq 0x58(%rbx), %rax
movl %ebp, 0x1100(%rax)
movq $0x0, 0xf30(%rax)
leaq 0x2b40f(%rip), %rsi     # 0x5554a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x18c40
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_ToggleFastSwitch_f
void Cmd_ToggleFastSwitch_f(edict_t *ent)
{
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
		return;
	}

	char *newval = (((int)fastswitch->value) == 1) ? "0" : "1";
	gi.cvar_set("fastswitch", newval);
	gi.bprintf(PRINT_HIGH, "Fast weapon switching now %sabled\n", (fastswitch->value) ? "en" : "dis");
}

// Assembly:
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x2a178
movq 0x3e49c(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2a3f7(%rip), %rdx     # 0x54566
movl $0x2, %esi
xorl %eax, %eax
jmpq *%rcx
pushq %r14
pushq %rbx
pushq %rax
movq 0x3ea1d(%rip), %rbx     # 0x68ba0
movq (%rbx), %rax
cvttss2si 0x20(%rax), %eax
cmpl $0x1, %eax
leaq 0x30f57(%rip), %rax     # 0x5b0ec
leaq 0x27ec8(%rip), %rsi     # 0x52064
cmoveq %rax, %rsi
movq 0x3e459(%rip), %r14     # 0x68600
leaq 0x2b852(%rip), %rdi     # 0x55a00
callq *0x128(%r14)
movq (%rbx), %rax
xorps %xmm0, %xmm0
ucomiss 0x20(%rax), %xmm0
leaq 0x2c092(%rip), %rax     # 0x56258
leaq 0x2b3ac(%rip), %rdx     # 0x55579
cmovneq %rax, %rdx
movq (%r14), %rcx
cmovpq %rax, %rdx
leaq 0x2b377(%rip), %rsi     # 0x55556
movl $0x2, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_ChangeMap_f
void Cmd_ChangeMap_f(edict_t *ent)
{
	if (!ISREF(ent)) {
		gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
		return;
	}

	if (gi.argc() < 2) {
		gi.cprintf(ent, PRINT_HIGH, "Usage: changemap <mapname>\n");
		return;
	}

	char *map = gi.argv(1);
	ctf_ChangeMap(map, false);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x2a4d3
movq 0x3e13a(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2a095(%rip), %rdx     # 0x54566
jmp 0x2a4f1
movq 0x3e126(%rip), %r14     # 0x68600
callq *0x138(%r14)
cmpl $0x1, %eax
jg 0x2a504
movq 0x10(%r14), %rcx
leaq 0x2b3f0(%rip), %rdx     # 0x558e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movl $0x1, %edi
callq *0x140(%r14)
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19740
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_cmds.c
// Function: Cmd_SetTimelimit_f
void Cmd_SetTimelimit_f(edict_t *ent)
{
    if (!ISREF(ent)) {
        gi.cprintf(ent, PRINT_HIGH, "Referee-only command\n");
        return;
    }

    if (gi.argc() < 2) {
        gi.cprintf(ent, PRINT_HIGH, "Usage: settimelimit <minutes>\n");
        return;
    }

    char *minutes = gi.argv(1);
    gi.cvar_set("timelimit", minutes);

    gi.cprintf(ent, PRINT_HIGH, "Timelimit set to %d minutes\n", (int)timelimit->value);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
testb $0x2, 0x1108(%rax)
jne 0x2a549
movq 0x3e0c4(%rip), %rax     # 0x68600
movq 0x10(%rax), %rcx
leaq 0x2a01f(%rip), %rdx     # 0x54566
jmp 0x2a567
movq 0x3e0b0(%rip), %r14     # 0x68600
callq *0x138(%r14)
cmpl $0x1, %eax
jg 0x2a57a
movq 0x10(%r14), %rcx
leaq 0x2b396(%rip), %rdx     # 0x558fd
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movl $0x1, %edi
callq *0x140(%r14)
leaq 0x27fa3(%rip), %rdi     # 0x52530
movq %rax, %rsi
callq *0x128(%r14)
movq 0x3e112(%rip), %rax     # 0x686b0
movq (%rax), %rax
cvttss2si 0x20(%rax), %ecx
movq 0x10(%r14), %r8
leaq 0x2b36b(%rip), %rdx     # 0x5591c
movq %rbx, %rdi
movl $0x2, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%r8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_combat.c
// Function: SpawnDamage
void SpawnDamage (int type, vec3_t origin, vec3_t normal, int damage)
{
	if (damage > 255)
		damage = 255;
	gi.WriteByte (svc_temp_entity);
	gi.WriteByte (type);
//	gi.WriteByte (damage);
	gi.WritePosition (origin);
	gi.WriteDir (normal);
	gi.multicast (origin, MULTICAST_PVS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x3d18c(%rip), %r15     # 0x68600
movl $0x3, %edi
callq *0xc8(%r15)
movl %ebp, %edi
callq *0xc8(%r15)
movq %r14, %rdi
callq *0xf0(%r15)
movq %rbx, %rdi
callq *0xf8(%r15)
movq 0xb0(%r15), %rax
movq %r14, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_combat.c
// Function: CheckTeamDamage
qboolean CheckTeamDamage (edict_t *targ, edict_t *attacker)
{
		//FIXME make the next line real and uncomment this block
		// if ((ability to damage a teammate == OFF) && (targ's team == attacker's team))
	// TEAM CODE - LM_JORM
	if (targ == attacker || matchstate == MATCH_RAILGUN_INPLAY)
		return false;
	if (attacker->client && targ->client && (OnSameTeam(attacker, targ)))
		return true;
	return false;
}

// Assembly:
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x2b4f8
movq 0x3d312(%rip), %rdx     # 0x687d8
cmpl $0x6, (%rdx)
je 0x2b4f8
cmpq $0x0, 0x58(%rsi)
je 0x2b4f9
movq %rdi, %rcx
cmpq $0x0, 0x58(%rdi)
je 0x2b4f9
pushq %rax
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x18700
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
leaq 0x8(%rsp), %rsp
je 0x2b4f9
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Move_Final
void Move_Final (edict_t *ent)
{
	if (ent->moveinfo.remaining_distance == 0)
	{
		Move_Done (ent);
		return;
	}

	VectorScale (ent->moveinfo.dir, ent->moveinfo.remaining_distance / FRAMETIME, ent->velocity);

	ent->think = Move_Done;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
movq %rdi, %rax
movss 0x3a4(%rdi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2c146
jp 0x2c146
movl $0x0, 0x1c8(%rax)
movq $0x0, 0x1c0(%rax)
movq %rax, %rdi
jmpq *0x3b0(%rax)
pushq %rbx
leaq 0x38c(%rax), %rdi
divss 0x2713a(%rip), %xmm0    # 0x53290
leaq 0x1c0(%rax), %rsi
movq %rax, %rbx
callq 0x189d0
movq 0x3c704(%rip), %rax     # 0x68870
movq %rax, 0x210(%rbx)
movq 0x3cc26(%rip), %rax     # 0x68da0
movss 0x2710e(%rip), %xmm0    # 0x53290
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Move_Begin
void Move_Begin (edict_t *ent)
{
	float	frames;

	if ((ent->moveinfo.speed * FRAMETIME) >= ent->moveinfo.remaining_distance)
	{
		Move_Final (ent);
		return;
	}
	VectorScale (ent->moveinfo.dir, ent->moveinfo.speed, ent->velocity);
	frames = floor((ent->moveinfo.remaining_distance / ent->moveinfo.speed) / FRAMETIME);
	ent->moveinfo.remaining_distance -= frames * ent->moveinfo.speed * FRAMETIME;
	ent->nextthink = level.time + (frames * FRAMETIME);
	ent->think = Move_Final;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movss 0x378(%rdi), %xmm0
movss 0x270e7(%rip), %xmm1    # 0x53290
mulss %xmm0, %xmm1
ucomiss 0x3a4(%rdi), %xmm1
jae 0x2c24e
leaq 0x38c(%rbx), %rdi
leaq 0x1c0(%rbx), %rsi
callq 0x189d0
movss 0x378(%rbx), %xmm1
movss %xmm1, 0x8(%rsp)
movss 0x3a4(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
divss %xmm1, %xmm0
divss 0x2709b(%rip), %xmm0    # 0x53290
callq 0x19540
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
movss 0x27084(%rip), %xmm3    # 0x53290
mulss %xmm3, %xmm1
movss 0xc(%rsp), %xmm2
subss %xmm1, %xmm2
movss %xmm2, 0x3a4(%rbx)
movq 0x3cb77(%rip), %rax     # 0x68da0
mulss %xmm3, %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x3ca1f(%rip), %rax     # 0x68c60
movq %rax, 0x210(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x19b20
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Move_Calc
void Move_Calc (edict_t *ent, vec3_t dest, void(*func)(edict_t*))
{
	VectorClear (ent->velocity);
	VectorSubtract (dest, ent->s.origin, ent->moveinfo.dir);
	ent->moveinfo.remaining_distance = VectorNormalize (ent->moveinfo.dir);
	ent->moveinfo.endfunc = func;

	if (ent->moveinfo.speed == ent->moveinfo.accel && ent->moveinfo.speed == ent->moveinfo.decel)
	{
		if (level.current_entity == ((ent->flags & FL_TEAMSLAVE) ? ent->teammaster : ent))
		{
			Move_Begin (ent);
		}
		else
		{
			ent->nextthink = level.time + FRAMETIME;
			ent->think = Move_Begin;
		}
	}
	else
	{
		// accelerative
		ent->moveinfo.current_speed = 0;
		ent->think = Think_AccelMove;
		ent->nextthink = level.time + FRAMETIME;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl $0x0, 0x1c8(%rdi)
movq $0x0, 0x1c0(%rdi)
movss (%rsi), %xmm0
subss 0x4(%rdi), %xmm0
addq $0x38c, %rdi            # imm = 0x38C
movss %xmm0, 0x38c(%rbx)
movss 0x4(%rsi), %xmm0
subss 0x8(%rbx), %xmm0
movss %xmm0, 0x390(%rbx)
movss 0x8(%rsi), %xmm0
subss 0xc(%rbx), %xmm0
movss %xmm0, 0x394(%rbx)
callq 0x18390
movss %xmm0, 0x3a4(%rbx)
movq %r14, 0x3b0(%rbx)
movss 0x378(%rbx), %xmm0
ucomiss 0x374(%rbx), %xmm0
jne 0x2c333
jp 0x2c333
ucomiss 0x37c(%rbx), %xmm0
jne 0x2c333
jp 0x2c333
movq 0x3cab1(%rip), %rax     # 0x68da0
movq 0x148(%rax), %rcx
testb $0x4, 0x11d(%rbx)
movq %rbx, %rdx
je 0x2c309
movq 0x2d0(%rbx), %rdx
cmpq %rdx, %rcx
je 0x2c36f
movss 0x4(%rax), %xmm0
addss 0x26f75(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq 0x3c626(%rip), %rax     # 0x68950
movq %rax, 0x210(%rbx)
jmp 0x2c367
movl $0x0, 0x398(%rbx)
movq 0x3c25c(%rip), %rax     # 0x685a0
movq %rax, 0x210(%rbx)
movq 0x3ca4e(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x26f31(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19ad8
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Think_AccelMove
void Think_AccelMove (edict_t *ent)
{
	ent->moveinfo.remaining_distance -= ent->moveinfo.current_speed;

	if (ent->moveinfo.current_speed == 0)		// starting or blocked
		plat_CalcAcceleratedMove(&ent->moveinfo);

	plat_Accelerate (&ent->moveinfo);

	// will the entire move complete on next frame?
	if (ent->moveinfo.remaining_distance <= ent->moveinfo.current_speed)
	{
		Move_Final (ent);
		return;
	}

	VectorScale (ent->moveinfo.dir, ent->moveinfo.current_speed*10, ent->velocity);
	ent->nextthink = level.time + FRAMETIME;
	ent->think = Think_AccelMove;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x338(%rdi), %r14
movss 0x398(%rdi), %xmm0
movss 0x3a4(%rdi), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x3a4(%rdi)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2c3ba
jp 0x2c3ba
movq %r14, %rdi
callq 0x19210
movq %r14, %rdi
callq 0x19090
movss 0x398(%rbx), %xmm0
ucomiss 0x3a4(%rbx), %xmm0
jae 0x2c420
leaq 0x38c(%rbx), %rdi
mulss 0x26b32(%rip), %xmm0    # 0x52f14
leaq 0x1c0(%rbx), %rsi
callq 0x189d0
movq 0x3c9ab(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x26e8e(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
movq 0x3c18f(%rip), %rax     # 0x685a0
movq %rax, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19b20
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: AngleMove_Final
void AngleMove_Final (edict_t *ent)
{
	vec3_t	move;

	if (ent->moveinfo.state == STATE_UP)
		VectorSubtract (ent->moveinfo.end_angles, ent->s.angles, move);
	else
		VectorSubtract (ent->moveinfo.start_angles, ent->s.angles, move);

	if (VectorCompare (move, vec3_origin))
	{
		AngleMove_Done (ent);
		return;
	}

	VectorScale (move, 1.0f/FRAMETIME, ent->avelocity);

	ent->think = AngleMove_Done;
	ent->nextthink = level.time + FRAMETIME;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x344(%rdi), %rax
leaq 0x35c(%rdi), %rcx
leaq 0x348(%rdi), %rdx
leaq 0x360(%rdi), %rsi
addq $0x34c, %rdi            # imm = 0x34C
leaq 0x364(%rbx), %r8
cmpl $0x2, 0x388(%rbx)
cmoveq %rcx, %rax
cmovneq %rdx, %rsi
cmovneq %rdi, %r8
movss (%r8), %xmm0
subss 0x18(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movss (%rsi), %xmm2
movss (%rax), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
subps %xmm1, %xmm3
movq %rsp, %rdi
movlps %xmm3, (%rdi)
movss %xmm0, 0x8(%rdi)
movq 0x3c2aa(%rip), %rsi     # 0x68768
callq 0x18b70
testl %eax, %eax
je 0x2c4e7
movl $0x0, 0x1d4(%rbx)
movq $0x0, 0x1cc(%rbx)
movq %rbx, %rdi
callq *0x3b0(%rbx)
jmp 0x2c528
leaq 0x1cc(%rbx), %rsi
movq %rsp, %rdi
movss 0x26a1b(%rip), %xmm0    # 0x52f14
callq 0x189d0
movq 0x3c5b3(%rip), %rax     # 0x68ab8
movq %rax, 0x210(%rbx)
movq 0x3c88d(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x26d70(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: AngleMove_Begin
void AngleMove_Begin (edict_t *ent)
{
	vec3_t	destdelta;
	float	len;
	float	traveltime;
	float	frames;

	// set destdelta to the vector needed to move
	if (ent->moveinfo.state == STATE_UP)
		VectorSubtract (ent->moveinfo.end_angles, ent->s.angles, destdelta);
	else
		VectorSubtract (ent->moveinfo.start_angles, ent->s.angles, destdelta);
	
	// calculate length of vector
	len = VectorLength (destdelta);
	
	// divide by speed to get time to reach dest
	traveltime = len / ent->moveinfo.speed;

	if (traveltime < FRAMETIME)
	{
		AngleMove_Final (ent);
		return;
	}

	frames = floor(traveltime / FRAMETIME);

	// scale the destdelta vector by the time spent traveling to get velocity
	VectorScale (destdelta, 1.0 / traveltime, ent->avelocity);

	// set nextthink to trigger a think when dest is reached
	ent->nextthink = level.time + frames * FRAMETIME;
	ent->think = AngleMove_Final;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x344(%rdi), %rax
leaq 0x35c(%rdi), %rcx
leaq 0x348(%rdi), %rdx
leaq 0x360(%rdi), %rsi
addq $0x34c, %rdi            # imm = 0x34C
leaq 0x364(%rbx), %r8
cmpl $0x2, 0x388(%rbx)
cmoveq %rcx, %rax
cmovneq %rdx, %rsi
cmovneq %rdi, %r8
movss (%r8), %xmm0
subss 0x18(%rbx), %xmm0
movsd 0x10(%rbx), %xmm1
movss (%rsi), %xmm2
movss (%rax), %xmm3
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
subps %xmm1, %xmm3
leaq 0x10(%rsp), %rdi
movlps %xmm3, (%rdi)
movss %xmm0, 0x8(%rdi)
callq 0x192e0
divss 0x378(%rbx), %xmm0
movss 0x26cde(%rip), %xmm1    # 0x53290
ucomiss %xmm0, %xmm1
jbe 0x2c5c1
movq %rbx, %rdi
callq 0x19b40
jmp 0x2c625
movss %xmm0, 0x8(%rsp)
divss %xmm1, %xmm0
callq 0x19540
movss %xmm0, 0xc(%rsp)
movss 0x2694a(%rip), %xmm0    # 0x52f28
divss 0x8(%rsp), %xmm0
leaq 0x1cc(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x189d0
movq 0x3c7a4(%rip), %rax     # 0x68da0
movss 0xc(%rsp), %xmm0
mulss 0x26c86(%rip), %xmm0    # 0x53290
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x3c812(%rip), %rax     # 0x68e30
movq %rax, 0x210(%rbx)
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: AngleMove_Calc
void AngleMove_Calc (edict_t *ent, void(*func)(edict_t*))
{
	VectorClear (ent->avelocity);
	ent->moveinfo.endfunc = func;
	if (level.current_entity == ((ent->flags & FL_TEAMSLAVE) ? ent->teammaster : ent))
	{
		AngleMove_Begin (ent);
	}
	else
	{
		ent->nextthink = level.time + FRAMETIME;
		ent->think = AngleMove_Begin;
	}
}

// Assembly:
movl $0x0, 0x1d4(%rdi)
movq $0x0, 0x1cc(%rdi)
movq %rsi, 0x3b0(%rdi)
movq 0x3c752(%rip), %rax     # 0x68da0
movq 0x148(%rax), %rcx
testb $0x4, 0x11d(%rdi)
movq %rdi, %rdx
je 0x2c668
movq 0x2d0(%rdi), %rdx
cmpq %rdx, %rcx
je 0x19a68
movss 0x4(%rax), %xmm0
addss 0x26c12(%rip), %xmm0    # 0x53290
movss %xmm0, 0x200(%rdi)
movq 0x3bf2b(%rip), %rax     # 0x685b8
movq %rax, 0x210(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_CalcAcceleratedMove
void plat_CalcAcceleratedMove(moveinfo_t *moveinfo)
{
	float	accel_dist;
	float	decel_dist;

	moveinfo->move_speed = moveinfo->speed;

	if (moveinfo->remaining_distance < moveinfo->accel)
	{
		moveinfo->current_speed = moveinfo->remaining_distance;
		return;
	}

	accel_dist = AccelerationDistance (moveinfo->speed, moveinfo->accel);
	decel_dist = AccelerationDistance (moveinfo->speed, moveinfo->decel);

	if ((moveinfo->remaining_distance - accel_dist - decel_dist) < 0)
	{
		float	f;

		f = (moveinfo->accel + moveinfo->decel) / (moveinfo->accel * moveinfo->decel);
		moveinfo->move_speed = (-2 + sqrtf(4 - 4 * f * (-2 * moveinfo->remaining_distance))) / (2 * f);
		decel_dist = AccelerationDistance (moveinfo->move_speed, moveinfo->decel);
	}

	moveinfo->decel_distance = decel_dist;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movss 0x3c(%rdi), %xmm0
movss 0x40(%rdi), %xmm4
movss %xmm4, 0x64(%rdi)
movss 0x6c(%rdi), %xmm1
movl $0x60, %r14d
ucomiss %xmm1, %xmm0
ja 0x2c77e
movss 0x44(%rbx), %xmm2
shufps $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movaps %xmm0, %xmm5
unpcklps %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
movaps %xmm4, %xmm3
divps %xmm5, %xmm3
addps 0x29582(%rip), %xmm3    # 0x55c60
mulps %xmm4, %xmm3
mulps 0x29588(%rip), %xmm3    # 0x55c70
movaps %xmm1, %xmm4
subss %xmm3, %xmm4
shufps $0x55, %xmm3, %xmm3     # xmm3 = xmm3[1,1,1,1]
movl $0x70, %r14d
ucomiss %xmm4, %xmm3
jbe 0x2c73b
movaps %xmm0, %xmm3
addss %xmm2, %xmm3
mulss %xmm2, %xmm0
divss %xmm0, %xmm3
mulss 0x27cfb(%rip), %xmm1    # 0x54410
movss 0x29527(%rip), %xmm0    # 0x55c44
mulss %xmm3, %xmm0
mulss %xmm1, %xmm0
addss 0x267df(%rip), %xmm0    # 0x52f0c
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2c740
sqrtss %xmm0, %xmm0
jmp 0x2c74d
movaps %xmm3, %xmm1
jmp 0x2c77e
movaps %xmm3, (%rsp)
callq 0x18e80
movaps (%rsp), %xmm3
addss 0x27cbb(%rip), %xmm0    # 0x54410
addss %xmm3, %xmm3
divss %xmm3, %xmm0
movss %xmm0, 0x64(%rbx)
movaps %xmm0, %xmm1
divss 0x44(%rbx), %xmm1
addss 0x267b6(%rip), %xmm1    # 0x52f28
mulss %xmm0, %xmm1
mulss 0x27c82(%rip), %xmm1    # 0x54400
movss %xmm1, (%rbx,%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_hit_top
void plat_hit_top (edict_t *ent)
{
	if (!(ent->flags & FL_TEAMSLAVE))
	{
		if (ent->moveinfo.sound_end)
			gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, ent->moveinfo.sound_end, 1, ATTN_STATIC, 0);
		ent->s.sound = 0;
	}
	ent->moveinfo.state = STATE_TOP;

	ent->think = plat_go_down;
	ent->nextthink = level.time + 3;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2c915
movl 0x370(%rbx), %edx
testl %edx, %edx
je 0x2c90e
movq 0x3bd10(%rip), %rax     # 0x68600
movss 0x26630(%rip), %xmm0    # 0x52f28
movss 0x26610(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl $0x0, 0x4c(%rbx)
movl $0x0, 0x388(%rbx)
movq 0x3c092(%rip), %rax     # 0x689b8
movq %rax, 0x210(%rbx)
movq 0x3c46c(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x265cf(%rip), %xmm0    # 0x52f10
movss %xmm0, 0x200(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_go_down
void plat_go_down (edict_t *ent)
{
	if (!(ent->flags & FL_TEAMSLAVE))
	{
		if (ent->moveinfo.sound_start)
			gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, ent->moveinfo.sound_start, 1, ATTN_STATIC, 0);
		ent->s.sound = ent->moveinfo.sound_middle;
	}
	ent->moveinfo.state = STATE_DOWN;
	Move_Calc (ent, ent->moveinfo.end_origin, plat_hit_bottom);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2c990
movl 0x368(%rbx), %edx
testl %edx, %edx
je 0x2c987
movq 0x3bc97(%rip), %rax     # 0x68600
movss 0x265b7(%rip), %xmm0    # 0x52f28
movss 0x26597(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl 0x36c(%rbx), %eax
movl %eax, 0x4c(%rbx)
movl $0x3, 0x388(%rbx)
leaq 0x350(%rbx), %rsi
movq 0x3bef8(%rip), %rdx     # 0x688a0
movq %rbx, %rdi
popq %rbx
jmp 0x18e70
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_hit_bottom
void plat_hit_bottom (edict_t *ent)
{
	if (!(ent->flags & FL_TEAMSLAVE))
	{
		if (ent->moveinfo.sound_end)
			gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, ent->moveinfo.sound_end, 1, ATTN_STATIC, 0);
		ent->s.sound = 0;
	}
	ent->moveinfo.state = STATE_BOTTOM;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2c9f4
movl 0x370(%rbx), %edx
testl %edx, %edx
je 0x2c9ed
movq 0x3bc31(%rip), %rax     # 0x68600
movss 0x26551(%rip), %xmm0    # 0x52f28
movss 0x26531(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl $0x0, 0x4c(%rbx)
movl $0x1, 0x388(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_go_up
void plat_go_up (edict_t *ent)
{
	if (!(ent->flags & FL_TEAMSLAVE))
	{
		if (ent->moveinfo.sound_start)
			gi.sound (ent, CHAN_NO_PHS_ADD+CHAN_VOICE, ent->moveinfo.sound_start, 1, ATTN_STATIC, 0);
		ent->s.sound = ent->moveinfo.sound_middle;
	}
	ent->moveinfo.state = STATE_UP;
	Move_Calc (ent, ent->moveinfo.start_origin, plat_hit_top);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x11d(%rdi)
jne 0x2ca45
movl 0x368(%rbx), %edx
testl %edx, %edx
je 0x2ca3c
movq 0x3bbe2(%rip), %rax     # 0x68600
movss 0x26502(%rip), %xmm0    # 0x52f28
movss 0x264e2(%rip), %xmm1    # 0x52f10
xorps %xmm2, %xmm2
movq %rbx, %rdi
movl $0xa, %esi
callq *0x20(%rax)
movl 0x36c(%rbx), %eax
movl %eax, 0x4c(%rbx)
leaq 0x338(%rbx), %rsi
movl $0x2, 0x388(%rbx)
movq 0x3bf4b(%rip), %rdx     # 0x689a8
movq %rbx, %rdi
popq %rbx
jmp 0x18e70
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_blocked
void plat_blocked (edict_t *self, edict_t *other)
{
	if (!(other->svflags & SVF_MONSTER) && (!other->client) )
	{
		// give it a chance to go away on it's own terms (like gibs)
		T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, 100000, 1, 0, MOD_CRUSH);
		// if it's still there, nuke it
		if (other)
			BecomeExplosion1 (other);
		return;
	}

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

	if (self->moveinfo.state == STATE_UP)
		plat_go_down (self);
	else if (self->moveinfo.state == STATE_DOWN)
		plat_go_up (self);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x4, 0xc8(%rsi)
jne 0x2ca80
cmpq $0x0, 0x58(%r14)
je 0x2cae3
leaq 0x4(%r14), %r8
movl 0x280(%rbx), %eax
movq 0x3bcd7(%rip), %rcx     # 0x68768
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq %rax
callq 0x190f0
addq $0x20, %rsp
movl 0x388(%rbx), %eax
cmpl $0x3, %eax
je 0x2cacc
cmpl $0x2, %eax
jne 0x2cadb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19ae0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x180f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4(%r14), %r8
movq 0x3bc7a(%rip), %rcx     # 0x68768
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rcx, %r9
pushq $0x14
pushq $0x0
pushq $0x1
pushq $0x186a0                # imm = 0x186A0
callq 0x190f0
addq $0x20, %rsp
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x195c0
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Touch_Plat_Center
void Touch_Plat_Center (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (!other->client)
		return;
		
	if (other->health <= 0)
		return;

	ent = ent->enemy;	// now point at the plat, not the trigger
	if (ent->moveinfo.state == STATE_BOTTOM)
		plat_go_up (ent);
	else if (ent->moveinfo.state == STATE_TOP)
		ent->nextthink = level.time + 1;	// the player is still on the plat, so delay going down
}

// Assembly:
cmpq $0x0, 0x58(%rsi)
je 0x2cb73
cmpl $0x0, 0x254(%rsi)
jle 0x2cb73
movq 0x2a0(%rdi), %rdi
movl 0x388(%rdi), %eax
testl %eax, %eax
je 0x2cb57
cmpl $0x1, %eax
jne 0x2cb73
jmp 0x180f0
movq 0x3c242(%rip), %rax     # 0x68da0
movss 0x4(%rax), %xmm0
addss 0x263bd(%rip), %xmm0    # 0x52f28
movss %xmm0, 0x200(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: plat_spawn_inside_trigger
void plat_spawn_inside_trigger (edict_t *ent)
{
	edict_t	*trigger;
	vec3_t	tmin, tmax;

//
// middle trigger
//	
	trigger = G_Spawn();
	trigger->touch = Touch_Plat_Center;
	trigger->movetype = MOVETYPE_NONE;
	trigger->solid = SOLID_TRIGGER;
	trigger->enemy = ent;
	
	tmin[0] = ent->mins[0] + 25;
	tmin[1] = ent->mins[1] + 25;
	tmin[2] = ent->mins[2];

	tmax[0] = ent->maxs[0] - 25;
	tmax[1] = ent->maxs[1] - 25;
	tmax[2] = ent->maxs[2] + 8;

	tmin[2] = tmax[2] - (ent->pos1[2] - ent->pos2[2] + st.lip);

	if (ent->spawnflags & PLAT_LOW_TRIGGER)
		tmax[2] = tmin[2] + 8;
	
	if (tmax[0] - tmin[0] <= 0)
	{
		tmin[0] = (ent->mins[0] + ent->maxs[0]) *0.5;
		tmax[0] = tmin[0] + 1;
	}
	if (tmax[1] - tmin[1] <= 0)
	{
		tmin[1] = (ent->mins[1] + ent->maxs[1]) *0.5;
		tmax[1] = tmin[1] + 1;
	}
	
	VectorCopy (tmin, trigger->mins);
	VectorCopy (tmax, trigger->maxs);

	gi.linkentity (trigger);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x19700
movq 0x3c03c(%rip), %rcx     # 0x68bc0
movq %rcx, 0x220(%rax)
movl $0x0, 0x118(%rax)
movl $0x1, 0x108(%rax)
movq %rbx, 0x2a0(%rax)
movss 0x2634e(%rip), %xmm2    # 0x52efc
movss 0xe0(%rbx), %xmm0
addss %xmm2, %xmm0
movss 0x1b0(%rbx), %xmm1
subss 0x1bc(%rbx), %xmm1
movq 0x3ba97(%rip), %rcx     # 0x68668
cvtsi2ssl 0x20(%rcx), %xmm3
addss %xmm1, %xmm3
movaps %xmm0, %xmm1
subss %xmm3, %xmm1
testb $0x1, 0x140(%rbx)
je 0x2cbf1
addss %xmm1, %xmm2
movaps %xmm2, %xmm0
movsd 0xcc(%rbx), %xmm2
movsd 0xd8(%rbx), %xmm3
movaps 0x29078(%rip), %xmm4    # 0x55c80
addps %xmm2, %xmm4
addps %xmm3, %xmm2
addps 0x2907b(%rip), %xmm3    # 0x55c90
mulps 0x29054(%rip), %xmm2    # 0x55c70
movaps %xmm3, %xmm5
subps %xmm4, %xmm5
xorps %xmm6, %xmm6
cmpnleps %xmm6, %xmm5
movaps %xmm5, %xmm6
andnps %xmm2, %xmm6
andps %xmm5, %xmm4
orps %xmm6, %xmm4
movlps %xmm4, 0xcc(%rax)
addps 0x2901d(%rip), %xmm2    # 0x55c60
movss %xmm1, 0xd4(%rax)
andps %xmm5, %xmm3
andnps %xmm2, %xmm5
orps %xmm3, %xmm5
movlps %xmm5, 0xd8(%rax)
movss %xmm0, 0xe0(%rax)
movq 0x3b996(%rip), %rcx     # 0x68600
movq %rax, %rdi
popq %rbx
jmpq *0x90(%rcx)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: rotating_use
void rotating_use (edict_t *self, edict_t *other, edict_t *activator)
{
	if (!VectorCompare (self->avelocity, vec3_origin))
	{
		self->s.sound = 0;
		VectorClear (self->avelocity);
		self->touch = NULL;
	}
	else
	{
		self->s.sound = self->moveinfo.sound_middle;
		VectorScale (self->movedir, self->speed, self->avelocity);
		if (self->spawnflags & 16)
			self->touch = rotating_touch;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1cc(%rdi), %r14
movq 0x3b803(%rip), %rsi     # 0x68768
movq %r14, %rdi
callq 0x18b70
testl %eax, %eax
je 0x2cfa3
movl 0x36c(%rbx), %eax
movl %eax, 0x4c(%rbx)
leaq 0x19c(%rbx), %rdi
movss 0x190(%rbx), %xmm0
movq %r14, %rsi
callq 0x189d0
testb $0x10, 0x140(%rbx)
je 0x2cfc0
movq 0x3ba5f(%rip), %rax     # 0x68a00
jmp 0x2cfb9
xorl %eax, %eax
movl %eax, 0x4c(%rbx)
movl %eax, 0x1d4(%rbx)
movq $0x0, 0x1cc(%rbx)
movq %rax, 0x220(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: SP_func_rotating
void SP_func_rotating (edict_t *ent)
{
	ent->solid = SOLID_BSP;
	if (ent->spawnflags & 32)
		ent->movetype = MOVETYPE_STOP;
	else
		ent->movetype = MOVETYPE_PUSH;

	// set the axis of rotation
	VectorClear(ent->movedir);
	if (ent->spawnflags & 4)
		ent->movedir[2] = 1.0;
	else if (ent->spawnflags & 8)
		ent->movedir[0] = 1.0;
	else // Z_AXIS
		ent->movedir[1] = 1.0;

	// check for reverse rotation
	if (ent->spawnflags & 2)
		VectorNegate (ent->movedir, ent->movedir);

	if (!ent->speed)
		ent->speed = 100;
	if (!ent->dmg)
		ent->dmg = 2;

//	ent->moveinfo.sound_middle = "doors/hydro1.wav";

	ent->use = rotating_use;
	if (ent->dmg)
		ent->blocked = rotating_blocked;

	if (ent->spawnflags & 1)
		ent->use (ent, NULL, NULL);

	if (ent->spawnflags & 64)
		ent->s.effects |= EF_ANIM_ALL;
	if (ent->spawnflags & 128)
		ent->s.effects |= EF_ANIM_ALLFAST;

	gi.setmodel (ent, ent->model);
	gi.linkentity (ent);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3, %ecx
movl %ecx, 0x108(%rdi)
movl 0x140(%rdi), %eax
movl %eax, %edx
andl $0x20, %edx
cmpl $0x1, %edx
sbbl $0x0, %ecx
movl %ecx, 0x118(%rdi)
leaq 0x19c(%rdi), %rdx
leaq 0x1a4(%rdi), %rcx
movl $0x0, 0x1a4(%rdi)
movq $0x0, 0x19c(%rdi)
testb $0x4, %al
jne 0x2d060
leaq 0x1a0(%rbx), %rsi
xorl %edi, %edi
testb $0x8, %al
cmovneq %rdx, %rsi
sete %dil
movd %edi, %xmm0
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pslld $0x1f, %xmm0
psrad $0x1f, %xmm0
movd 0x25ee2(%rip), %xmm1    # 0x52f28
movdqa %xmm0, %xmm2
pandn %xmm1, %xmm2
pand 0x28c6a(%rip), %xmm0    # 0x55cc0
por %xmm2, %xmm0
pxor %xmm1, %xmm1
jmp 0x2d06f
pxor %xmm0, %xmm0
movd 0x25ebc(%rip), %xmm1    # 0x52f28
movq %rcx, %rsi
movl $0x3f800000, (%rsi)     # imm = 0x3F800000
testb $0x2, %al
je 0x2d091
movdqa 0x28c4f(%rip), %xmm2    # 0x55cd0
pxor %xmm2, %xmm0
movq %xmm0, (%rdx)
pxor %xmm2, %xmm1
movd %xmm1, (%rcx)
movss 0x190(%rbx), %xmm0
pxor %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2d0ae
jp 0x2d0ae
movl $0x42c80000, 0x190(%rbx) # imm = 0x42C80000
cmpl $0x0, 0x280(%rbx)
jne 0x2d0c1
movl $0x2, 0x280(%rbx)
movq 0x3b388(%rip), %rcx     # 0x68450
movq %rcx, 0x228(%rbx)
movq 0x3b492(%rip), %rcx     # 0x68568
movq %rcx, 0x218(%rbx)
testb $0x1, %al
je 0x2d0ef
movq %rbx, %rdi
callq 0x19a60
movl 0x140(%rbx), %eax
testb $0x40, %al
je 0x2d0f7
orb $0x10, 0x41(%rbx)
testb %al, %al
jns 0x2d0ff
orb $0x20, 0x41(%rbx)
movq 0x3b4fa(%rip), %r14     # 0x68600
movq 0x120(%rbx), %rsi
movq %rbx, %rdi
callq *0x58(%r14)
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x90(%rax)
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: button_return
void button_return (edict_t *self)
{
	self->moveinfo.state = STATE_DOWN;

	Move_Calc (self, self->moveinfo.start_origin, button_done);

	self->s.frame = 0;

	if (self->health)
		self->takedamage = DAMAGE_YES;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x338(%rdi), %rsi
movl $0x3, 0x388(%rdi)
movq 0x3b9a2(%rip), %rdx     # 0x68b00
callq 0x18e70
movl $0x0, 0x38(%rbx)
cmpl $0x0, 0x254(%rbx)
je 0x2d17d
movl $0x1, 0x27c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: button_wait
void button_wait (edict_t *self)
{
	self->moveinfo.state = STATE_TOP;
	self->s.effects &= ~EF_ANIM01;
	self->s.effects |= EF_ANIM23;

	G_UseTargets (self, self->activator);
	self->s.frame = 1;
	if (self->moveinfo.wait >= 0)
	{
		self->nextthink = level.time + self->moveinfo.wait;
		self->think = button_return;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x0, 0x388(%rdi)
movl $0xfffff3ff, %eax       # imm = 0xFFFFF3FF
andl 0x40(%rdi), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, 0x40(%rdi)
movq 0x2b0(%rdi), %rsi
callq 0x198e0
movl $0x1, 0x38(%rbx)
movss 0x384(%rbx), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2d1e2
movq 0x3bbd9(%rip), %rax     # 0x68da0
addss 0x4(%rax), %xmm0
movss %xmm0, 0x200(%rbx)
movq 0x3b305(%rip), %rax     # 0x684e0
movq %rax, 0x210(%rbx)
popq %rbx
retq