LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2e34
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2dd4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2e09
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpl $0x2, (%rax,%rcx,4)
jne 0x2df1
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2e07
movq 0x18(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %eax
imull 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2e09
movl 0x10(%rsp), %eax
cmpl 0x333d(%rip), %eax      # 0x6150
jle 0x2e22
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2ed3
jmp 0x2e24
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2dad
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jle 0x2e81
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %eax
subl 0x8(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x3, %edi
callq 0x4200
movaps %xmm0, %xmm1
movsd 0x3277(%rip), %xmm0     # 0x60e0
mulsd %xmm0, %xmm1
cvtsi2sdl 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x10(%rsp)
jmp 0x2ecb
movl 0xc(%rsp), %esi
movl $0x3, %edi
callq 0x4200
movaps %xmm0, %xmm1
cvtsi2sdl 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x10(%rsp)
movl 0x8(%rsp), %esi
subl 0xc(%rsp), %esi
movl $0x2, %edi
callq 0x4200
movaps %xmm0, %xmm1
cvtsi2sdl 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movq 0xb0(%rsp), %rdi
movl 0xac(%rsp), %esi
callq 0x2d80
movl 0xbc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x20e6(%rip), %rcx      # 0x60f0
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jge 0x4077
leaq 0xab(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2280
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x2203(%rip), %rsi      # 0x623b
callq 0x21d0
jmp 0x403f
leaq 0xab(%rsp), %rdi
callq 0x21a0
jmp 0x41e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xab(%rsp), %rdi
callq 0x21a0
jmp 0x41ee
movslq 0xac(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x40, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x20(%rsp)
cmpq $0x0, %rax
je 0x410b
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdx
shlq $0x6, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x45d0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x40, %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x40e6
movq 0x20(%rsp), %rax
movq %rax, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
cmpl 0xac(%rsp), %eax
jge 0x41b9
movq 0xb0(%rsp), %rax
movslq 0x8c(%rsp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0x40(%rsp), %rdi
movl $0x1, %edx
callq 0x2460
movl 0x8c(%rsp), %edx
movq 0x40(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x45f0
movq 0x90(%rsp), %rdi
movslq 0x8c(%rsp), %rax
shlq $0x6, %rax
addq %rax, %rdi
leaq 0x48(%rsp), %rsi
callq 0x4520
leaq 0x48(%rsp), %rdi
callq 0x4580
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x4123
movq 0x30(%rsp), %rdi
movl 0xbc(%rsp), %esi
movq 0x90(%rsp), %rdx
movl 0xac(%rsp), %ecx
movl 0xac(%rsp), %r8d
callq 0x2ee0
movq 0x38(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl (%rax), %esi
movl $0x8, %edi
callq 0x4200
movq (%rsp), %rax
cvttsd2si %xmm0, %rcx
movq %rcx, 0x18(%rsp)
movl (%rax), %esi
movl $0x6, %edi
callq 0x4200
cvttsd2si %xmm0, %rax
movq %rax, 0x10(%rsp)
movl $0x5, %edi
callq 0x52a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %esi
movq 0x43ed(%rip), %rdi      # 0x8fd8
callq 0x2210
movq %rax, %rdi
leaq 0x161e(%rip), %rsi      # 0x6218
callq 0x2170
movq %rax, %rdi
movq (%rsp), %rax
movl (%rax), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x1607(%rip), %rsi      # 0x621e
callq 0x2170
movq %rax, %rdi
movq (%rsp), %rax
movl 0x4(%rax), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x15f0(%rip), %rsi      # 0x6225
callq 0x2170
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x2290
movq %rax, %rdi
leaq 0x15dc(%rip), %rsi      # 0x622d
callq 0x2170
movq %rax, %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2290
movq %rax, %rdi
leaq 0x15c4(%rip), %rsi      # 0x6234
callq 0x2170
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2290
movq %rax, %rdi
leaq 0x15b0(%rip), %rsi      # 0x623c
callq 0x2170
movq %rax, %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2290
movq %rax, %rdi
leaq 0x1599(%rip), %rsi      # 0x6244
callq 0x2170
movq %rax, %rdi
movq (%rsp), %rax
cvtsi2sdq 0x10(%rax), %xmm0
cvtsi2sdq 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x22a0
movq %rax, %rdi
leaq 0x148b(%rip), %rsi      # 0x6162
callq 0x2170
movq %rax, %rdi
movq (%rsp), %rax
cvtsi2sdq 0x18(%rax), %xmm0
cvtsi2sdq 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x22a0
movq %rax, %rdi
leaq 0x1461(%rip), %rsi      # 0x6164
callq 0x2170
movq %rax, %rdi
movq 0x42ae(%rip), %rsi      # 0x8fc0
callq 0x2190
addq $0x28, %rsp
retq
nopl (%rax)
// File: akw0088[P]openssl/aes_enc.cpp
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("Usage:\taes_enc 256bit_key 128bit_iv plaintext\r\n");
		printf("Example:\taes_enc 01234567890123456789012345678901 0123456789012345 HelloWorld!\r\n");
		return -1;
	}

	/* A 256 bit key */
	unsigned char *key = (unsigned char *)argv[1];

	/* A 128 bit IV */
	unsigned char *iv = (unsigned char *)argv[2];

	/* Message to be encrypted */
	unsigned char *plaintext = (unsigned char *)argv[3];

	/*
	 * Buffer for ciphertext. Ensure the buffer is long enough for the
	 * ciphertext which may be longer than the plaintext, depending on the
	 * algorithm and mode.
	 */
	unsigned char *ciphertext = (unsigned char *)malloc(strlen((char *)plaintext) * 2);
	if (ciphertext == NULL)
	{
		perror("malloc failed");
		return -1;
	}


	int ciphertext_len;

	/* Encrypt the plaintext */
	ciphertext_len = encrypt (plaintext, strlen ((char *)plaintext), key, iv, ciphertext);

	/* Do something useful with the ciphertext here */
	printf("Ciphertext is:\n");
	BIO_dump_fp (stdout, (const char *)ciphertext, ciphertext_len);

	write_file((char *)"file.enc", (char *)ciphertext, ciphertext_len);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x1494
leaq 0xbd4(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1050
leaq 0xbf6(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1555
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1090
movq %rax, %rdi
shlq %rdi
callq 0x1170
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x14ec
leaq 0xbea(%rip), %rdi       # 0x20c8
callq 0x1110
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1555
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1090
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x1560
movl %eax, -0x34(%rbp)
leaq 0xbb8(%rip), %rdi       # 0x20d6
movb $0x0, %al
callq 0x1050
movq 0x2a9c(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x10d0
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
leaq 0xb9d(%rip), %rdi       # 0x20e6
callq 0x13b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2570
movq -0x48(%rbp), %rdi
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rdi), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %esi
callq 0x2900
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x40(%rbp)
jne 0x2529
movq -0x48(%rbp), %rdi
movl $0x2, %esi
callq 0x2900
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2a80
movq %rax, -0x8(%rbp)
jmp 0x2558
cmpl $0x3, -0x40(%rbp)
jne 0x2550
movq -0x48(%rbp), %rdi
movl $0x3, %esi
callq 0x2900
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2ac0
movq %rax, -0x8(%rbp)
jmp 0x2558
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc1.cc
// Function: Interpreter::minus(long)
long Interpreter::minus(long left_value) {
    // we expect the current token to be an integer
    Token right = _current_token;
    eat(TOKENTYPE::INTEGER);
    // after the above call _current_token is set to ENDOFFILE token

    // at this point INTEGER MINUS INTEGER sequence of tokens has been
    // successfully found and the method can just return the result of
    // subtracting two integers, thus effectively interpreting client input
    return left_value - right.value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rdi), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
callq 0x2900
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x55e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d2d
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5600
movl (%rax), %esi
movq 0x152ce(%rip), %rdi     # 0x17fd8
callq 0x2370
movq 0x152c2(%rip), %rdi     # 0x17fd8
leaq 0xd353(%rip), %rsi      # 0x10070
callq 0x21c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cd7
movq 0x152a4(%rip), %rdi     # 0x17fd8
movq 0x1528d(%rip), %rsi     # 0x17fc8
callq 0x2200
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x14be1(%rip), %rdi     # 0x17fd8
leaq 0xcc75(%rip), %rsi      # 0x10073
callq 0x21c0
movq %rax, %rdi
movq 0x14bbb(%rip), %rsi     # 0x17fc8
callq 0x2200
movq 0x14bbf(%rip), %rdi     # 0x17fd8
leaq 0xcc8b(%rip), %rsi      # 0x100ab
callq 0x21c0
movq %rax, %rdi
movq 0x14b99(%rip), %rsi     # 0x17fc8
callq 0x2200
movq 0x14b9d(%rip), %rdi     # 0x17fd8
leaq 0xcca1(%rip), %rsi      # 0x100e3
callq 0x21c0
movq %rax, %rdi
movq 0x14b77(%rip), %rsi     # 0x17fc8
callq 0x2200
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4a00
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3594
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x4a30
movl (%rax), %esi
movq 0x14b44(%rip), %rdi     # 0x17fd8
callq 0x2370
movq %rax, %rdi
leaq 0xcc71(%rip), %rsi      # 0x10114
callq 0x21c0
movq -0x18(%rbp), %rdi
movq %rax, -0x38(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x4a30
movq -0x38(%rbp), %rdi
movl 0x10(%rax), %esi
callq 0x2370
movq 0x14b0c(%rip), %rdi     # 0x17fd8
leaq 0xcc41(%rip), %rsi      # 0x10114
callq 0x21c0
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x4a30
movq -0x30(%rbp), %rdi
movl 0x14(%rax), %esi
callq 0x2370
movq %rax, %rdi
leaq 0xcc15(%rip), %rsi      # 0x10114
callq 0x21c0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x4a30
movl 0x8(%rax), %esi
movq 0x14abd(%rip), %rdi     # 0x17fd8
callq 0x2370
movq %rax, %rdi
leaq 0xcbea(%rip), %rsi      # 0x10114
callq 0x21c0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x4a30
movq -0x28(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x2370
movq %rax, %rdi
leaq 0xcbbe(%rip), %rsi      # 0x10114
callq 0x21c0
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x4a30
movl 0x18(%rax), %esi
movq 0x14a66(%rip), %rdi     # 0x17fd8
callq 0x2370
movq %rax, %rdi
movq 0x14a47(%rip), %rsi     # 0x17fc8
callq 0x2200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x345d
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: maramire[P]SP_PSO/parallel_main.cpp
// Function: showSwarm(std::vector<Particle, std::allocator<Particle>>)
void showSwarm(Swarm swarm)
{
    /* print swarm */
    for (int i = 0; i < swarm.size(); i++)
    {
        //showPermutation(swarm[i].permutation);
        cout << "Fitness: " << swarm[i].fitness << endl;
        cout << "Velocity : ";
        for (int j=0; j< swarm[i].velocity.size(); j++){
                cout << swarm[i].velocity[j];
                cout << ", ";
            }
        cout <<endl;
        cout <<endl;
        
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x58b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x36dd
movq 0x149f9(%rip), %rdi     # 0x17fd8
leaq 0xcb30(%rip), %rsi      # 0x10116
callq 0x21c0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x58e0
movq -0x28(%rbp), %rdi
movl 0x18(%rax), %esi
callq 0x2370
movq %rax, %rdi
movq 0x149b6(%rip), %rsi     # 0x17fc8
callq 0x2200
movq 0x149ba(%rip), %rdi     # 0x17fd8
leaq 0xcafb(%rip), %rsi      # 0x10120
callq 0x21c0
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x58e0
movq %rax, %rdi
addq $0x40, %rdi
callq 0x5620
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x36a9
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x58e0
movq %rax, %rdi
addq $0x40, %rdi
movslq -0x10(%rbp), %rsi
callq 0x5640
movss (%rax), %xmm0
movq 0x14952(%rip), %rdi     # 0x17fd8
callq 0x2140
movq 0x14946(%rip), %rdi     # 0x17fd8
leaq 0xc9d7(%rip), %rsi      # 0x10070
callq 0x21c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3631
movq 0x14928(%rip), %rdi     # 0x17fd8
movq 0x14911(%rip), %rsi     # 0x17fc8
callq 0x2200
movq 0x14915(%rip), %rdi     # 0x17fd8
movq 0x148fe(%rip), %rsi     # 0x17fc8
callq 0x2200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x35b7
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x10, %rdi
movq %rdi, -0x78(%rbp)
callq 0x2f880
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rsi
movq $0x0, 0x8(%rax)
movb $0x0, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x2f300
jmp 0x36baa
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x17c530
jmp 0x36bb9
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fd80
leaq -0x30(%rbp), %rdi
callq 0x311e8
leaq -0x50(%rbp), %rdi
callq 0x311e8
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x36c08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x311e8
movq -0x78(%rbp), %rdi
callq 0x311e8
movq -0x58(%rbp), %rdi
callq 0x30170
nopw (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Config.cpp
// Function: Config::printDetails()
int Config::printDetails(){ //razi added for debugging
	if (swarm_ != NULL){
		swarm_->printDetails();
	}
//	else{
//		cout<<"No Details for config file: "<< configPath_ <<", Swarm object has not created yet !!! "<<endl;
//	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x36c48
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11a620
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq (%rax), %rdi
callq 0x8e350
movq %rax, -0x20(%rbp)
movq -0x90(%rbp), %rax
movq (%rax), %rdi
callq 0x8e3b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8e380
testb $0x1, %al
jne 0x8d0bf
jmp 0x8d206
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8e4c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x8e4e0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8e4c0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x8e540
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8e510
testb $0x1, %al
jne 0x8d113
jmp 0x8d15a
leaq -0x30(%rbp), %rdi
callq 0x8e590
movsd 0x8(%rax), %xmm0
callq 0x8e570
testb $0x1, %al
jne 0x8d12c
jmp 0x8d12e
jmp 0x8d14f
leaq -0x30(%rbp), %rdi
callq 0x8e590
movsd 0x8(%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8e5e0
jmp 0x8d0e7
movq -0x90(%rbp), %rax
addq $0x38, %rax
movq %rax, -0xb0(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8e4c0
movq %rax, %rsi
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x68(%rbp), %rdx
callq 0x8e760
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x8e720
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x8d1c1
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8e7a0
leaq -0x20(%rbp), %rdi
callq 0x8e6f0
jmp 0x8d096
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8e7a0
jmp 0x8d20f
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x30170
nopl (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::Data(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<double, double, std::less<double>, std::allocator<std::pair<double const, double>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<double, double, std::less<double>, std::allocator<std::pair<double const, double>>>>>>&)
Data::Data(map<string, map<double, double> > &dataSet) {
	dataOrig_ = dataSet;
	dataCurrent = &dataOrig_;
	isExp_ = false;
	swarm_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x60(%rbp)
callq 0x8de10
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x58(%rbp)
callq 0x8de30
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x50(%rbp)
callq 0x2f880
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x28(%rbp)
callq 0x8de10
movq -0x38(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x48(%rbp)
callq 0x8de10
movq -0x38(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x40(%rbp)
callq 0x8de10
movq -0x38(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x30(%rbp)
callq 0x8de10
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8de90
jmp 0x8db06
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x90, %rcx
movq %rcx, (%rax)
movb $0x0, 0x158(%rax)
movq $0x0, 0x150(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8de50
movq -0x40(%rbp), %rdi
callq 0x8de50
movq -0x48(%rbp), %rdi
callq 0x8de50
movq -0x28(%rbp), %rdi
callq 0x8de50
movq -0x50(%rbp), %rdi
callq 0x311e8
movq -0x58(%rbp), %rdi
callq 0x8de70
movq -0x60(%rbp), %rdi
callq 0x8de50
movq -0x18(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::Data()
Data::Data() {
	map<string, map<double, double> > dummySet;
	dataOrig_ = dummySet;
	dataCurrent = 0;
	isExp_ = false;
	swarm_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
movq %rdi, -0x90(%rbp)
callq 0x8de10
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x88(%rbp)
callq 0x8de30
movq -0x68(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x80(%rbp)
callq 0x2f880
movq -0x68(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x58(%rbp)
callq 0x8de10
movq -0x68(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x78(%rbp)
callq 0x8de10
movq -0x68(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x70(%rbp)
callq 0x8de10
movq -0x68(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq %rdi, -0x60(%rbp)
callq 0x8de10
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x8de10
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x8de90
jmp 0x8dc48
movq -0x68(%rbp), %rax
movq $0x0, (%rax)
movb $0x0, 0x158(%rax)
movq $0x0, 0x150(%rax)
leaq -0x38(%rbp), %rdi
callq 0x8de50
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8de50
movq -0x60(%rbp), %rdi
callq 0x8de50
movq -0x70(%rbp), %rdi
callq 0x8de50
movq -0x78(%rbp), %rdi
callq 0x8de50
movq -0x58(%rbp), %rdi
callq 0x8de50
movq -0x80(%rbp), %rdi
callq 0x311e8
movq -0x88(%rbp), %rdi
callq 0x8de70
movq -0x90(%rbp), %rdi
callq 0x8de50
movq -0x40(%rbp), %rdi
callq 0x30170
nopw (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Data.cpp
// Function: Data::getPath[abi:cxx11]()
std::string Data::getPath() {
	if (!dataPath.empty())
		return dataPath;
	else
		return "empty";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x70, %rdi
callq 0x2f700
testb $0x1, %al
jne 0x8dd23
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x70, %rsi
callq 0x2f300
jmp 0x8dd68
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x30a70
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x15098b(%rip), %rsi    # 0x1de6ca
callq 0x44470
jmp 0x8dd46
leaq -0x11(%rbp), %rdi
callq 0x311c0
jmp 0x8dd68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x311c0
jmp 0x8dd72
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x30170
nopl (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/FreeParam.cpp
// Function: FreeParam::FreeParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FreeParam::FreeParam(string parameterName) {
	parameterName_ = parameterName;
	generationMethod_ = "";
	hasMutation_ = false;
	mutationRate_ = 0;
	mutationFactor_ = 0;
	genMin_ = 0;
	genMax_ = 0;
	isLog_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2f880
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2f880
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x30fa0
jmp 0x97bf8
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq 0x1418f9(%rip), %rsi    # 0x1d9500
callq 0x2f9d0
jmp 0x97c0e
movq -0x40(%rbp), %rax
movb $0x0, 0x50(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x40(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x44(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x4c(%rax)
movb $0x0, 0x51(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x311e8
movq -0x30(%rbp), %rdi
callq 0x311e8
movq -0x18(%rbp), %rdi
callq 0x30170
nopw (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/FreeParam.cpp
// Function: FreeParam::FreeParam()
FreeParam::FreeParam() {
	parameterName_ = "";
	generationMethod_ = "";
	hasMutation_ = false;
	mutationRate_ = 0;
	mutationFactor_ = 0;
	genMin_ = 0;
	genMax_ = 0;
	isLog_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x2f880
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2f880
movq -0x20(%rbp), %rdi
leaq 0x141854(%rip), %rsi    # 0x1d9500
callq 0x2f9d0
jmp 0x97cb3
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq 0x14183e(%rip), %rsi    # 0x1d9500
callq 0x2f9d0
jmp 0x97cc9
movq -0x30(%rbp), %rax
movb $0x0, 0x50(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x40(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x44(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x4c(%rax)
movb $0x0, 0x51(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x311e8
movq -0x20(%rbp), %rdi
callq 0x311e8
movq -0x10(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Model.cpp
// Function: Model::Model(Swarm*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Model::Model(Swarm * swarm, string path) {

	swarm_ = swarm;
	hasGenerateNetwork_ = false;
	modelPath_ = convertToAbsPath(path);
	parseModel();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
callq 0x9c220
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x98(%rbp)
callq 0x9c240
movq -0x78(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x90(%rbp)
callq 0x2f880
movq -0x78(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x88(%rbp)
callq 0x448b0
movq -0x78(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x80(%rbp)
callq 0x448b0
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rcx, 0x60(%rax)
movb $0x0, 0xb8(%rax)
leaq -0x58(%rbp), %rdi
callq 0x2f300
jmp 0x97e67
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x17c530
jmp 0x97e76
movq -0xa0(%rbp), %rdi
addq $0x68, %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x2fd80
movq -0xa8(%rbp), %rdi
callq 0x311e8
leaq -0x58(%rbp), %rdi
callq 0x311e8
movq -0xa0(%rbp), %rdi
callq 0x97f20
jmp 0x97eb4
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x97ee0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x311e8
movq -0x80(%rbp), %rdi
callq 0x448d0
movq -0x88(%rbp), %rdi
callq 0x448d0
movq -0x90(%rbp), %rdi
callq 0x311e8
movq -0x98(%rbp), %rdi
callq 0x9c260
movq -0x78(%rbp), %rdi
callq 0x9c280
movq -0x60(%rbp), %rdi
callq 0x30170
nop
// File: richardposner[P]BioNetFit2/src/code/Model.cpp
// Function: check_model_consistency(std::vector<Model*, std::allocator<Model*>>)
bool check_model_consistency(std::vector<Model *> models){
	if (models.size()==0){
		outputError("There is no models to compare. Add at least one model. I am quitting....\n");
	}else if (models.size()<1){
		cout<<"There are no models to compare\n"; return false;
	}else{
		Model * basic_model = models.at(0);
		vector<Model *>::iterator it;
		bool consflag=true;
		for (it=models.begin(); it!=models.end(); ++it){
			if (basic_model->getHasGenerateNetwork() != (*it)->getHasGenerateNetwork())
				consflag = false;
			if (basic_model->getNumFreeParams() != (*it)->getNumFreeParams())
				consflag = false;
		}
		return consflag;
	}
	return 0; //Raquel Fixing warnings
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x45170
cmpq $0x0, %rax
jne 0x9c064
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x30a70
movq -0x80(%rbp), %rdx
leaq 0x13ea49(%rip), %rsi    # 0x1daa4f
leaq -0x30(%rbp), %rdi
callq 0x44470
jmp 0x9c011
leaq -0x30(%rbp), %rdi
callq 0x17e420
jmp 0x9c01c
leaq -0x30(%rbp), %rdi
callq 0x311e8
leaq -0x31(%rbp), %rdi
callq 0x311c0
jmp 0x9c16a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9c056
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x311e8
leaq -0x31(%rbp), %rdi
callq 0x311c0
jmp 0x9c17c
movq -0x78(%rbp), %rdi
callq 0x45170
cmpq $0x1, %rax
jae 0x9c08f
movq 0x238ed6(%rip), %rdi    # 0x2d4f50
leaq 0x13ea18(%rip), %rsi    # 0x1daa99
callq 0x2ff50
movb $0x0, -0x1(%rbp)
jmp 0x9c16e
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45190
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9cb00
movq -0x78(%rbp), %rdi
movb $0x1, -0x59(%rbp)
callq 0x9cb20
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x78(%rbp), %rdi
callq 0x9cb90
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9cb50
testb $0x1, %al
jne 0x9c0e5
jmp 0x9c160
movq -0x50(%rbp), %rdi
callq 0x9cbc0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9cbe0
movq (%rax), %rdi
callq 0x9cbc0
movb %al, %cl
movl -0x84(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x9c120
movb $0x0, -0x59(%rbp)
movq -0x50(%rbp), %rdi
callq 0x45b60
movl %eax, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9cbe0
movq (%rax), %rdi
callq 0x45b60
movl %eax, %ecx
movl -0x88(%rbp), %eax
cmpl %ecx, %eax
je 0x9c150
movb $0x0, -0x59(%rbp)
jmp 0x9c152
leaq -0x58(%rbp), %rdi
callq 0x9cc00
jmp 0x9c0c5
movb -0x59(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9c16e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
void Parser::split(string in, string& left, string& right, char c) {
	size_t pos = in.find_first_of(c);
	if(pos == string::npos) {
		left = in;
		trim(left);
		right = "";
	} else if (pos <= 1) {
		left = "";
		right = in.substr(pos+1, string::npos);
		trim(right);
	} else {
		left = in.substr(0, pos-1);
		trim(left);
		right = in.substr(pos+1, string::npos);
		trim(right);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rsi
movq -0xa0(%rbp), %rdi
movb %r8b, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
xorl %eax, %eax
movl %eax, %edx
movsbl -0x21(%rbp), %esi
callq 0x30080
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x9f7fa
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x30fa0
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9fa70
movq -0x20(%rbp), %rdi
leaq 0x139d10(%rip), %rsi    # 0x1d9500
callq 0x2f9d0
jmp 0x9f8ed
cmpq $0x1, -0x30(%rbp)
ja 0x9f85b
movq -0x18(%rbp), %rdi
leaq 0x139cf4(%rip), %rsi    # 0x1d9500
callq 0x2f9d0
movq -0xa0(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
leaq -0x50(%rbp), %rdi
movq $-0x1, %rcx
callq 0x30b40
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2fd80
leaq -0x50(%rbp), %rdi
callq 0x311e8
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9fa70
jmp 0x9f8eb
movq -0xa0(%rbp), %rsi
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
leaq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x30b40
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2fd80
leaq -0x70(%rbp), %rdi
callq 0x311e8
movq -0x98(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9fa70
movq -0xa0(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq $0x1, %rdx
leaq -0x90(%rbp), %rdi
movq $-0x1, %rcx
callq 0x30b40
movq -0x20(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2fd80
leaq -0x90(%rbp), %rdi
callq 0x311e8
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9fa70
jmp 0x9f8ed
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::symbolExpand(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Parser::symbolExpand(map<string, string>& symbols, string& s) {
	bool expanded;
	do {
		expanded = false;
		for (map<string, string>::iterator i = symbols.begin(); i != symbols.end(); ++i) {
			string search = "%" + i->first + "%";
			string replace = i->second;
			size_t pos = s.find(search);
			if (pos != string::npos) {
				expanded = true;
				s.replace(pos, search.length(), replace);
			}
		}
	} while (expanded);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa0770
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa07d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa07a0
testb $0x1, %al
jne 0x9fdbb
jmp 0x9feff
leaq -0x28(%rbp), %rdi
callq 0xa0800
movq %rax, %rdx
leaq 0x13ad07(%rip), %rsi    # 0x1daad5
movq %rsi, -0xb0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x44240
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x441f0
jmp 0x9fdfe
leaq -0x70(%rbp), %rdi
callq 0x311e8
leaq -0x28(%rbp), %rdi
callq 0xa0800
movq %rax, %rsi
addq $0x20, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x2f300
jmp 0x9fe25
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x30130
movq %rax, -0xa8(%rbp)
cmpq $-0x1, -0xa8(%rbp)
je 0x9fed1
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2ff30
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
leaq -0xa0(%rbp), %rcx
callq 0x30a90
jmp 0x9fe90
jmp 0x9fed1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x311e8
jmp 0x9ff14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x9fef4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x311e8
jmp 0x9fef4
leaq -0xa0(%rbp), %rdi
callq 0x311e8
leaq -0x50(%rbp), %rdi
callq 0x311e8
leaq -0x28(%rbp), %rdi
callq 0xa0820
jmp 0x9fd98
leaq -0x50(%rbp), %rdi
callq 0x311e8
jmp 0x9ff14
jmp 0x9ff01
testb $0x1, -0x19(%rbp)
jne 0x9fd87
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x30170
nopl (%rax)
// File: richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::pString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Parser::pString(string name) {
	map<string, string>::iterator i = symbols.find(name);
	if (i == symbols.end()) {
		//logError(cout << "access of missing property '" << name << "' (" << debugInfo << ")" << endl);
		exit(4);
	}
	return i->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rdi, -0x40(%rbp)
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xa0850
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xa07d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa0880
testb $0x1, %al
jne 0x9ff7b
jmp 0x9ff85
movl $0x4, %edi
callq 0x30200
leaq -0x20(%rbp), %rdi
callq 0xa0800
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x2f300
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Parser.cpp
// Function: Parser::pBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::pBool(string name) {
	string val = pString(name);

	if ( (val == "yes") ||
	     (val == "Yes") ||
	     (val == "YES") ||
		 (val == "true") ||
	     (val == "True") ||
	     (val == "TRUE"))
	{
		return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2f300
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x9ff20
jmp 0x9ffeb
leaq -0x58(%rbp), %rdi
callq 0x311e8
leaq 0x13aadc(%rip), %rsi    # 0x1daad7
leaq -0x38(%rbp), %rdi
callq 0x44930
movb %al, -0x79(%rbp)
jmp 0xa0009
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xa00ac
jmp 0xa0016
leaq 0x13aabe(%rip), %rsi    # 0x1daadb
leaq -0x38(%rbp), %rdi
callq 0x44930
movb %al, -0x7a(%rbp)
jmp 0xa002b
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0xa00ac
jmp 0xa0034
leaq 0x13aaa4(%rip), %rsi    # 0x1daadf
leaq -0x38(%rbp), %rdi
callq 0x44930
movb %al, -0x7b(%rbp)
jmp 0xa0049
movb -0x7b(%rbp), %al
testb $0x1, %al
jne 0xa00ac
jmp 0xa0052
leaq 0x13aa8a(%rip), %rsi    # 0x1daae3
leaq -0x38(%rbp), %rdi
callq 0x44930
movb %al, -0x7c(%rbp)
jmp 0xa0067
movb -0x7c(%rbp), %al
testb $0x1, %al
jne 0xa00ac
jmp 0xa0070
leaq 0x13aa71(%rip), %rsi    # 0x1daae8
leaq -0x38(%rbp), %rdi
callq 0x44930
movb %al, -0x7d(%rbp)
jmp 0xa0085
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0xa00ac
jmp 0xa008e
leaq 0x13aa58(%rip), %rsi    # 0x1daaed
leaq -0x38(%rbp), %rdi
callq 0x44930
movb %al, -0x7e(%rbp)
jmp 0xa00a3
movb -0x7e(%rbp), %al
testb $0x1, %al
jne 0xa00ac
jmp 0xa00e7
movb $0x1, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0xa00f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x311e8
jmp 0xa0109
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x311e8
jmp 0xa0109
movb $0x0, -0x1(%rbp)
movl $0x1, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x311e8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)
// File: richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::objFunc_divByMeasured(double, double, double)
double Particle::objFunc_divByMeasured(double sim, double exp, double dummyvar) {
	if(swarm_->options.verbosity >=4){
		cout << "sim: " << sim << endl;
		cout << "exp: " << exp << endl;
	}
	if(sim!=0){
		return pow(((abs(sim) - exp) / sim), 2);
	}else{
		return pow(((abs(sim) - exp)), 2); //Raquel solving division by zero problem

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
cmpl $0x4, 0x1614(%rax)
jb 0xa341d
movq 0x231b8a(%rip), %rdi    # 0x2d4f50
leaq 0x1377e4(%rip), %rsi    # 0x1dabb1
callq 0x2ff50
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0x30710
movq %rax, %rdi
movq 0x231bdf(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
movq 0x231b5b(%rip), %rdi    # 0x2d4f50
leaq 0x1377bb(%rip), %rsi    # 0x1dabb7
callq 0x2ff50
movq %rax, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x30710
movq %rax, %rdi
movq 0x231bb0(%rip), %rsi    # 0x2d4fc8
callq 0x30c10
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa342f
jp 0xa342f
jmp 0xa3454
movsd -0x18(%rbp), %xmm0
callq 0x9c8a0
subsd -0x20(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
movl $0x2, %edi
callq 0x8e5b0
movsd %xmm0, -0x8(%rbp)
jmp 0xa3472
movsd -0x18(%rbp), %xmm0
callq 0x9c8a0
subsd -0x20(%rbp), %xmm0
movl $0x2, %edi
callq 0x8e5b0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: richardposner[P]BioNetFit2/src/code/Particle.cpp
// Function: Particle::getCentroid(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
vector<double> Particle::getCentroid(vector<vector<double> > centroidVectors) {
	vector<double> centroid;

	for (unsigned int d = 0; d < centroidVectors[0].size(); ++d) {
		double sum = 0;
		for (unsigned int set = 0; set < centroidVectors.size(); ++set) {
			sum += centroidVectors[set][d];
		}
		centroid.push_back(sum / centroidVectors[0].size());
	}

	return centroid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xb2580
movl $0x0, -0x20(%rbp)
movq -0x60(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xb25a0
movq %rax, %rdi
callq 0xb25c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xa360b
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x60(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq %rax, -0x70(%rbp)
callq 0xb25e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0xa3581
movq -0x60(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xb25a0
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0xb2610
movsd (%rax), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa3531
movq -0x60(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xb25a0
movq %rax, %rdi
callq 0xb25c0
movsd -0x78(%rbp), %xmm0
movq -0x58(%rbp), %rdi
movq %rax, %xmm1
movaps 0x13754b(%rip), %xmm2   # 0x1dab00
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x13754f(%rip), %xmm2   # 0x1dab10
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xb2630
jmp 0xa35e4
jmp 0xa35e6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa34f6
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xb2660
jmp 0xa362b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa361e
movq -0x58(%rbp), %rdi
callq 0xb2660
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x30170
nopw %cs:(%rax,%rax)