LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1d4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1d0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1cc(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3b0(%rax)
movq 0x4f0ed(%rip), %rax     # 0x82da0
movq 0x148(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x33ce3
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x33ceb
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jne 0x33d03
movq -0x8(%rbp), %rdi
callq 0x19ce8
jmp 0x33d35
movss 0x3c589(%rip), %xmm0    # 0x70294
movq 0x4f08e(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4e88a(%rip), %rcx     # 0x825b8
movq %rcx, 0x210(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x3428b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x370(%rax)
je 0x34280
movq 0x4e3ac(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x370(%rcx), %edx
movl $0xa, %esi
movss 0x3bc79(%rip), %xmm0    # 0x6feec
movss 0x3bc95(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x388(%rax)
movq -0x8(%rbp), %rax
movq 0x4e714(%rip), %rcx     # 0x829b8
movq %rcx, 0x210(%rax)
movss 0x3bc5d(%rip), %xmm0    # 0x6ff10
movq 0x4eae6(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x34351
movq -0x8(%rbp), %rax
cmpl $0x0, 0x368(%rax)
je 0x34340
movq 0x4e2ec(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x368(%rcx), %edx
movl $0xa, %esi
movss 0x3bbb9(%rip), %xmm0    # 0x6feec
movss 0x3bbd5(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl 0x36c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x388(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x338, %rsi            # imm = 0x338
addq $0x18, %rsi
movq 0x4e527(%rip), %rdx     # 0x828a0
callq 0x18ff0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x343fb
movq -0x8(%rbp), %rax
cmpl $0x0, 0x370(%rax)
je 0x343f0
movq 0x4e23c(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x370(%rcx), %edx
movl $0xa, %esi
movss 0x3bb09(%rip), %xmm0    # 0x6feec
movss 0x3bb25(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x388(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x34481
movq -0x8(%rbp), %rax
cmpl $0x0, 0x368(%rax)
je 0x34470
movq 0x4e1bc(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x368(%rcx), %edx
movl $0xa, %esi
movss 0x3ba89(%rip), %xmm0    # 0x6feec
movss 0x3baa5(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl 0x36c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x388(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x338, %rsi            # imm = 0x338
movq 0x4e503(%rip), %rdx     # 0x829a8
callq 0x18ff0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x34533
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x34533
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq 0x4e270(%rip), %r9      # 0x82768
xorl %eax, %eax
movq %r9, %rcx
movl $0x186a0, (%rsp)        # imm = 0x186A0
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x14, 0x18(%rsp)
callq 0x192c0
cmpq $0x0, -0x10(%rbp)
je 0x34531
movq -0x10(%rbp), %rdi
callq 0x19800
jmp 0x345ad
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq -0x8(%rbp), %rax
movl 0x280(%rax), %eax
movq 0x4e210(%rip), %r9      # 0x82768
xorl %ecx, %ecx
movq %r9, %rcx
movl %eax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x14, 0x18(%rsp)
callq 0x192c0
movq -0x8(%rbp), %rax
cmpl $0x2, 0x388(%rax)
jne 0x34595
movq -0x8(%rbp), %rdi
callq 0x19d70
jmp 0x345ad
movq -0x8(%rbp), %rax
cmpl $0x3, 0x388(%rax)
jne 0x345ab
movq -0x8(%rbp), %rdi
callq 0x180f0
jmp 0x345ad
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x34625
jmp 0x3468a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x254(%rax)
jg 0x34634
jmp 0x3468a
movq -0x8(%rbp), %rax
movq 0x2a0(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x388(%rax)
jne 0x3465b
movq -0x8(%rbp), %rdi
callq 0x180f0
jmp 0x3468a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x388(%rax)
jne 0x34688
movss 0x3b87c(%rip), %xmm0    # 0x6feec
movq 0x4e729(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
jmp 0x3468a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1cc, %rdi            # imm = 0x1CC
movq 0x4d852(%rip), %rsi     # 0x82768
callq 0x18c60
cmpl $0x0, %eax
jne 0x34f69
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1d4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1d0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1cc(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x220(%rax)
jmp 0x34fc7
movq -0x8(%rbp), %rax
movl 0x36c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rdi
addq $0x19c, %rdi            # imm = 0x19C
movq -0x8(%rbp), %rax
movss 0x190(%rax), %xmm0
movq -0x8(%rbp), %rsi
addq $0x1cc, %rsi            # imm = 0x1CC
callq 0x18a80
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x34fc5
movq -0x8(%rbp), %rax
movq 0x4da42(%rip), %rcx     # 0x82a00
movq %rcx, 0x220(%rax)
jmp 0x34fc7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, 0x388(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x338, %rsi            # imm = 0x338
movq 0x4d840(%rip), %rdx     # 0x82b00
callq 0x18ff0
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x254(%rax)
je 0x352eb
movq -0x8(%rbp), %rax
movl $0x1, 0x27c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x388(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
andl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
orl $0x800, %ecx            # imm = 0x800
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rsi
callq 0x19b50
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x353a3
movq 0x4da2c(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x384(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4d144(%rip), %rcx     # 0x824e0
movq %rcx, 0x210(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: button_fire
void button_fire (edict_t *self)
{
	if (self->moveinfo.state == STATE_UP || self->moveinfo.state == STATE_TOP)
		return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x388(%rax)
je 0x353d6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x388(%rax)
jne 0x353db
jmp 0x3545c
movq -0x8(%rbp), %rax
movl $0x2, 0x388(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x368(%rax)
je 0x3543d
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x3543d
movq 0x4d1ef(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x368(%rcx), %edx
movl $0xa, %esi
movss 0x3aabc(%rip), %xmm0    # 0x6feec
movss 0x3aad8(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x338, %rsi            # imm = 0x338
addq $0x18, %rsi
movq 0x4d389(%rip), %rdx     # 0x827e0
callq 0x18ff0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: button_touch
void button_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (!other->client)
		return;

	if (other->health <= 0)
		return;

	self->activator = other;
	button_fire (self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x354d5
jmp 0x354fc
movq -0x10(%rbp), %rax
cmpl $0x0, 0x254(%rax)
jg 0x354e4
jmp 0x354fc
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rdi
callq 0x190e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: button_killed
void button_killed (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	self->activator = attacker;
	self->health = self->max_health;
	self->takedamage = DAMAGE_NO;
	button_fire (self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movl 0x258(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x254(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x27c(%rax)
movq -0x8(%rbp), %rdi
callq 0x190e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_use_areaportals
void door_use_areaportals (edict_t *self, qboolean open)
{
	edict_t	*t = NULL;

	if (!self->target)
		return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x35a3a
jmp 0x35ac0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdx
xorl %eax, %eax
addq $0x158, %rax            # imm = 0x158
movl %eax, %esi
callq 0x19660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x35ac0
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x3d185(%rip), %rsi     # 0x72bfa
callq 0x186f0
cmpl $0x0, %eax
jne 0x35a9c
movq 0x4cb7a(%rip), %rax     # 0x82600
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x32c(%rcx), %edi
movl -0xc(%rbp), %esi
callq *%rax
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdx
xorl %eax, %eax
addq $0x158, %rax            # imm = 0x158
movl %eax, %esi
callq 0x19660
movq %rax, -0x18(%rbp)
jmp 0x35a5c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_hit_top
void door_hit_top (edict_t *self)
{
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_end)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_end, 1, ATTN_STATIC, 0);
		self->s.sound = 0;
	}
	self->moveinfo.state = STATE_TOP;
	if (self->spawnflags & DOOR_TOGGLE)
		return;
	if (self->moveinfo.wait >= 0)
	{
		self->think = door_go_down;
		self->nextthink = level.time + self->moveinfo.wait;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x35b3b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x370(%rax)
je 0x35b30
movq 0x4cafc(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x370(%rcx), %edx
movl $0xa, %esi
movss 0x3a3c9(%rip), %xmm0    # 0x6feec
movss 0x3a3e5(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x388(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x35b5d
jmp 0x35ba7
movq -0x8(%rbp), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x35ba7
movq -0x8(%rbp), %rax
movq 0x4d39c(%rip), %rcx     # 0x82f18
movq %rcx, 0x210(%rax)
movq 0x4d216(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x384(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_go_down
void door_go_down (edict_t *self)
{
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_start)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_start, 1, ATTN_STATIC, 0);
		self->s.sound = self->moveinfo.sound_middle;
	}
	if (self->max_health)
	{
		self->takedamage = DAMAGE_YES;
		self->health = self->max_health;
	}
	
	self->moveinfo.state = STATE_DOWN;
	if (strcmp(self->classname, "func_door") == 0)
		Move_Calc (self, self->moveinfo.start_origin, door_hit_bottom);
	else if (strcmp(self->classname, "func_door_rotating") == 0)
		AngleMove_Calc (self, door_hit_bottom);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x35c21
movq -0x8(%rbp), %rax
cmpl $0x0, 0x368(%rax)
je 0x35c10
movq 0x4ca1c(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x368(%rcx), %edx
movl $0xa, %esi
movss 0x3a2e9(%rip), %xmm0    # 0x6feec
movss 0x3a305(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl 0x36c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x258(%rax)
je 0x35c50
movq -0x8(%rbp), %rax
movl $0x1, 0x27c(%rax)
movq -0x8(%rbp), %rax
movl 0x258(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x254(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x388(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x3cf9a(%rip), %rsi     # 0x72c0a
callq 0x18bf0
cmpl $0x0, %eax
jne 0x35c97
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x338, %rsi            # imm = 0x338
movq 0x4d1c0(%rip), %rdx     # 0x82e50
callq 0x18ff0
jmp 0x35cc5
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x3cf6b(%rip), %rsi     # 0x72c14
callq 0x18bf0
cmpl $0x0, %eax
jne 0x35cc3
movq -0x8(%rbp), %rdi
movq 0x4d192(%rip), %rsi     # 0x82e50
callq 0x182f0
jmp 0x35cc5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_hit_bottom
void door_hit_bottom (edict_t *self)
{
	if (!(self->flags & FL_TEAMSLAVE))
	{
		if (self->moveinfo.sound_end)
			gi.sound (self, CHAN_NO_PHS_ADD+CHAN_VOICE, self->moveinfo.sound_end, 1, ATTN_STATIC, 0);
		self->s.sound = 0;
	}
	self->moveinfo.state = STATE_BOTTOM;
	door_use_areaportals (self, false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x35d3b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x370(%rax)
je 0x35d30
movq 0x4c8fc(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x370(%rcx), %edx
movl $0xa, %esi
movss 0x3a1c9(%rip), %xmm0    # 0x6feec
movss 0x3a1e5(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x388(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x18250
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_go_up
void door_go_up (edict_t *self, edict_t *activator)
{
	if (self->moveinfo.state == STATE_UP)
		return;		// already going up

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, 0x388(%rax)
jne 0x35d82
jmp 0x35ec5
movq -0x8(%rbp), %rax
cmpl $0x0, 0x388(%rax)
jne 0x35dcc
movq -0x8(%rbp), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x35dc7
movq 0x4cff6(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x384(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
jmp 0x35ec5
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x35e31
movq -0x8(%rbp), %rax
cmpl $0x0, 0x368(%rax)
je 0x35e20
movq 0x4c80c(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x368(%rcx), %edx
movl $0xa, %esi
movss 0x3a0d9(%rip), %xmm0    # 0x6feec
movss 0x3a0f5(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl 0x36c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x388(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x3cdb9(%rip), %rsi     # 0x72c0a
callq 0x18bf0
cmpl $0x0, %eax
jne 0x35e7c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x338, %rsi            # imm = 0x338
addq $0x18, %rsi
movq 0x4ca33(%rip), %rdx     # 0x828a8
callq 0x18ff0
jmp 0x35eaa
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rdi
leaq 0x3cd86(%rip), %rsi     # 0x72c14
callq 0x18bf0
cmpl $0x0, %eax
jne 0x35ea8
movq -0x8(%rbp), %rdi
movq 0x4ca05(%rip), %rsi     # 0x828a8
callq 0x182f0
jmp 0x35eaa
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19b50
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x18250
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_use
void door_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t	*ent;

	if (self->flags & FL_TEAMSLAVE)
		return;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x35efd
jmp 0x35fbf
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x35f74
movq -0x8(%rbp), %rax
cmpl $0x2, 0x388(%rax)
je 0x35f29
movq -0x8(%rbp), %rax
cmpl $0x0, 0x388(%rax)
jne 0x35f72
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x35f70
movq -0x20(%rbp), %rax
movq $0x0, 0x130(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x20(%rbp), %rdi
callq 0x19de0
movq -0x20(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x35f31
jmp 0x35fbf
jmp 0x35f74
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x35fbf
movq -0x20(%rbp), %rax
movq $0x0, 0x130(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18830
movq -0x20(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x35f7c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: Touch_DoorTrigger
void Touch_DoorTrigger (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (other->health <= 0)
		return;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x254(%rax)
jg 0x35ffa
jmp 0x360ac
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x3601c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x3601c
jmp 0x360ac
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movl 0x140(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x36049
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x36049
jmp 0x360ac
movq 0x4cd50(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x240(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x36068
jmp 0x360ac
movq 0x4cd31(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x39ec0(%rip), %xmm1    # 0x6ff40
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x240(%rax)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x19d78
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_blocked
void door_blocked  (edict_t *self, edict_t *other)
{
	edict_t	*ent;

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

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

	if (self->spawnflags & DOOR_CRUSHER)
		return;


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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x36546
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x36546
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq 0x4c260(%rip), %r9      # 0x82768
xorl %eax, %eax
movq %r9, %rcx
movl $0x186a0, (%rsp)        # imm = 0x186A0
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x14, 0x18(%rsp)
callq 0x192c0
cmpq $0x0, -0x10(%rbp)
je 0x36541
movq -0x10(%rbp), %rdi
callq 0x19800
jmp 0x36639
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq -0x8(%rbp), %rax
movl 0x280(%rax), %eax
movq 0x4c1fd(%rip), %r9      # 0x82768
xorl %ecx, %ecx
movq %r9, %rcx
movl %eax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x14, 0x18(%rsp)
callq 0x192c0
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x365a7
jmp 0x36639
movq -0x8(%rbp), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x36639
movq -0x8(%rbp), %rax
cmpl $0x3, 0x388(%rax)
jne 0x36605
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x36603
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x2b0(%rax), %rsi
callq 0x18830
movq -0x18(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x365d7
jmp 0x36637
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x36635
movq -0x18(%rbp), %rdi
callq 0x19de0
movq -0x18(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x36614
jmp 0x36637
jmp 0x36639
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_killed
void door_killed (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
{
	edict_t	*ent;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x366a4
movq -0x30(%rbp), %rax
movl 0x258(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x254(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x27c(%rax)
movq -0x30(%rbp), %rax
movq 0x2c8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x3666a
movq -0x8(%rbp), %rax
movq 0x2d0(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x19d78
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: door_touch
void door_touch (edict_t *self, edict_t *other, cplane_t *plane, csurface_t *surf)
{
	if (!other->client)
		return;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x366f8
jmp 0x367af
movq 0x4c6a1(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x240(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x3671a
jmp 0x367af
movq 0x4c67f(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x3c45e(%rip), %xmm1    # 0x72b90
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x240(%rax)
movq 0x4beb3(%rip), %rax     # 0x82600
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdx
leaq 0x39236(%rip), %rsi     # 0x6f99d
movb $0x0, %al
callq *%rcx
movq 0x4be8e(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x3c49e(%rip), %rdi     # 0x72c27
movq 0x4be70(%rip), %rax     # 0x82600
callq *0x48(%rax)
movq -0x30(%rbp), %rdi
movl %eax, %edx
movq -0x28(%rbp), %rax
xorl %esi, %esi
movss 0x39745(%rip), %xmm1    # 0x6feec
xorps %xmm2, %xmm2
movaps %xmm1, %xmm0
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: train_blocked
void train_blocked (edict_t *self, edict_t *other)
{
	if (!(other->svflags & SVF_MONSTER) && (!other->client) )
	{
		// give it a chance to go away on it's own terms (like gibs)
		T_Damage (other, self, self, vec3_origin, other->s.origin, vec3_origin, 100000, 1, 0, MOD_CRUSH);
		// if it's still there, nuke it
		if (other)
			BecomeExplosion1 (other);
		return;
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x37c36
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x37c36
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq 0x4ab70(%rip), %r9      # 0x82768
xorl %eax, %eax
movq %r9, %rcx
movl $0x186a0, (%rsp)        # imm = 0x186A0
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x14, 0x18(%rsp)
callq 0x192c0
cmpq $0x0, -0x10(%rbp)
je 0x37c31
movq -0x10(%rbp), %rdi
callq 0x19800
jmp 0x37cdd
movq 0x4b163(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm1
movq -0x8(%rbp), %rax
movss 0x240(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x37c58
jmp 0x37cdd
movq -0x8(%rbp), %rax
cmpl $0x0, 0x280(%rax)
jne 0x37c67
jmp 0x37cdd
movq 0x4b132(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x397a9(%rip), %xmm1    # 0x71428
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x240(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r8
addq $0x4, %r8
movq -0x8(%rbp), %rax
movl 0x280(%rax), %eax
movq 0x4aab0(%rip), %r9      # 0x82768
xorl %ecx, %ecx
movq %r9, %rcx
movl %eax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x14, 0x18(%rsp)
callq 0x192c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: train_wait
void train_wait (edict_t *self)
{
	if (self->target_ent->pathtarget)
	{
		char	*savetarget;
		edict_t	*ent;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x188(%rax), %rax
cmpq $0x0, 0x170(%rax)
je 0x37d79
movq -0x8(%rbp), %rax
movq 0x188(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x150(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x170(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x150(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x2b0(%rax), %rsi
callq 0x19b50
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x150(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x37d77
jmp 0x37eb6
jmp 0x37d79
movq -0x8(%rbp), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x37d94
jp 0x37d94
jmp 0x37ead
movq -0x8(%rbp), %rax
movss 0x384(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x37de0
movq 0x4aff1(%rip), %rax     # 0x82da0
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
addss 0x384(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4ab11(%rip), %rcx     # 0x828e8
movq %rcx, 0x210(%rax)
jmp 0x37e4c
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x37e4a
movq -0x8(%rbp), %rdi
callq 0x19d60
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x200(%rax)
jmp 0x37e4c
movq -0x8(%rbp), %rax
movl 0x11c(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x37eab
movq -0x8(%rbp), %rax
cmpl $0x0, 0x370(%rax)
je 0x37ea0
movq 0x4a78c(%rip), %rax     # 0x82600
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl 0x370(%rcx), %edx
movl $0xa, %esi
movss 0x38059(%rip), %xmm0    # 0x6feec
movss 0x38075(%rip), %xmm1    # 0x6ff10
xorps %xmm2, %xmm2
callq *%rax
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
jmp 0x37eb6
movq -0x8(%rbp), %rdi
callq 0x19d60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: train_resume
void train_resume (edict_t *self)
{
	edict_t	*ent;
	vec3_t	dest;

	ent = self->target_ent;

	VectorSubtract (ent->s.origin, self->mins, dest);
	self->moveinfo.state = STATE_TOP;
	VectorCopy (self->s.origin, self->moveinfo.start_origin);
	VectorCopy (dest, self->moveinfo.end_origin);
	Move_Calc (self, dest, train_wait);
	self->spawnflags |= TRAIN_START_ON;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x188(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xcc(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xd0(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xd4(%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x388(%rax)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x338(%rax)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x33c(%rax)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x340(%rax)
movss -0x1c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x350(%rax)
movss -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x354(%rax)
movss -0x14(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x358(%rax)
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movq 0x4acc8(%rip), %rdx     # 0x82fb0
callq 0x18ff0
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: func_train_find
void func_train_find (edict_t *self)
{
	edict_t *ent;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x38342
leaq 0x3a9d9(%rip), %rdi     # 0x72d0a
movq 0x4a2c8(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x8(%rcx)
jmp 0x3847b
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdi
callq 0x18390
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x38383
movq 0x4a29c(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rsi
leaq 0x3a9a7(%rip), %rdi     # 0x72d21
movb $0x0, %al
callq *%rcx
jmp 0x3847b
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x150(%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xcc(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xd0(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x8(%rbp), %rax
subss 0xd4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0xc(%rax)
movq 0x4a206(%rip), %rax     # 0x82600
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x158(%rax)
jne 0x38428
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3847b
movss 0x37e52(%rip), %xmm0    # 0x70294
movq 0x4a957(%rip), %rax     # 0x82da0
addss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x200(%rax)
movq -0x8(%rbp), %rax
movq 0x4a483(%rip), %rcx     # 0x828e8
movq %rcx, 0x210(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: train_use
void train_use (edict_t *self, edict_t *other, edict_t *activator)
{
	self->activator = activator;

	if (self->spawnflags & TRAIN_START_ON)
	{
		if (!(self->spawnflags & TRAIN_TOGGLE))
			return;
		self->spawnflags &= ~TRAIN_START_ON;
		VectorClear (self->velocity);
		self->nextthink = 0;
	}
	else
	{
		if (self->target_ent)
			train_resume(self);
		else
			train_next(self);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3852a
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x384d9
jmp 0x3854e
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c4(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x1c0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x200(%rax)
jmp 0x3854e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x188(%rax)
je 0x38543
movq -0x8(%rbp), %rdi
callq 0x19b10
jmp 0x3854c
movq -0x8(%rbp), %rdi
callq 0x19d60
jmp 0x3854e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: trigger_elevator_use
void trigger_elevator_use (edict_t *self, edict_t *other, edict_t *activator)
{
	edict_t *target;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movss 0x200(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x38783
jp 0x38783
jmp 0x38788
jmp 0x3880f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x170(%rax)
jne 0x387ab
leaq 0x3a5c8(%rip), %rdi     # 0x72d65
movq 0x49e5c(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x8(%rcx)
jmp 0x3880f
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rdi
callq 0x18390
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x387e9
movq 0x49e33(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rsi
leaq 0x3a5a4(%rip), %rdi     # 0x72d87
movb $0x0, %al
callq *%rcx
jmp 0x3880f
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movq %rcx, 0x188(%rax)
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rdi
callq 0x19b10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/g_func.c
// Function: trigger_elevator_init
void trigger_elevator_init (edict_t *self)
{
	if (!self->target)
	{
		gi.dprintf("trigger_elevator has no target\n");
		return;
	}
	self->movetarget = G_PickTarget (self->target);
	if (!self->movetarget)
	{
		gi.dprintf("trigger_elevator unable to find target %s\n", self->target);
		return;
	}
	if (strcmp(self->movetarget->classname, "func_train") != 0)
	{
		gi.dprintf("trigger_elevator target %s is not a train\n", self->target);
		return;
	}

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x38852
leaq 0x3a56d(%rip), %rdi     # 0x72dae
movq 0x49db8(%rip), %rcx     # 0x82600
movb $0x0, %al
callq *0x8(%rcx)
jmp 0x38907
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rdi
callq 0x18390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1f0(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1f0(%rax)
jne 0x388a1
movq 0x49d7b(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rsi
leaq 0x3a533(%rip), %rdi     # 0x72dce
movb $0x0, %al
callq *%rcx
jmp 0x38907
movq -0x8(%rbp), %rax
movq 0x1f0(%rax), %rax
movq 0x138(%rax), %rdi
leaq 0x3a53f(%rip), %rsi     # 0x72df9
callq 0x18bf0
cmpl $0x0, %eax
je 0x388e7
movq 0x49d35(%rip), %rax     # 0x82600
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rsi
leaq 0x3a523(%rip), %rdi     # 0x72e04
movb $0x0, %al
callq *%rcx
jmp 0x38907
movq -0x8(%rbp), %rax
movq 0x4a406(%rip), %rcx     # 0x82cf8
movq %rcx, 0x228(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)