// File: /workspace/github_cpp_makefile_star2_O2/FreeSlave[P]vhlt/hlcsg/brush.cpp
// Function: ExpandBrush(brush_s*, int)
void ExpandBrush(brush_t* brush, const int hullnum)
{
#ifdef HLCSG_HULLBRUSH
	const hullshape_t *hs = &g_defaulthulls[hullnum];
	{ // look up the name of its hull shape in g_hullshapes[]
		const char *name = brush->hullshapes[hullnum];
		if (name && *name)
		{
			bool found = false;
			for (int i = 0; i < g_numhullshapes; i++)
			{
				const hullshape_t *s = &g_hullshapes[i];
				if (!strcmp (name, s->id))
				{
					if (found)
					{
						Warning ("Entity %i, Brush %i: Found several info_hullshape entities with the same name '%s'.",
#ifdef HLCSG_COUNT_NEW
							brush->originalentitynum, brush->originalbrushnum,
#else
							brush->entitynum, brush->brushnum,
#endif
							name);
					}
					hs = s;
					found = true;
				}
			}
			if (!found)
			{
				Error ("Entity %i, Brush %i: Couldn't find info_hullshape entity '%s'.",
#ifdef HLCSG_COUNT_NEW
					brush->originalentitynum, brush->originalbrushnum,
#else
					brush->entitynum, brush->brushnum,
#endif
					name);
			}
		}
	}

	if (!hs->disabled)
	{
		if (hs->numbrushes == 0)
		{
			return; // leave this hull of this brush empty (noclip)
		}
		ExpandBrushWithHullBrush (brush, &brush->hulls[0], hs->brushes[0], &brush->hulls[hullnum]);

		return;
	}
#endif
	//for looping through the faces and constructing the hull
	bface_t* current_face;
	plane_t* current_plane;
	brushhull_t* hull;
	vec3_t	origin, normal;

	//for non-axial bevel testing
	Winding* winding;
	bface_t* other_face;
	plane_t* other_plane;
	Winding* other_winding;
	vec3_t  edge_start, edge_end, edge, bevel_edge;
	unsigned int counter, counter2, dir;
	bool start_found,end_found;
	bool axialbevel[last_axial+1][2] = { {false,false}, {false,false}, {false,false} };

	bool warned = false;

	hull = &brush->hulls[hullnum];

	// step 1: for collision between player vertex and brush face. --vluzacn
	for(current_face = brush->hulls[0].faces; current_face; current_face = current_face->next)
	{
		current_plane = current_face->plane;

		//don't bother adding axial planes,
		//they're defined by adding the bounding box anyway
		if(current_plane->type <= last_axial)
		{
			//flag case where bounding box shouldn't expand
#ifdef HLCSG_CUSTOMHULL
			if (current_face->bevel)
#else
			if((g_texinfo[current_face->texinfo].flags & TEX_BEVEL))
#endif
			{
				switch(current_plane->type)
				{
				case plane_x:
					axialbevel[plane_x][(current_plane->normal[0] > 0 ? 1 : 0)] = true;
					break;
				case plane_y:
					axialbevel[plane_y][(current_plane->normal[1] > 0 ? 1 : 0)] = true;
					break;
				case plane_z:
					axialbevel[plane_z][(current_plane->normal[2] > 0 ? 1 : 0)] = true;
					break;
				}
			}
			continue;
		}

		//add the offset non-axial plane to the expanded hull
        VectorCopy(current_plane->origin, origin);
        VectorCopy(current_plane->normal, normal);

		//old code multiplied offset by normal -- this led to post-csg "sticky" walls where a
		//slope met an axial plane from the next brush since the offset from the slope would be less
		//than the full offset for the axial plane -- the discontinuity also contributes to increased
		//clipnodes.  If the normal is zero along an axis, shifting the origin in that direction won't
		//change the plane number, so I don't explicitly test that case.  The old method is still used if
		//preciseclip is turned off to allow backward compatability -- some of the improperly beveled edges
		//grow using the new origins, and might cause additional problems.

#ifdef HLCSG_CUSTOMHULL
		if (current_face->bevel)
#else
		if((g_texinfo[current_face->texinfo].flags & TEX_BEVEL))
#endif
		{
			//don't adjust origin - we'll correct g_texinfo's flags in a later step
		}
#ifdef HLCSG_CLIPTYPEPRECISE_EPSILON_FIX
		// The old offset will generate an extremely small gap when the normal is close to axis, causing epsilon errors (ambiguous leafnode content, player falling into ground, etc.).
		// For example: with the old shifting method, slopes with angle arctan(1/8) and arctan(1/64) will result in gaps of 0.0299 unit and 0.000488 unit respectively, which are smaller than ON_EPSILON, while in both 'simple' cliptype and the new method, the gaps are 2.0 units and 0.25 unit, which are good.
		// This also reduce the number of clipnodes used for cliptype precise.
		// The maximum difference in height between the old offset and the new offset is 0.86 unit for standing player and 6.9 units for ducking player. (when FLOOR_Z = 0.7)
		// And another reason not to use the old offset is that the old offset is quite wierd. It might appears at first glance that it regards the player as an ellipse, but in fact it isn't, and the player's feet may even sink slightly into the ground theoretically for slopes of certain angles.
		else if (g_cliptype == clip_precise && normal[2] > FLOOR_Z)
		{
			origin[0] += 0;
			origin[1] += 0;
			origin[2] += g_hull_size[hullnum][1][2];
		}
		else if (g_cliptype == clip_legacy || g_cliptype == clip_normalized)
#else
		else if(g_cliptype == clip_legacy || (g_cliptype == clip_precise && (normal[2] > FLOOR_Z)) || g_cliptype == clip_normalized)
#endif
		{
			if(normal[0])
			{ origin[0] += normal[0] * (normal[0] > 0 ? g_hull_size[hullnum][1][0] : -g_hull_size[hullnum][0][0]); }
			if(normal[1])
			{ origin[1] += normal[1] * (normal[1] > 0 ? g_hull_size[hullnum][1][1] : -g_hull_size[hullnum][0][1]); }
			if(normal[2])
			{ origin[2] += normal[2] * (normal[2] > 0 ? g_hull_size[hullnum][1][2] : -g_hull_size[hullnum][0][2]); }
		}
		else
		{
			origin[0] += g_hull_size[hullnum][(normal[0] > 0 ? 1 : 0)][0];
			origin[1] += g_hull_size[hullnum][(normal[1] > 0 ? 1 : 0)][1];
			origin[2] += g_hull_size[hullnum][(normal[2] > 0 ? 1 : 0)][2];
		}

		AddHullPlane(hull,normal,origin,false);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movl %esi, 0x8c(%rsp)
movslq %esi, %r8
imulq $0x18, %r8, %rax
leaq 0x30bd6bd(%rip), %rcx   # 0x30ca950
addq %rax, %rcx
movq %rdi, 0x38(%rsp)
movq 0x38(%rdi,%r8,8), %rbx
testq %rbx, %rbx
je 0xd353
cmpb $0x0, (%rbx)
je 0xd353
movq %rcx, 0x40(%rsp)
movq %r8, 0x78(%rsp)
leaq 0x30bd6fd(%rip), %r13   # 0x30ca9c0
movl 0x30bd6e6(%rip), %r14d  # 0x30ca9b0
xorl %r15d, %r15d
xorl %ebp, %ebp
movslq %r14d, %rax
cmpq %rax, %rbp
jge 0xd328
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x4480
testl %eax, %eax
je 0xd2ec
movl %r15d, %r12d
jmp 0xd31c
movb $0x1, %r12b
testb $0x1, %r15b
je 0xd317
movq 0x38(%rsp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
leaq 0xf2c3(%rip), %rdi      # 0x1c5c9
movq %rbx, %rcx
xorl %eax, %eax
callq 0x90f1
movl 0x30bd699(%rip), %r14d  # 0x30ca9b0
movq %r13, 0x40(%rsp)
incq %rbp
addq $0x18, %r13
movl %r12d, %r15d
jmp 0xd2cf
testb $0x1, %r15b
jne 0xd349
movq 0x38(%rsp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
leaq 0xf2de(%rip), %rdi      # 0x1c61d
movq %rbx, %rcx
xorl %eax, %eax
callq 0x8d7b
movq 0x78(%rsp), %r8
movq 0x40(%rsp), %rcx
cmpb $0x0, 0x8(%rcx)
je 0xd5e6
andw $0x0, 0x14(%rsp)
andl $0x0, 0x10(%rsp)
movq 0x38(%rsp), %rcx
leaq 0x60(%rcx), %rax
movq %rax, 0xc8(%rsp)
imulq $0x38, %r8, %rax
addq %rcx, %rax
addq $0x60, %rax
movq %rax, 0x80(%rsp)
leaq 0x90(%rcx), %r15
imulq $0x30, %r8, %r14
leaq 0x19fd2(%rip), %rax     # 0x27370
leaq (%rax,%r14), %rcx
addq $0x18, %rcx
movq %rcx, 0x18(%rsp)
addq %r14, %rax
movq %rax, 0x70(%rsp)
xorpd %xmm6, %xmm6
leaq 0x50(%rsp), %rbx
addq 0x18be5(%rip), %r14     # 0x25fa8
movq %r15, 0x90(%rsp)
movq (%r15), %r15
testq %r15, %r15
je 0xd622
movq 0x10(%r15), %rax
movl 0x38(%rax), %ecx
cmpl $0x2, %ecx
jg 0xd414
cmpb $0x1, 0x30(%r15)
jne 0xd3cb
cmpl $0x2, %ecx
je 0xd4cd
cmpl $0x1, %ecx
je 0xd4b5
testl %ecx, %ecx
jne 0xd3cb
movsd (%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm6, %xmm0
seta %al
movb $0x1, 0x10(%rsp,%rax)
jmp 0xd3cb
movupd 0x18(%rax), %xmm2
movapd %xmm2, 0x20(%rsp)
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movupd (%rax), %xmm4
movapd %xmm4, 0x50(%rsp)
movsd 0x10(%rax), %xmm1
movsd %xmm1, 0x60(%rsp)
cmpb $0x0, 0x30(%r15)
jne 0xd5c6
leaq 0x1a017(%rip), %rax     # 0x27468
movl (%rax), %eax
cmpl $0x3, %eax
jne 0xd47f
ucomisd 0xf048(%rip), %xmm1     # 0x1c4a8
jbe 0xd47f
addpd 0xefd6(%rip), %xmm2     # 0x1c440
movapd %xmm2, 0x20(%rsp)
movq 0x18(%rsp), %rax
addsd 0x10(%rax), %xmm0
jmp 0xd52a
movapd %xmm4, %xmm3
unpckhpd %xmm4, %xmm3            # xmm3 = xmm3[1],xmm4[1]
cmpl $0x4, %eax
je 0xd491
cmpl $0x1, %eax
jne 0xd4e5
ucomisd %xmm6, %xmm4
jne 0xd49d
jnp 0xd552
ucomisd %xmm6, %xmm4
jbe 0xd533
movq 0x18(%rsp), %rax
movsd (%rax), %xmm5
jmp 0xd544
movsd 0x8(%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm6, %xmm0
seta %al
movb $0x1, 0x12(%rsp,%rax)
jmp 0xd3cb
movsd 0x10(%rax), %xmm0
xorl %eax, %eax
ucomisd %xmm6, %xmm0
seta %al
movb $0x1, 0x14(%rsp,%rax)
jmp 0xd3cb
xorl %eax, %eax
ucomisd %xmm6, %xmm4
seta %al
imulq $0x18, %rax, %rax
xorl %ecx, %ecx
ucomisd %xmm6, %xmm3
seta %cl
imulq $0x18, %rcx, %rcx
movsd (%rax,%r14), %xmm3
movhpd 0x8(%rcx,%r14), %xmm3   # xmm3 = xmm3[0],mem[0]
addpd %xmm3, %xmm2
movapd %xmm2, 0x20(%rsp)
xorl %eax, %eax
ucomisd %xmm6, %xmm1
seta %al
imulq $0x18, %rax, %rax
addsd 0x10(%rax,%r14), %xmm0
movapd %xmm0, %xmm1
jmp 0xd5c0
movq 0x70(%rsp), %rax
movsd (%rax), %xmm5
xorpd 0xecfc(%rip), %xmm5     # 0x1c240
mulsd %xmm5, %xmm4
addsd %xmm2, %xmm4
movsd %xmm4, 0x20(%rsp)
ucomisd %xmm6, %xmm3
jne 0xd55a
jnp 0xd590
ucomisd %xmm6, %xmm3
jbe 0xd56c
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm4
jmp 0xd57e
movq 0x18(%rsp), %rax
movsd -0x10(%rax), %xmm4
xorpd 0xecc2(%rip), %xmm4     # 0x1c240
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x28(%rsp)
ucomisd %xmm6, %xmm1
jne 0xd598
jnp 0xd5c6
jbe 0xd5a6
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
jmp 0xd5b8
movq 0x18(%rsp), %rax
movsd -0x8(%rax), %xmm2
xorpd 0xec88(%rip), %xmm2     # 0x1c240
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
movq 0x80(%rsp), %rdi
movq %rbx, %rsi
leaq 0x20(%rsp), %rdx
xorl %ecx, %ecx
callq 0xc75e
xorpd %xmm6, %xmm6
jmp 0xd3cb
cmpl $0x0, 0xc(%rcx)
je 0xdccf
movq 0x38(%rsp), %rdi
leaq 0x60(%rdi), %rsi
movq 0x10(%rcx), %rax
movq (%rax), %rdx
imulq $0x38, %r8, %rax
leaq (%rdi,%rax), %rcx
addq $0x60, %rcx
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc7c5
leaq 0x19e3f(%rip), %rax     # 0x27468
movl (%rax), %eax
decl %eax
cmpl $0x2, %eax
ja 0xdb5c
xorl %ecx, %ecx
movq 0x90(%rsp), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xdb5c
movq 0x10(%r15), %rax
movq %rax, 0x78(%rsp)
movq 0x18(%r15), %rbx
xorl %r14d, %r14d
movq %r15, 0x40(%rsp)
movq %rbx, 0x98(%rsp)
cmpl $0x1, 0x8c(%rsp)
setne %al
orb %cl, %al
movb %al, 0xf(%rsp)
movq %rcx, 0xa0(%rsp)
movl 0x8(%rbx), %eax
cmpq %rax, %r14
jae 0xd640
movq 0x10(%rbx), %rax
imulq $0x18, %r14, %rcx
movsd (%rax,%rcx), %xmm1
movsd %xmm1, 0xb0(%rsp)
movsd 0x8(%rax,%rcx), %xmm0
movsd %xmm0, 0xb8(%rsp)
movsd 0x10(%rax,%rcx), %xmm2
movsd %xmm2, 0xc0(%rsp)
movq 0x10(%rbx), %rcx
incq %r14
movl %r14d, %eax
xorl %edx, %edx
divl 0x8(%rbx)
imulq $0x18, %rdx, %rax
movsd (%rcx,%rax), %xmm4
movsd %xmm4, 0x110(%rsp)
movsd 0x8(%rcx,%rax), %xmm5
movsd %xmm5, 0x118(%rsp)
movq %r14, 0xa8(%rsp)
movl %r14d, %eax
xorl %edx, %edx
divl 0x8(%rbx)
imulq $0x18, %rdx, %rax
movsd 0x10(%rcx,%rax), %xmm3
movsd %xmm3, 0x120(%rsp)
subsd %xmm1, %xmm4
movapd %xmm4, 0x100(%rsp)
unpcklpd %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
subpd %xmm0, %xmm5
movapd %xmm5, 0xf0(%rsp)
movq 0x90(%rsp), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xdafb
cmpq %r15, %rbx
je 0xd73b
movq 0x18(%rbx), %r12
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %r14d, %r14d
xorl %ebp, %ebp
movl 0x8(%r12), %eax
cmpq %rax, %r13
jae 0xd7c9
testb $0x1, %r14b
jne 0xd78d
movq 0x10(%r12), %rdi
addq %r15, %rdi
leaq 0xb0(%rsp), %rsi
callq 0xfae3
movzbl %r14b, %r14d
testb %al, %al
pushq $0x1
popq %rax
cmovnel %eax, %r14d
testb $0x1, %bpl
jne 0xd7b4
movq 0x10(%r12), %rdi
addq %r15, %rdi
leaq 0x110(%rsp), %rsi
callq 0xfae3
movzbl %bpl, %ebp
testb %al, %al
pushq $0x1
popq %rax
cmovnel %eax, %ebp
testb $0x1, %r14b
je 0xd7c0
testb $0x1, %bpl
jne 0xd7c9
incq %r13
addq $0x18, %r15
jmp 0xd75b
testb $0x1, %r14b
movq 0x40(%rsp), %r15
je 0xd73b
testb $0x1, %bpl
je 0xd73b
movq 0x10(%rbx), %rbx
movapd 0xf0(%rsp), %xmm1
movapd %xmm1, %xmm2
shufpd $0x1, 0x100(%rsp), %xmm2 # xmm2 = xmm2[1],mem[0]
movapd 0xea3b(%rip), %xmm0     # 0x1c240
xorpd %xmm0, %xmm2
movapd %xmm2, 0x140(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, 0x130(%rsp)
xorl %ebp, %ebp
cmpq $0x3, %rbp
je 0xdb20
movq %rbp, %r14
movq 0x78(%rsp), %rax
movsd (%rax,%rbp,8), %xmm0
movsd (%rbx,%rbp,8), %xmm1
mulsd %xmm0, %xmm1
movsd 0xec4f(%rip), %xmm2     # 0x1c498
ucomisd %xmm1, %xmm2
jbe 0xd9a7
xorl %eax, %eax
ucomisd 0xec43(%rip), %xmm0     # 0x1c4a0
seta %al
andq $0x0, 0xe0(%rsp)
leaq 0xebc0(%rip), %rcx      # 0x1c430
movsd (%rcx,%rax,8), %xmm0
xorpd %xmm1, %xmm1
movapd %xmm1, 0xd0(%rsp)
movsd %xmm0, 0xd0(%rsp,%r14,8)
movsd 0xd0(%rsp), %xmm0
movupd 0xd8(%rsp), %xmm1
movapd %xmm1, %xmm2
mulpd 0x140(%rsp), %xmm2
movapd 0x100(%rsp), %xmm3
mulsd %xmm1, %xmm3
shufpd $0x1, %xmm0, %xmm1      # xmm1 = xmm1[1],xmm0[0]
mulpd 0xf0(%rsp), %xmm1
addpd %xmm2, %xmm1
movapd %xmm1, 0x50(%rsp)
mulsd 0x130(%rsp), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, 0x60(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xc2e9
leaq 0x1(%r14), %rbp
cmpq $0x2, %r14
movl %ebp, %eax
movl $0x0, %ecx
cmovneq %rax, %rcx
movsd 0x50(%rsp,%rcx,8), %xmm0
andpd 0xe942(%rip), %xmm0     # 0x1c250
movsd 0xb76a(%rip), %xmm1     # 0x19080
ucomisd %xmm0, %xmm1
jae 0xd821
leal -0x1(%r14), %eax
testq %r14, %r14
pushq $0x2
popq %rcx
cmoveq %rcx, %rax
movsd 0x50(%rsp,%rax,8), %xmm0
andpd 0xe914(%rip), %xmm0     # 0x1c250
movsd 0xb73c(%rip), %xmm1     # 0x19080
ucomisd %xmm0, %xmm1
jae 0xd821
movapd 0xb0(%rsp), %xmm2
movapd %xmm2, 0x20(%rsp)
movsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x19af5(%rip), %rax     # 0x27468
movl (%rax), %eax
movsd 0x60(%rsp), %xmm1
cmpl $0x3, %eax
jne 0xd9b2
ucomisd 0xeb20(%rip), %xmm1     # 0x1c4a8
jbe 0xd9b2
addpd 0xeaae(%rip), %xmm2     # 0x1c440
movapd %xmm2, 0x20(%rsp)
movq 0x18(%rsp), %rax
addsd 0x10(%rax), %xmm0
jmp 0xda32
incq %r14
movq %r14, %rbp
jmp 0xd821
movsd 0x50(%rsp), %xmm3
cmpl $0x1, %eax
jne 0xd9e1
ucomisd 0xeadb(%rip), %xmm3     # 0x1c4a0
jne 0xd9cd
jnp 0xda7a
jbe 0xda5b
movq 0x18(%rsp), %rax
movsd (%rax), %xmm4
jmp 0xda6c
xorl %eax, %eax
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
seta %al
imulq $0x18, %rax, %rax
movsd 0x58(%rsp), %xmm3
xorl %ecx, %ecx
ucomisd %xmm4, %xmm3
seta %cl
imulq $0x18, %rcx, %rcx
movq 0x70(%rsp), %rdx
movsd (%rax,%rdx), %xmm3
movhpd 0x8(%rcx,%rdx), %xmm3   # xmm3 = xmm3[0],mem[0]
addpd %xmm3, %xmm2
movapd %xmm2, 0x20(%rsp)
xorl %eax, %eax
ucomisd %xmm4, %xmm1
seta %al
imulq $0x18, %rax, %rax
addsd 0x10(%rax,%rdx), %xmm0
movapd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
movq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0xc75e
jmp 0xd821
movq 0x70(%rsp), %rax
movsd (%rax), %xmm4
xorpd 0xe7d4(%rip), %xmm4     # 0x1c240
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x20(%rsp)
movsd 0x58(%rsp), %xmm3
ucomisd 0xea18(%rip), %xmm3     # 0x1c4a0
jne 0xda8c
jnp 0xdabe
jbe 0xda9a
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm4
jmp 0xdaac
movq 0x18(%rsp), %rax
movsd -0x10(%rax), %xmm4
xorpd 0xe794(%rip), %xmm4     # 0x1c240
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
mulsd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x28(%rsp)
ucomisd 0xe9da(%rip), %xmm1     # 0x1c4a0
jne 0xdace
jnp 0xda3c
jbe 0xdadc
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
jmp 0xdaee
movq 0x18(%rsp), %rax
movsd -0x8(%rax), %xmm2
xorpd 0xe752(%rip), %xmm2     # 0x1c240
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
jmp 0xda36
testb $0x1, 0xf(%rsp)
movq 0xa0(%rsp), %rcx
movq 0x98(%rsp), %rbx
movq 0xa8(%rsp), %r14
jne 0xd682
jmp 0xdb3d
movq 0xa0(%rsp), %rcx
movq 0x98(%rsp), %rbx
movq 0xa8(%rsp), %r14
jmp 0xd682
movq 0x38(%rsp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
leaq 0xea3a(%rip), %rdi      # 0x1c588
xorl %eax, %eax
callq 0x90f1
movb $0x1, %cl
jmp 0xd669
movq 0x38(%rsp), %r15
movupd 0x60(%r15), %xmm0
movq 0x70(%rsp), %rbp
addpd (%rbp), %xmm0
movapd %xmm0, 0x20(%rsp)
movsd 0x70(%r15), %xmm0
addsd 0x10(%rbp), %xmm0
movsd %xmm0, 0x30(%rsp)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x50(%rsp), %rbx
movq %rax, (%rbx)
xorpd %xmm0, %xmm0
cmpb $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %rax
movupd %xmm0, (%rax)
leaq 0x20(%rsp), %r13
movq %r13, %rdx
movq 0xc8(%rsp), %r14
cmovneq %r14, %rdx
movq 0x80(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xc75e
xorpd %xmm0, %xmm0
movhpd 0xe627(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
movapd %xmm0, 0x40(%rsp)
cmpb $0x0, 0x12(%rsp)
movapd %xmm0, (%rbx)
movq %r13, %rdx
cmovneq %r14, %rdx
movq %r12, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xc75e
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x8(%rbx)
cmpb $0x0, 0x14(%rsp)
cmoveq %r13, %r14
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xc75e
andq $0x0, 0x10(%rbx)
leaq 0x78(%r15), %r14
movupd 0x78(%r15), %xmm0
movupd 0x18(%rbp), %xmm1
addpd %xmm0, %xmm1
movapd %xmm1, 0x20(%rsp)
movsd 0x88(%r15), %xmm0
addsd 0x28(%rbp), %xmm0
movsd %xmm0, 0x30(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
cmpb $0x0, 0x11(%rsp)
movq %rax, (%rbx)
movq %r13, %rdx
cmovneq %r14, %rdx
movq %r12, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xc75e
xorpd %xmm0, %xmm0
movhpd 0xe3ce(%rip), %xmm0     # xmm0 = xmm0[0],mem[0]
movapd %xmm0, 0x40(%rsp)
cmpb $0x0, 0x13(%rsp)
movapd %xmm0, (%rbx)
movq %r13, %rdx
cmovneq %r14, %rdx
movq %r12, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xc75e
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x8(%rbx)
cmpb $0x0, 0x15(%rsp)
cmovneq %r14, %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xc75e
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq