LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::TileNode::nextNode()
TileNode* nextNode()
    {
      if (!terminal) return children[0];
      
      if (level == 0) return NULL; // single node case.

      if ( parent_slot < parent->children.size()-1 )
        return parent->children[parent_slot+1];

      // last child case
      TileNode* tmp = this;
      do
      {
        tmp = tmp->parent;
      }
      while ( (tmp->level != 0) && (tmp->parent_slot ==  tmp->parent->children.size()-1) );

      if (tmp->level == 0) return NULL; // last node
      return tmp->parent->children[tmp->parent_slot+1];

    }

// Assembly:
cmpb $0x0, 0x5c(%rdi)
je 0x65ff
cmpl $0x0, (%rdi)
je 0x6607
movl 0x58(%rdi), %eax
movq 0x50(%rdi), %rcx
movq 0x60(%rcx), %rdx
movq 0x68(%rcx), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
decq %rsi
cmpq %rax, %rsi
jbe 0x660a
incl %eax
leaq (%rdx,%rax,8), %rax
jmp 0x6603
movq 0x60(%rdi), %rax
movq (%rax), %rax
retq
xorl %eax, %eax
retq
xorl %eax, %eax
cmpl $0x0, (%rcx)
je 0x6606
movl 0x58(%rcx), %edx
movq 0x50(%rcx), %rcx
movq 0x60(%rcx), %rsi
movq 0x68(%rcx), %rdi
subq %rsi, %rdi
sarq $0x3, %rdi
decq %rdi
cmpq %rdx, %rdi
je 0x660c
incl %edx
leaq (%rsi,%rdx,8), %rax
jmp 0x6603
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::calcFCodeValue(unsigned int, unsigned int)
static unsigned calcFCodeValue(unsigned bitsequence,unsigned nbits)
  {
    unsigned i_s = 0;
    for (unsigned i=0; i<nbits ;i++ )
    {
      if ( bitsequence & ( 1u<<(nbits-i-1) ) ) i_s += fibonacci(i+2);
    }
    return i_s;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x666c
movl %esi, %ebx
movl %edi, %ebp
decl %ebx
xorl %r14d, %r14d
movl $0x2, %r15d
btl %ebx, %ebp
jae 0x6662
movl %r15d, %edi
callq 0x667e
addl %eax, %r14d
incl %r15d
addl $-0x1, %ebx
jb 0x6652
jmp 0x666f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/./quasisampler_prototype.h
// Function: Quasisampler::calcDisplacementVector(unsigned int, unsigned int, int)
static Point2D calcDisplacementVector(unsigned importance, unsigned f_code, int dir)
  {
    unsigned i_s = calcStructuralIndex(f_code);
    unsigned i_v = calcImportanceIndex(importance);

    return  
      vvect[dir]        * lut[i_v][i_s][0] + // u component
      vvect[(dir+5)%20] * lut[i_v][i_s][1] ; // v component
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %edi, %r14d
movl %esi, %edi
movl $0x6, %esi
callq 0x6638
movl %eax, %ebx
movl %r14d, %eax
cvtsi2sd %rax, %xmm0
mulsd 0x3d4f(%rip), %xmm0     # 0xa440
addsd 0x3d4f(%rip), %xmm0     # 0xa448
callq 0x2150
divsd 0x3d52(%rip), %xmm0     # 0xa458
movsd %xmm0, 0x8(%rsp)
callq 0x22f0
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
mulsd 0x3d3d(%rip), %xmm1     # 0xa460
cvttsd2si %xmm1, %rax
movslq %ebp, %rcx
movl %ecx, %edx
addl $0x5, %edx
movslq %edx, %rdx
imulq $0x66666667, %rdx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x23, %rdx
addl %esi, %edx
shll $0x2, %edx
leal (%rdx,%rdx,4), %edx
negl %edx
addl %ecx, %edx
addl $0x5, %edx
shlq $0x4, %rcx
leaq 0x3e61(%rip), %rsi      # 0xa5c0
movl %eax, %eax
movl %ebx, %edi
imulq $0x150, %rax, %rax      # imm = 0x150
leaq 0x3f8f(%rip), %r8       # 0xa700
addq %rax, %r8
shlq $0x4, %rdi
movslq %edx, %rax
shlq $0x4, %rax
movsd (%rdi,%r8), %xmm1
movsd 0x8(%rdi,%r8), %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd (%rcx,%rsi), %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd (%rax,%rsi), %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::split(WDPDF_Node<int>*)
void WeightedDiscretePDF<T>::split(WDPDF_Node<T> *n)
{
	if (n->left) n->left->markBlack();
	if (n->right) n->right->markBlack();

	if (n->parent) {
		WDPDF_Node<T> *p = n->parent;

		n->markRed();

		if (p->isRed()) {
			p->parent->markRed();

				// not same direction
			if (!(	(n==p->left && p==p->parent->left) || 
					(n==p->right && p==p->parent->right))) {
			  rotate(n);
			  p = n;
			}

			rotate(p);
			p->markBlack();
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x6ebf
movb $0x0, (%rax)
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x6ecb
movb $0x0, (%rax)
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x6f1a
movb $0x1, (%r14)
cmpb $0x1, (%r15)
jne 0x6f1a
movq 0x8(%r15), %rax
movb $0x1, (%rax)
cmpq %r14, 0x10(%r15)
jne 0x6ef1
cmpq 0x10(%rax), %r15
je 0x6f0b
cmpq %r14, 0x18(%r15)
jne 0x6efd
cmpq 0x18(%rax), %r15
je 0x6f0b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f20
movq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f20
movb $0x0, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::rotate(WDPDF_Node<int>*)
void WeightedDiscretePDF<T>::rotate(WDPDF_Node<T> *n)
{
	WDPDF_Node<T> *p=n->parent, *pp=p->parent;

	n->parent = pp;
	p->parent = n;

	if (n==p->left) {
		p->left = n->right;
		n->right = p;
		if (p->left) p->left->parent = p;
	} else {
		p->right = n->left;
		n->left = p;
		if (p->right) p->right->parent = p;
	}

	n->setSum();
	p->setSum();
	
	if (!pp) {
		m_root = n;
	} else {
		if (p==pp->left) {
			pp->left = n;
		} else {
			pp->right = n;
		}
	}
}

// Assembly:
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rsi, 0x8(%rax)
cmpq %rsi, 0x10(%rax)
je 0x6f44
movq 0x10(%rsi), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%rsi)
jmp 0x6f50
movq 0x18(%rsi), %rdx
movq %rdx, 0x10(%rax)
movq %rax, 0x18(%rsi)
testq %rdx, %rdx
je 0x6f59
movq %rax, 0x8(%rdx)
movq 0x10(%rsi), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testq %rdx, %rdx
je 0x6f6d
movss 0x28(%rdx), %xmm1
movss 0x24(%rsi), %xmm2
movq 0x18(%rsi), %rdx
testq %rdx, %rdx
je 0x6f80
movss 0x28(%rdx), %xmm0
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, 0x28(%rsi)
movq 0x10(%rax), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
testq %rdx, %rdx
je 0x6fa1
movss 0x28(%rdx), %xmm1
movss 0x24(%rax), %xmm2
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x6fb4
movss 0x28(%rdx), %xmm0
addss %xmm1, %xmm2
addss %xmm0, %xmm2
movss %xmm2, 0x28(%rax)
testq %rcx, %rcx
je 0x6fd6
leaq 0x10(%rcx), %rdx
leaq 0x18(%rcx), %rdi
cmpq 0x10(%rcx), %rax
cmoveq %rdx, %rdi
movq %rsi, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/./WeightedDiscretePDF.cpp
// Function: WeightedDiscretePDF<int>::lengthen(WDPDF_Node<int>*)
void WeightedDiscretePDF<T>::lengthen(WDPDF_Node<T> *n)
{
	if (n->isRed()) {
		n->markBlack();
	} else if (n->parent) {
		WDPDF_Node<T> *sibling = n->sibling();

		if (sibling && sibling->isRed()) {
			n->parent->markRed();
			sibling->markBlack();

			rotate(sibling); // node sibling is now old sibling child, must be black
			sibling = n->sibling();
		}

		// sibling is black

		if (!sibling) {
			lengthen(n->parent);
		} else if (sibling->leftIsBlack() && sibling->rightIsBlack()) {
			if (n->parent->isBlack()) {
				sibling->markRed();
				lengthen(n->parent);
			} else {
				sibling->markRed();
				n->parent->markBlack();
			}
		} else {
			if (n==n->parent->left && sibling->rightIsBlack()) {
				rotate(sibling->left); // sibling->left must be red
				sibling->markRed();
				sibling->parent->markBlack();
				sibling = sibling->parent;
			} else if (n==n->parent->right && sibling->leftIsBlack()) {
				rotate(sibling->right); // sibling->right must be red
				sibling->markRed();
				sibling->parent->markBlack();
				sibling = sibling->parent;
			}

			// sibling is black, and sibling's far child is red

			rotate(sibling);
			if (n->parent->isRed()) sibling->markRed();
			sibling->left->markBlack();
			sibling->right->markBlack();
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x702b
movq %r14, %rax
jmp 0x7110
movq %rdi, %rbx
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7113
movq 0x10(%rax), %rcx
movq %rcx, %r15
cmpq %r14, %rcx
jne 0x704b
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x70a6
cmpb $0x1, (%r15)
jne 0x7081
movb $0x1, (%rax)
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f20
movq 0x8(%r14), %rax
movq 0x10(%rax), %rcx
movq %rcx, %r15
cmpq %r14, %rcx
jne 0x707c
movq 0x18(%rax), %r15
testq %r15, %r15
je 0x70a6
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x708f
cmpb $0x0, (%rsi)
jne 0x70b0
movq 0x18(%r15), %rdx
testq %rdx, %rdx
je 0x709d
cmpb $0x0, (%rdx)
jne 0x70b0
cmpb $0x0, (%rax)
movb $0x1, (%r15)
jne 0x7110
cmpb $0x0, (%rax)
movq %rax, %r14
je 0x702e
jmp 0x7110
cmpq %r14, %rcx
je 0x70cb
cmpq %r14, 0x18(%rax)
jne 0x70ed
testq %rsi, %rsi
je 0x70c5
cmpb $0x0, (%rsi)
jne 0x70ed
movq 0x18(%r15), %rsi
jmp 0x70d9
movq 0x18(%r15), %rcx
testq %rcx, %rcx
je 0x70d9
cmpb $0x1, (%rcx)
je 0x70b5
movq %rbx, %rdi
callq 0x6f20
movb $0x1, (%r15)
movq 0x8(%r15), %r15
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6f20
movq 0x8(%r14), %rax
cmpb $0x1, (%rax)
jne 0x7105
movb $0x1, (%r15)
movq 0x10(%r15), %rax
movb $0x0, (%rax)
movq 0x18(%r15), %rax
movb $0x0, (%rax)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/RangeList.cpp
// Function: RangeList::insertRange(int, float, float)
void RangeList::insertRange(int pos, float min, float max)
{
	if (numRanges==rangesSize) {
		RangeEntry *tmp = new RangeEntry[rangesSize];
		memcpy(tmp, ranges, numRanges*sizeof(*tmp));
		delete[] ranges;
		ranges = tmp;
	}

	if (pos<numRanges) {
		memmove(&ranges[pos+1], &ranges[pos], sizeof(*ranges)*(numRanges-pos));
	}

	ranges[pos].min = min;
	ranges[pos].max = max;
	numRanges++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %r13d
cmpl 0xc(%rdi), %r13d
jne 0x7237
movslq %r13d, %r12
shlq $0x3, %r12
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %r12, %rdi
callq 0x2030
movq %rax, %r14
movq (%rbx), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2160
testq %r15, %r15
je 0x7232
movq %r15, %rdi
callq 0x2220
movl 0x8(%rbx), %r13d
movq %r14, (%rbx)
jmp 0x723a
movq (%rbx), %r14
movl %r13d, %eax
movslq %ebp, %r15
subl %ebp, %eax
jle 0x7263
leaq (%r14,%r15,8), %rsi
leaq (%r14,%r15,8), %rdi
addq $0x8, %rdi
movslq %eax, %rdx
shlq $0x3, %rdx
callq 0x22d0
movq (%rbx), %r14
movl 0x8(%rbx), %r13d
movss (%rsp), %xmm0
movss %xmm0, (%r14,%r15,8)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%r14,%r15,8)
incl %r13d
movl %r13d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/RangeList.cpp
// Function: RangeList::print()
void RangeList::print()
{
	printf("[");
	for (int i=0; i<numRanges; i++) {
		printf("(%f,%f)%s", ranges[i].min, ranges[i].max, (i==numRanges-1)?"":", ");
	}
	printf("]\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x5b, %edi
callq 0x2240
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x754d
xorl %r15d, %r15d
leaq 0x4e23(%rip), %r12      # 0xc32a
leaq 0x505c(%rip), %r13      # 0xc56a
leaq 0x504b(%rip), %r14      # 0xc560
movq (%rbx), %rcx
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%r15,8), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rcx,%r15,8), %xmm1
decl %eax
cmpq %rax, %r15
movq %r13, %rsi
cmoveq %r12, %rsi
movq %r14, %rdi
movb $0x2, %al
callq 0x2040
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x7515
leaq 0x5019(%rip), %rdi      # 0xc56d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: ScallopedSector::ScallopedSector(Vec2&, float, float, Vec2&, float, float, Vec2&, float, float)
ScallopedSector::ScallopedSector(Vec2 &_Pt, float _a1, float _a2, Vec2 &P1, float r1, float sign1, Vec2 &P2, float r2, float sign2)
{
	Vec2 v1 = Vec2(P1.x - _Pt.x, P1.y - _Pt.y);
	Vec2 v2 = Vec2(P2.x - _Pt.x, P2.y - _Pt.y);

	P = _Pt;
	a1 = _a1;
	a2 = _a2;

	arcs[0].P = P1;
	arcs[0].r = r1;
	arcs[0].sign = sign1;
	arcs[0].d = sqrt(v1.x*v1.x + v1.y*v1.y);
	arcs[0].rSqrd = arcs[0].r*arcs[0].r;
	arcs[0].dSqrd = arcs[0].d*arcs[0].d;
	arcs[0].theta = atan2(v1.y,v1.x);
	arcs[0].integralAtStart = integralOfDistToCircle(a1 - arcs[0].theta, arcs[0].d, arcs[0].r, arcs[0].sign);

	arcs[1].P = P2;
	arcs[1].r = r2;
	arcs[1].sign = sign2;
	arcs[1].d = sqrt(v2.x*v2.x + v2.y*v2.y);
	arcs[1].rSqrd = arcs[1].r*arcs[1].r;
	arcs[1].dSqrd = arcs[1].d*arcs[1].d;
	arcs[1].theta = atan2(v2.y,v2.x);
	arcs[1].integralAtStart = integralOfDistToCircle(a1 - arcs[1].theta, arcs[1].d, arcs[1].r, arcs[1].sign);

	area = calcAreaToAngle(a2);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movss %xmm5, 0xc(%rsp)
movaps %xmm4, 0x10(%rsp)
movq %rcx, %r14
movaps %xmm1, %xmm4
movaps %xmm0, %xmm5
movq %rdi, %rbx
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm0
movss (%rsi), %xmm6
movss 0x4(%rsi), %xmm7
subss %xmm6, %xmm1
subss %xmm7, %xmm0
movss (%rcx), %xmm8
movss 0x4(%rcx), %xmm9
subss %xmm6, %xmm8
movss %xmm8, 0x8(%rsp)
subss %xmm7, %xmm9
movss %xmm9, 0x4(%rsp)
movq (%rsi), %rax
movq %rax, (%rdi)
movss %xmm5, 0x8(%rdi)
movss %xmm4, 0xc(%rdi)
movq (%rdx), %rax
movq %rax, 0x14(%rdi)
movss %xmm2, 0x1c(%rdi)
movss %xmm3, 0x20(%rdi)
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
movaps %xmm1, %xmm4
mulss %xmm1, %xmm4
addss %xmm3, %xmm4
xorps %xmm3, %xmm3
sqrtss %xmm4, %xmm3
movss %xmm3, 0x24(%rdi)
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
mulps %xmm2, %xmm2
movlps %xmm2, 0x30(%rdi)
callq 0x2230
movss %xmm0, 0x28(%rbx)
movss 0x8(%rbx), %xmm4
movss 0x1c(%rbx), %xmm2
subss %xmm0, %xmm4
movss 0x24(%rbx), %xmm1
movss 0x20(%rbx), %xmm3
movaps %xmm4, %xmm0
callq 0x76cd
movss %xmm0, 0x2c(%rbx)
movq (%r14), %rax
movq %rax, 0x38(%rbx)
movaps 0x10(%rsp), %xmm2
movss %xmm2, 0x40(%rbx)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x44(%rbx)
movss 0x4(%rsp), %xmm0
movaps %xmm0, %xmm4
mulss %xmm0, %xmm4
movss 0x8(%rsp), %xmm1
movaps %xmm1, %xmm3
mulss %xmm1, %xmm3
addss %xmm4, %xmm3
sqrtss %xmm3, %xmm3
movss %xmm3, 0x48(%rbx)
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
mulps %xmm2, %xmm2
movlps %xmm2, 0x54(%rbx)
callq 0x2230
movss %xmm0, 0x4c(%rbx)
movss 0x8(%rbx), %xmm4
movss 0x40(%rbx), %xmm2
subss %xmm0, %xmm4
movss 0x48(%rbx), %xmm1
movss 0x44(%rbx), %xmm3
movaps %xmm4, %xmm0
callq 0x76cd
movss %xmm0, 0x50(%rbx)
movss 0xc(%rbx), %xmm0
movq %rbx, %rdi
callq 0x77ae
movss %xmm0, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: integralOfDistToCircle(float, float, float, float)
static float integralOfDistToCircle(float x, float d, float r, float k)
{
	if (r<FLT_EPSILON)
		return 0.0;

	float sin_x = sin(x);
	float d_sin_x = d*sin_x;
	float y = sin_x*d/r;
	if (y<-1) y = -1;
	else if (y>1) y = 1;

	float theta = asin(y);

	return (r*(r*(x + 
				  k*theta) +
			   k*cos(theta)*d_sin_x) +
		    d*cos(x)*d_sin_x)*.5f;
}

// Assembly:
xorps %xmm5, %xmm5
movss 0x4e98(%rip), %xmm4     # 0xc570
ucomiss %xmm2, %xmm4
ja 0x77a9
subq $0x18, %rsp
movss %xmm3, 0x8(%rsp)
movss %xmm0, 0x10(%rsp)
movss %xmm2, 0x4(%rsp)
movss %xmm1, 0x14(%rsp)
callq 0x2170
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movaps %xmm0, %xmm1
divss 0x4(%rsp), %xmm1
movss 0x2d4d(%rip), %xmm0     # 0xa46c
ucomiss %xmm1, %xmm0
ja 0x7738
ucomiss 0x2d45(%rip), %xmm1     # 0xa470
movaps %xmm1, %xmm0
jbe 0x7738
movss 0x2d38(%rip), %xmm0     # 0xa470
callq 0x22b0
movss 0x8(%rsp), %xmm1
mulss %xmm0, %xmm1
addss 0x10(%rsp), %xmm1
movss %xmm1, (%rsp)
callq 0x2120
mulss 0x8(%rsp), %xmm0
mulss 0xc(%rsp), %xmm0
movss (%rsp), %xmm1
mulss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rsp)
movss 0x10(%rsp), %xmm0
callq 0x2120
movss (%rsp), %xmm5
mulss 0x14(%rsp), %xmm0
mulss 0xc(%rsp), %xmm0
mulss 0x4(%rsp), %xmm5
addss %xmm0, %xmm5
mulss 0x28b7(%rip), %xmm5     # 0xa05c
addq $0x18, %rsp
movaps %xmm5, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: ScallopedSector::calcAngleForArea(float, RNG&)
float ScallopedSector::calcAngleForArea(float area, RNG &rng)
{
	float lo = a1, hi = a2, cur = lo + (hi-lo)*rng.getFloat();

	for (int i=0; i<10; i++) {
		if (calcAreaToAngle(cur)<area) {
			lo = cur;
			cur = (cur + hi)*.5f;
		} else {
			hi = cur;
			cur = (lo + cur)*.5f;
		}
	}

	return cur;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
movss 0x8(%rdi), %xmm1
movaps %xmm1, 0x20(%rsp)
movss 0xc(%rdi), %xmm0
movss %xmm0, 0x8(%rsp)
subss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movq %rsi, %rdi
callq 0x286a
movaps 0x20(%rsp), %xmm1
movaps %xmm0, %xmm3
mulss 0x10(%rsp), %xmm3
addss %xmm1, %xmm3
movl $0xa, %ebp
movaps %xmm1, 0x20(%rsp)
movaps %xmm3, 0x10(%rsp)
movq %rbx, %rdi
movaps %xmm3, %xmm0
callq 0x77ae
movaps 0x20(%rsp), %xmm4
movaps 0x10(%rsp), %xmm3
movss 0xc(%rsp), %xmm2
ucomiss %xmm0, %xmm2
movss 0x8(%rsp), %xmm1
ja 0x7896
movss %xmm3, 0x8(%rsp)
movaps %xmm4, %xmm1
cmpltss %xmm2, %xmm0
movaps %xmm0, %xmm2
andps %xmm3, %xmm2
andnps %xmm4, %xmm0
orps %xmm2, %xmm0
addss %xmm1, %xmm3
mulss 0x27a9(%rip), %xmm3     # 0xa05c
movaps %xmm0, %xmm1
decl %ebp
jne 0x785d
movaps %xmm3, %xmm0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: ScallopedSector::distToCurve(float, int)
float ScallopedSector::distToCurve(float angle, int index)
{
	float alpha = angle - arcs[index].theta;
	float sin_alpha = sin(alpha);
	float t0 = arcs[index].rSqrd - arcs[index].dSqrd*sin_alpha*sin_alpha;
	if (t0<0) {
		return arcs[index].d*cos(alpha);
	} else {
		return arcs[index].d*cos(alpha) + arcs[index].sign*sqrt(t0);
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rax,%rax,8), %r14
subss 0x28(%rdi,%r14,4), %xmm0
movss %xmm0, 0x10(%rsp)
callq 0x2170
movss 0x24(%rbx,%r14,4), %xmm1
movss %xmm1, 0x14(%rsp)
movss 0x30(%rbx,%r14,4), %xmm2
movss 0x34(%rbx,%r14,4), %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
subss %xmm1, %xmm2
movss %xmm2, 0xc(%rsp)
movss 0x10(%rsp), %xmm0
callq 0x2120
movss 0xc(%rsp), %xmm1
movaps %xmm0, %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x793c
movss 0x14(%rsp), %xmm0
mulss %xmm2, %xmm0
jmp 0x798c
leaq (%rbx,%r14,4), %rax
addq $0x14, %rax
movss 0xc(%rax), %xmm3
ucomiss %xmm0, %xmm1
jb 0x7957
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
jmp 0x7977
movaps %xmm1, %xmm0
movss %xmm2, 0x10(%rsp)
movss %xmm3, 0xc(%rsp)
callq 0x2320
movss 0xc(%rsp), %xmm3
movss 0x10(%rsp), %xmm2
movss 0x14(%rsp), %xmm1
mulss %xmm0, %xmm3
mulss %xmm2, %xmm1
addss %xmm3, %xmm1
movaps %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: ScallopedSector::sample(RNG&)
Vec2 ScallopedSector::sample(RNG &rng)
{
	float angle = calcAngleForArea(area*rng.getFloatL(), rng);
	float d1 = distToCurve(angle, 0);
	float d2 = distToCurve(angle, 1);
	float d = sqrt(d1*d1 + (d2*d2 - d1*d1)*rng.getFloat());
	
	return Vec2(P.x + cos(angle)*d, P.y + sin(angle)*d);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movss 0x10(%rdi), %xmm0
movss %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x2838
mulss (%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7810
movss %xmm0, 0x1c(%rsp)
subss 0x28(%rbx), %xmm0
movss %xmm0, 0x20(%rsp)
callq 0x2170
movss 0x24(%rbx), %xmm1
movss %xmm1, (%rsp)
movss 0x30(%rbx), %xmm2
movss 0x34(%rbx), %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
subss %xmm1, %xmm2
movss %xmm2, 0x30(%rsp)
movss 0x20(%rsp), %xmm0
callq 0x2120
movss 0x30(%rsp), %xmm1
movaps %xmm0, %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7a2b
movss (%rsp), %xmm0
mulss %xmm2, %xmm0
movss %xmm0, (%rsp)
jmp 0x7a74
movss 0x20(%rbx), %xmm3
ucomiss %xmm0, %xmm1
jb 0x7a3e
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
jmp 0x7a5e
movaps %xmm1, %xmm0
movss %xmm2, 0x20(%rsp)
movss %xmm3, 0x30(%rsp)
callq 0x2320
movss 0x30(%rsp), %xmm3
movss 0x20(%rsp), %xmm2
movss (%rsp), %xmm1
mulss %xmm0, %xmm3
mulss %xmm2, %xmm1
addss %xmm3, %xmm1
movss %xmm1, (%rsp)
movss 0x1c(%rsp), %xmm0
subss 0x4c(%rbx), %xmm0
movss %xmm0, 0x30(%rsp)
callq 0x2170
movss 0x48(%rbx), %xmm1
movss %xmm1, 0x20(%rsp)
movss 0x54(%rbx), %xmm2
movss 0x58(%rbx), %xmm1
mulss %xmm0, %xmm1
mulss %xmm0, %xmm1
subss %xmm1, %xmm2
movss %xmm2, 0x40(%rsp)
movss 0x30(%rsp), %xmm0
callq 0x2120
movss 0x40(%rsp), %xmm1
movaps %xmm0, %xmm2
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7ade
movss 0x20(%rsp), %xmm0
mulss %xmm2, %xmm0
movss (%rsp), %xmm1
jmp 0x7b28
movss 0x44(%rbx), %xmm3
ucomiss %xmm0, %xmm1
jb 0x7af1
xorps %xmm0, %xmm0
sqrtss %xmm1, %xmm0
jmp 0x7b11
movaps %xmm1, %xmm0
movss %xmm2, 0x30(%rsp)
movss %xmm3, 0x40(%rsp)
callq 0x2320
movss 0x40(%rsp), %xmm3
movss 0x30(%rsp), %xmm2
movss (%rsp), %xmm1
mulss %xmm0, %xmm3
movss 0x20(%rsp), %xmm0
mulss %xmm2, %xmm0
addss %xmm3, %xmm0
mulss %xmm0, %xmm0
mulss %xmm1, %xmm1
movss %xmm1, (%rsp)
subss %xmm1, %xmm0
movss %xmm0, 0x20(%rsp)
movq %r14, %rdi
callq 0x286a
mulss 0x20(%rsp), %xmm0
addss (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x7b60
sqrtss %xmm0, %xmm0
jmp 0x7b65
callq 0x2320
movaps %xmm0, (%rsp)
movups (%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movss 0x1c(%rsp), %xmm0
callq 0x2120
movaps %xmm0, 0x40(%rsp)
movss 0x4(%rbx), %xmm0
movaps %xmm0, 0x30(%rsp)
movss 0x1c(%rsp), %xmm0
callq 0x2170
movaps 0x40(%rsp), %xmm1
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movaps (%rsp), %xmm2
shufps $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
mulps %xmm1, %xmm2
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm0
movlhps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm0     # xmm0 = xmm0[2,0],xmm1[2,3]
addps %xmm2, %xmm0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: ScallopedSector::distToCircle(float, Vec2&, float, float*, float*)
void ScallopedSector::distToCircle(float angle, Vec2 &C, float r, float *d1_out, float *d2_out)
{
	Vec2 v(C.x - P.x, C.y - P.y);
	float dSqrd = v.x*v.x + v.y*v.y;
	float theta = atan2(v.y, v.x);
	float alpha = angle - theta;
	float sin_alpha = sin(alpha);
	float xSqrd = r*r - dSqrd*sin_alpha*sin_alpha;

	if (xSqrd<0) {
		*d1_out = *d2_out = -10000000;
	} else {
		float a = sqrt(dSqrd)*cos(alpha);
		float x = sqrt(xSqrd);
		*d1_out = a-x;
		*d2_out = a+x;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movss (%rsi), %xmm1
subss (%rdi), %xmm1
movss 0x4(%rsi), %xmm0
subss 0x4(%rdi), %xmm0
movaps %xmm0, %xmm2
mulss %xmm0, %xmm2
movaps %xmm1, %xmm3
mulss %xmm1, %xmm3
addss %xmm2, %xmm3
movss %xmm3, 0x10(%rsp)
callq 0x2230
movss 0x14(%rsp), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movaps %xmm1, %xmm0
callq 0x2170
movss 0x10(%rsp), %xmm2
movaps %xmm0, %xmm1
mulss %xmm2, %xmm1
mulss %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
mulss %xmm0, %xmm0
subss %xmm1, %xmm0
xorps %xmm1, %xmm1
movss %xmm0, 0xc(%rsp)
ucomiss %xmm0, %xmm1
jbe 0x7c9f
movl $0xcb189680, %eax       # imm = 0xCB189680
movl %eax, (%rbx)
movl %eax, (%r14)
jmp 0x7d05
xorps %xmm0, %xmm0
sqrtss %xmm2, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x14(%rsp), %xmm0
callq 0x2120
movaps %xmm0, %xmm2
mulss 0x10(%rsp), %xmm2
movss 0xc(%rsp), %xmm0
ucomiss 0x48a7(%rip), %xmm0     # 0xc574
jb 0x7cda
xorps %xmm0, %xmm0
sqrtss 0xc(%rsp), %xmm0
jmp 0x7cf1
movss 0xc(%rsp), %xmm0
movss %xmm2, 0xc(%rsp)
callq 0x2320
movss 0xc(%rsp), %xmm2
movaps %xmm2, %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%r14)
addss %xmm0, %xmm2
movss %xmm2, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ddunbar[P]PDSample/ScallopedSector.cpp
// Function: ScallopedRegion::sample(RNG&)
Vec2 ScallopedRegion::sample(RNG &rng)
{
	if (!regions->size()) {
		printf("Fatal error, sampled from empty region.");
		exit(1);
		return Vec2(0,0); 
	} else {
		float a = area*rng.getFloatL();
		ScallopedSector &ss = (*regions)[0];

		for (unsigned int i=0; i<regions->size(); i++) {
			ss = (*regions)[i];
			if (a<ss.area)
				break;
			a -= ss.area;
		}

		return ss.sample(rng);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
je 0x8cea
movq %rsi, %rbx
movq %rdi, %r14
movss 0xc(%rdi), %xmm0
movss %xmm0, 0x4(%rsp)
movq %rsi, %rdi
callq 0x2838
movss 0x4(%rsp), %xmm1
movq (%r14), %rcx
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0x8cd8
mulss %xmm0, %xmm1
movl $0x1, %edx
xorl %ecx, %ecx
movabsq $-0x2c8590b21642c859, %r8 # imm = 0xD37A6F4DE9BD37A7
movq %rax, %rdi
imulq $0x5c, %rcx, %rsi
addq %rdi, %rsi
movl $0x17, %ecx
movq %rax, %rdi
rep  movsl (%rsi), %es:(%rdi)
movss 0x10(%rax), %xmm0
ucomiss %xmm1, %xmm0
ja 0x8cd8
subss %xmm0, %xmm1
movl %edx, %ecx
movq (%r14), %rsi
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
subq %rdi, %rsi
sarq $0x2, %rsi
imulq %r8, %rsi
incl %edx
cmpq %rcx, %rsi
ja 0x8c9b
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7994
leaq 0x38af(%rip), %rdi      # 0xc5a0
xorl %eax, %eax
callq 0x2040
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/Helpers/fraction.cpp
// Function: Fraction::Normalize()
Fraction Fraction::Normalize()
{
    int d = gcd(numerator, denominator);
    numerator /= d;
    denominator /= d;
    if(denominator < 0)
    {
        numerator *= -1;
        denominator *= -1;
    }
    return *this;
}

// Assembly:
movl (%rdi), %esi
movl 0x4(%rdi), %ecx
movl %esi, %r8d
testl %ecx, %ecx
je 0x23be
movl %ecx, %edx
movl %esi, %eax
movl %edx, %r8d
cltd
idivl %r8d
movl %r8d, %eax
testl %edx, %edx
jne 0x23b0
movl %esi, %eax
cltd
idivl %r8d
movl %eax, %esi
movl %eax, (%rdi)
movl %ecx, %eax
cltd
idivl %r8d
movl %eax, 0x4(%rdi)
testl %eax, %eax
jns 0x23de
negl %esi
movl %esi, (%rdi)
negl %eax
movl %eax, 0x4(%rdi)
movq (%rdi), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/sacredGeometry.cpp
// Function: GetHigherBound(int*, int)
int GetHigherBound(int * values, int size)
{
    int res = 1;
    int ones = 0;
    int twos = 0;
    for(int i = 0; i < size; ++i)
    {
        if(values[i] == 1)
        {
            ++ones;
        }
        else if(values[i] == 2)
        {
            ++twos;
        }
        else
        {
            res *= values[i];
        }
        if(res > PRIMECONSTANTS[(sizeof(PRIMECONSTANTS)/sizeof(*PRIMECONSTANTS))-1][0])
        {
            return res;
        }
    }
    if(ones > twos)
    {
        res *= pow(3, twos+(ones-twos)/3)*2;
    }
    else
    {
        res *= pow(3, ones);
        res *= pow(2, twos-ones);
    }
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x2aa3
movl %esi, %ecx
movl $0x1, %eax
xorl %edx, %edx
xorl %ebx, %ebx
xorl %ebp, %ebp
movl (%rdi,%rdx,4), %esi
cmpl $0x2, %esi
je 0x2a48
cmpl $0x1, %esi
jne 0x2a4c
incl %ebp
jmp 0x2a58
incl %ebx
jmp 0x2a58
imull %esi, %eax
cmpl $0x65, %eax
jg 0x2af5
incq %rdx
cmpq %rdx, %rcx
jne 0x2a37
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movl %ebp, %eax
subl %ebx, %eax
jle 0x2ab4
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
addl %ebx, %eax
cvtsi2sd %eax, %xmm1
movsd 0x2655(%rip), %xmm0     # 0x50e8
callq 0x2210
addsd %xmm0, %xmm0
mulsd (%rsp), %xmm0
jmp 0x2af1
movsd 0x2635(%rip), %xmm0     # 0x50e0
movsd %xmm0, (%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
cvtsi2sd %ebp, %xmm1
movsd 0x2628(%rip), %xmm0     # 0x50e8
callq 0x2210
mulsd (%rsp), %xmm0
movapd %xmm0, (%rsp)
subl %ebp, %ebx
movsd 0x2607(%rip), %xmm0     # 0x50e0
movl %ebx, %edi
callq 0x21b0
cvttpd2dq (%rsp), %xmm2
movapd %xmm0, %xmm1
cvtdq2pd %xmm2, %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/sacredGeometry.cpp
// Function: GetDesiredExpression[abi:cxx11](int, int*, int)
string GetDesiredExpression(int spellLevel, int rolledDices[], int size)
{
    if(GetHigherBound(rolledDices, size) < PRIMECONSTANTS[spellLevel-1][0])
    {
         return "";
    }
    ExprAndValue * exprs = new ExprAndValue[size];
    for(int i = 0; i < size; ++i)
    {
        exprs[i] = ExprAndValue(Fraction(rolledDices[i]), i);
    }
    return CombineExpressions(spellLevel, exprs, size, size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movq %rdx, %rdi
movl %ecx, %esi
callq 0x2a20
leal -0x1(%r14), %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x197b(%rip), %rdx      # 0x50f0
cmpl (%rdx,%rcx,4), %eax
jge 0x3798
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b13(%rip), %rdx      # 0x529b
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3c3e
jmp 0x38ca
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movslq %ebp, %r14
movq %r14, %rbx
shlq $0x6, %rbx
leaq 0x8(%rbx), %rax
testl %ebp, %ebp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %r13
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq %r14, (%r13)
movl %ebp, 0xc(%rsp)
testl %ebp, %ebp
je 0x38ac
leaq 0x20(%r13), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x40, %rax
addq $-0x40, %rbx
jne 0x37e2
cmpl $0x0, 0xc(%rsp)
jle 0x38ac
leaq 0x40(%rsp), %r12
movl 0xc(%rsp), %ebp
addq $0x30, %r13
xorl %r14d, %r14d
leaq 0x30(%rsp), %rbx
movl (%r15,%r14,4), %esi
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x2396
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x23e2
movw $0x101, 0x60(%rsp)      # imm = 0x101
movd %r14d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu %xmm0, 0x64(%rsp)
movq 0x38(%rsp), %rax
movq %rax, -0x28(%r13)
leaq -0x20(%r13), %rdi
movq %r12, %rsi
callq 0x2190
movl 0x30(%r12), %eax
movl %eax, 0x10(%r13)
movups 0x20(%r12), %xmm0
movups %xmm0, (%r13)
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x389c
callq 0x2120
incq %r14
addq $0x40, %r13
cmpq %r14, %rbp
jne 0x381b
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
movl %ecx, %r8d
callq 0x2afc
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pokorj54[P]Pathfinder-utilities/src/SGsearch.cpp
// Function: SGCategory::Print() const
void SGCategory::Print() const
{
    int64_t possibleVariations = pow(maxDiceValue, noDices);
    int64_t possibleLimitedVariations = pow(limitedDiceValue, noDices);
    cout << setprecision(5)  << "NoD: " << noDices << ", SL: " << spellLevel<< " = PC: "
        << possibleVariations << ", SC: " << successfulVariations << ", PLC: " << possibleLimitedVariations 
        << ", SLC: " << successfulLimitedVariations << " -> Rate: "
        << (double)successfulVariations/possibleVariations << "(" << (double)successfulLimitedVariations/possibleLimitedVariations 
        << ")" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sdl (%rdi), %xmm0
mulsd 0x116d(%rip), %xmm0     # 0x50e8
callq 0x2100
cvttsd2si %xmm0, %r15
cvtsi2sdl (%rbx), %xmm1
movsd 0x122f(%rip), %xmm0     # 0x51c0
callq 0x2210
cvttsd2si %xmm0, %r14
movq 0x3036(%rip), %r12      # 0x6fd8
movq (%r12), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x8(%r12,%rax)
leaq 0x12be(%rip), %rsi      # 0x5278
movl $0x5, %edx
movq %r12, %rdi
callq 0x2170
movl (%rbx), %esi
movq %r12, %rdi
callq 0x2200
movq %rax, %r12
leaq 0x12a3(%rip), %rsi      # 0x527e
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movl 0x4(%rbx), %esi
movq %r12, %rdi
callq 0x2200
movq %rax, %r12
leaq 0x1288(%rip), %rsi      # 0x5285
movl $0x7, %edx
movq %rax, %rdi
callq 0x2170
movq %r12, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, %r12
leaq 0x126e(%rip), %rsi      # 0x528d
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
leaq 0x1252(%rip), %rsi      # 0x5294
movl $0x7, %edx
movq %rax, %rdi
callq 0x2170
movq %r12, %rdi
movq %r14, %rsi
callq 0x2130
movq %rax, %r12
leaq 0x1238(%rip), %rsi      # 0x529c
movl $0x7, %edx
movq %rax, %rdi
callq 0x2170
movq 0x18(%rbx), %rsi
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
leaq 0x121d(%rip), %rsi      # 0x52a4
movl $0xa, %edx
movq %rax, %rdi
callq 0x2170
xorps %xmm0, %xmm0
cvtsi2sdq 0x10(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r15, %xmm1
divsd %xmm1, %xmm0
movq %r12, %rdi
callq 0x21e0
movq %rax, %r15
leaq 0x10a7(%rip), %rsi      # 0x5162
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
xorps %xmm0, %xmm0
cvtsi2sdq 0x18(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
movq %r15, %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0x1075(%rip), %rsi      # 0x5164
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O3/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc1.cc
// Function: Interpreter::expression()
long Interpreter::expression() {

    // set current token to the first token taken from the input
    _current_token = get_next_token();

    // we expect the current token to be an integer
    Token left = _current_token;
    eat(TOKENTYPE::INTEGER);

    // we expect the current token to be a '+' or '-' token
    Token op = _current_token;
    if (op.type == TOKENTYPE::PLUS) {
        eat(TOKENTYPE::PLUS);
        return plus(left.value);
    }

    if (op.type == TOKENTYPE::MINUS) {
        eat(TOKENTYPE::MINUS);
        return minus(left.value);
    }

    return 0L; // An exception should have been thrown before we ever get here.
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2472
movq %rdx, %r14
movl %eax, 0x10(%rbx)
movq %rdx, 0x18(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2734
movl 0x10(%rbx), %eax
cmpl $0x3, %eax
je 0x2440
cmpl $0x2, %eax
jne 0x2466
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2734
movq 0x18(%rbx), %r15
addq %r14, %r15
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2734
jmp 0x2469
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2734
movq 0x18(%rbx), %rax
subq %rax, %r14
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2734
movq %r14, %r15
jmp 0x2469
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/ordhuff_x.c
// Function: main
int
main (int argc, char **argv)
{
    unsigned        freq[MAXTEST], code[MAXTEST], bits[MAXTEST];
    char            zcode[33];
    int             i, ncodes;

    if (argc != 2)
        return fputs ("Usage: ordhuff_x (freqfile | -)\n", stderr);

    FILE           *finp =
        strcmp (argv[1], "-") ? fopen (argv[1], "r") : stdin;

    if (!finp)
        return 1;

    for (ncodes = 0; 
         ncodes < MAXTEST && fscanf (finp, "%ud", &freq[ncodes]) == 1; 
        ++ncodes);

    ordhuff(ncodes, freq, code, bits);

    unsigned        raw = 0, pkd = 0;

    for (i = 0; i < ncodes; ++i) {
        prbits(zcode, (int) code[i], (int) bits[i]);
        printf ("%4d %8d %s\n", i, freq[i], zcode);
        raw += freq[i];
        pkd += freq[i] * strlen (zcode);
    }

    fprintf (stderr, "Exprevbits: %4.2f\n", (float) pkd / raw);
    return 0;
}

// Assembly:
cmpl $0x2, %edi
jne 0x1398
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f18, %rsp           # imm = 0x2F18
movq 0x8(%rsi), %rdi
cmpb $0x2d, (%rdi)
jne 0x1361
cmpb $0x0, 0x1(%rdi)
je 0x138c
leaq 0x2101(%rip), %rsi      # 0x3469
callq 0x10e0
movq %rax, %r14
movl $0x1, %eax
testq %r14, %r14
jne 0x13ae
addq $0x2f18, %rsp           # imm = 0x2F18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3c45(%rip), %rax      # 0x4fd8
movq (%rax), %r14
jmp 0x1370
movq 0x3c41(%rip), %rax      # 0x4fe0
movq (%rax), %rsi
leaq 0x1c67(%rip), %rdi      # 0x3010
jmp 0x10d0
leaq 0x30(%rsp), %r15
leaq 0x1c77(%rip), %r12      # 0x3031
xorl %ebx, %ebx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1190
cmpl $0x1, %eax
jne 0x1407
incq %rbx
addq $0x4, %r15
cmpq $0x3e8, %rbx            # imm = 0x3E8
jne 0x13bc
leaq 0x30(%rsp), %rsi
leaq 0x1f70(%rsp), %rdx
leaq 0xfd0(%rsp), %rcx
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x14e4
movl $0x3e8, %ebx            # imm = 0x3E8
jmp 0x1435
leaq 0x30(%rsp), %rsi
leaq 0x1f70(%rsp), %rdx
leaq 0xfd0(%rsp), %rcx
movl %ebx, %edi
callq 0x14e4
testq %rbx, %rbx
jne 0x1435
movsd 0x1bd8(%rip), %xmm0     # 0x3008
jmp 0x14c3
movl %ebx, %r12d
movq %rsp, %r14
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %ebp, %ebp
movl 0x1f70(%rsp,%r15,4), %eax
movslq 0xfd0(%rsp,%r15,4), %rcx
movb $0x0, (%rsp,%rcx)
testq %rcx, %rcx
jle 0x1476
incq %rcx
movl %eax, %edx
andb $0x1, %dl
orb $0x30, %dl
movb %dl, -0x2(%rsp,%rcx)
sarl %eax
decq %rcx
cmpq $0x1, %rcx
ja 0x145f
movl 0x30(%rsp,%r15,4), %edx
leaq 0x1bb3(%rip), %rdi      # 0x3035
movl %r15d, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x1030
movl 0x30(%rsp,%r15,4), %ebx
addl %ebx, %ebp
movq %r14, %rdi
callq 0x1060
imull %ebx, %eax
addl %eax, %r13d
incq %r15
cmpq %r12, %r15
jne 0x1443
movl %r13d, %eax
cvtsi2ss %rax, %xmm0
movl %ebp, %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x3b16(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
leaq 0x1b6d(%rip), %rsi      # 0x3041
movb $0x1, %al
callq 0x1170
xorl %eax, %eax
jmp 0x137a
nop
// File: /workspace/github_cpp_makefile_star2_O3/maramire[P]SP_PSO/parallel_main.cpp
// Function: showPermutation(std::vector<int, std::allocator<int>>)
void showPermutation(vector<int> permutation)
{
    for (int i=0; i<permutation.size(); i++){
        cout << permutation[i];
        cout << ", ";
    }
    cout <<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x2afc
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x7515(%rip), %r14      # 0x9fd8
leaq 0x45a6(%rip), %r15      # 0x7070
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x22e0
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x2aca
movq 0x74d5(%rip), %rbx      # 0x9fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/maramire[P]SP_PSO/parallel_main.cpp
// Function: showRectangles(std::vector<Item, std::allocator<Item>>)
void showRectangles(Item_vector items)
{
    /* Print all rectangles and its information */
    cout << "-> Printing rectangles of instance and its information!"<<endl;
    cout << "-------------------------------------------------------"<<endl;
    cout << "AreaID, X,      Y,     Width,  Height,  Rotated?"<<endl;
    
    for (int i = 0; i < items.size(); i++)
    {
        cout << items[i].id << "	" << items[i].x_position;
        cout << "	" << items[i].y_position << "	";
        cout << items[i].width << "	" << items[i].height << "	"; 
        cout << items[i].rotated <<endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x711f(%rip), %r14      # 0x9fd8
leaq 0x41b3(%rip), %rsi      # 0x7073
movl $0x37, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x41b0(%rip), %rsi      # 0x70ab
movl $0x37, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x41ad(%rip), %rsi      # 0x70e3
movl $0x30, %edx
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x30a1
xorl %r13d, %r13d
xorl %r14d, %r14d
movl (%rax,%r13), %esi
movq 0x7050(%rip), %rdi      # 0x9fd8
callq 0x22e0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %r15
leaq 0x4172(%rip), %rbx      # 0x7114
movq %rbx, %rsi
callq 0x21e0
movq (%r15), %rax
movl 0x10(%rax,%r13), %esi
movq %r12, %rdi
callq 0x22e0
movl $0x1, %edx
movq 0x7012(%rip), %r12      # 0x9fd8
movq %r12, %rdi
movq %rbx, %rsi
callq 0x21e0
movq (%r15), %rax
movl 0x14(%rax,%r13), %esi
movq %r12, %rdi
callq 0x22e0
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
movq (%r15), %rax
movl 0x8(%rax,%r13), %esi
movq %r12, %rdi
callq 0x22e0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
movq (%r15), %rax
movl 0x4(%rax,%r13), %esi
movq %r12, %rdi
callq 0x22e0
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rbx
callq 0x21e0
movq (%r15), %rax
movl 0x18(%rax,%r13), %esi
movq 0x6f92(%rip), %rdi      # 0x9fd8
callq 0x22e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
incq %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rcx
addq $0x1c, %r13
cmpq %r14, %rcx
ja 0x2f7d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Config.cpp
// Function: Config::Config(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Config::Config(string configFile) {
	swarm_ = 0;
	verbose=false; //razi added
	configPath_ = convertToAbsPath(configFile);
	//cout << "*** configFile: " << configPath_ << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r15
movq %r15, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
movq %rax, 0x8(%rdi)
movb %al, (%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3213c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xbdb20
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22bb0
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x28f2c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x28f43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x28f6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x229c0
jmp 0x28f6e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x28f81
movq (%r15), %rsi
incq %rsi
callq 0x229c0
movq %r14, %rdi
callq 0x23240
nop
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::getColumnAverages()
void Data::getColumnAverages() {
	double sum;
	int counter;
	for(map<string,map<double,double> >::iterator c = dataCurrent->begin(); c != dataCurrent->end(); ++c) {
		//cout << "gca col loop" << endl;

		sum = 0;
		counter = 0;

		for(map<double,double>::iterator v = c->second.begin(); v != c->second.end(); ++v) {
			//cout << "gca tp loop" << endl;
			if (std::isnan(v->second)) {
				continue;
			}

			sum += v->second;
			counter++;
		}
		colAverages.insert(pair<string,double>(c->first,sum/counter));
	}



}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
movq 0x18(%rax), %r14
addq $0x8, %rax
cmpq %rax, %r14
je 0x49739
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %r15
leaq 0x10(%rsp), %r12
movq 0x58(%r14), %rax
leaq 0x48(%r14), %rbp
movsd 0xad464(%rip), %xmm0    # 0xf6ae0
cmpq %rbp, %rax
je 0x496d2
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd 0x28(%rax), %xmm0
xorl %ecx, %ecx
ucomisd %xmm0, %xmm0
setnp %dl
jp 0x496ab
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movb %dl, %cl
addl %ecx, %r13d
movq %rax, %rdi
callq 0x22670
cmpq %rbp, %rax
jne 0x4968d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq %r15, 0x10(%rsp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3213c
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4d068
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x4971e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %r14, %rdi
callq 0x22670
movq %rax, %r14
movq (%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r14
jne 0x4966c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x49762
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
// File: /workspace/github_cpp_makefile_star2_O3/richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::divideByInit()
void Data::divideByInit() {
	for(map<string,map<double,double> >::iterator c = dataCurrent->begin(); c != dataCurrent->end(); ++c) {
		for(map<double,double>::iterator v = c->second.begin(); v != c->second.end(); ++v) {
			if (v->second == 0) {
				swarm_->outputError("You chose to divide_by_init, but the first value in the column '" + c->first + "' is 0. We cannot divide by 0.");
			}
			if (std::isnan(v->second)) {
				dataDividedByInit_[c->first][v->first] = nan("1");
				continue;
			}
			dataDividedByInit_[c->first][v->first] = v->second / c->second.begin()->first;
			//cout << "dividing t=" << v->first << " of " << v->second << "by " << c->first << " init of " << c->second.begin()->first << endl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, (%rsp)
movq (%rdi), %rbx
movq 0x18(%rbx), %r14
leaq 0x8(%rbx), %rax
cmpq %rax, %r14
je 0x4990e
movq (%rsp), %rax
addq $0x120, %rax            # imm = 0x120
movq %rax, 0x30(%rsp)
movq 0x58(%r14), %rbp
leaq 0x48(%r14), %r13
cmpq %r13, %rbp
je 0x498f6
leaq 0x20(%r14), %r12
movsd 0x28(%rbp), %xmm0
ucomisd 0xad327(%rip), %xmm0    # 0xf6ae8
jne 0x49890
jp 0x49890
movq (%rsp), %rax
movq 0x150(%rax), %rbx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
leaq 0xad5a4(%rip), %rsi     # 0xf6d8b
movq %r12, %rdx
callq 0x31944
movq %r15, %rdi
leaq 0xad5d3(%rip), %rsi     # 0xf6dcc
callq 0x233b0
leaq 0x20(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x49826
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x4982e
movupd (%rcx), %xmm0
movupd %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x784c2
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4986f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x4988b
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x229c0
movsd 0x28(%rbp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x498e1
movq 0x58(%r14), %rax
divsd 0x20(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rbp), %rbx
movq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x4a1ce
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4a332
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbp, %rdi
callq 0x22670
movq %rax, %rbp
cmpq %r13, %rax
jne 0x497b4
jmp 0x498ef
leaq 0xaf2f4(%rip), %rdi     # 0xf8bdc
callq 0x22130
jmp 0x4989f
movq (%rsp), %rax
movq (%rax), %rbx
movq %r14, %rdi
callq 0x22670
movq %rax, %r14
leaq 0x8(%rbx), %rax
cmpq %rax, %r14
jne 0x4979f
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x49941
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x49941
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x229c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x4995d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x229c0
movq %rbx, %rdi
callq 0x23240
nop