LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sokolcom[P]tp-blockchain-task06/uint256_t/uint256_t.cpp
// Function: uint256_t::addmod(uint256_t&, uint256_t const&) const
uint256_t uint256_t::addmod(uint256_t &another, const uint256_t &modulo) const
{
    uint256_t result;

    if (modulo - *this > another)
    {
        result = *this + another;
    }
    else
    {
        result = another - (modulo - *this);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0xa0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8280
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x7e60
testb $0x1, %al
jne 0xaa40
jmp 0xaa7c
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x8130
movq -0xb0(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0xaadb
movq -0xa0(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x8280
movq -0xb8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x8280
movq -0xb0(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq -0x70(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sokolcom[P]tp-blockchain-task06/uint256_t/uint256_t.cpp
// Function: uint256_t::from_bytes(unsigned char const*)
void uint256_t::from_bytes(const uint8_t *const bytes)
{
    uint64_t buffer64[4] = { 0 };
    for (uint8_t i = 0; i < 4; i++)
    {
        uint64_t value = 0;
        for (int8_t j = (i * 8) + 7; j >= (i * 8); j--)
        {
            value <<= 8;
            value |= (uint64_t)bytes[j];
        }

        buffer64[i] = value;
    }

    uint128_t upper(buffer64[3], buffer64[2]), lower(buffer64[1], buffer64[0]);
    UPPER = upper;
    LOWER = lower;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3100
movb $0x0, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x4, %eax
jge 0xab8b
movq $0x0, -0x40(%rbp)
movzbl -0x31(%rbp), %eax
shll $0x3, %eax
addl $0x7, %eax
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %eax
movzbl -0x31(%rbp), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jl 0xab74
movq -0x40(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsbq -0x41(%rbp), %rcx
movzbl (%rax,%rcx), %eax
orq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movb -0x41(%rbp), %al
addb $-0x1, %al
movb %al, -0x41(%rbp)
jmp 0xab3a
movq -0x40(%rbp), %rcx
movzbl -0x31(%rbp), %eax
movq %rcx, -0x30(%rbp,%rax,8)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0xab1c
leaq -0x30(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%rbp), %rdx
addq $0x10, %rdx
leaq -0x58(%rbp), %rdi
callq 0x5920
leaq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x5920
movq -0x70(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sokolcom[P]tp-blockchain-task06/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        throw std::invalid_argument("Error!\nInvalid amount of the options!");
        return FAILURE;
    }
    else
    {
        if (!strcmp(argv[1], "split"))
        {
            mode_split();
        }
        else if (!strcmp(argv[1], "recover"))
        {
            mode_recover();
        }
        else
        {
            throw std::invalid_argument("Error!\nUnknown option!");
            return FAILURE;
        }
    }

    return SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0xbdcf
movl $0x10, %edi
callq 0x30e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x3358(%rip), %rsi      # 0xf0ef
callq 0x33b0
jmp 0xbd9e
movq -0x28(%rbp), %rdi
movq 0xa227(%rip), %rsi      # 0x15fd0
movq 0xa210(%rip), %rdx      # 0x15fc0
callq 0x3360
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3190
jmp 0xbe6b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x3337(%rip), %rsi      # 0xf115
callq 0x32f0
cmpl $0x0, %eax
jne 0xbdef
callq 0xdb00
jmp 0xbe61
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x331d(%rip), %rsi      # 0xf11b
callq 0x32f0
cmpl $0x0, %eax
jne 0xbe0f
callq 0xbe80
jmp 0xbe5f
movl $0x10, %edi
callq 0x30e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x32f9(%rip), %rsi      # 0xf123
callq 0x33b0
jmp 0xbe31
movq -0x30(%rbp), %rdi
movq 0xa194(%rip), %rsi      # 0x15fd0
movq 0xa17d(%rip), %rdx      # 0x15fc0
callq 0x3360
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3190
jmp 0xbe6b
jmp 0xbe61
jmp 0xbe63
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
nop
// File: sokolcom[P]tp-blockchain-task06/src/recover.cpp
// Function: mode_recover()
int16_t mode_recover()
{
    uint16_t t;
    std::cout << "T: ";
    std::cin >> t;
    std::vector<std::pair<uint256_t, uint256_t>> points_vector;

    uint16_t i = 0;
    bool input_flag = true;
    std::cout << "To stop entering type 'stop'...\n";
    while ((i < t) || input_flag)
    {
        std::pair<uint256_t, uint256_t> pair;
        bool code = get_point(pair);
        if (code && (i < t))
        {
            std::cout << "Not enough points were entered!\nContinue entering...\n";
        }
        else if (code && (i >= t))
        {
            input_flag = false;
        }
        else
        {
            points_vector.push_back(pair);
            i++;
        }
    }

    uint256_t secret = reconstruct_secret(points_vector, t);
    std::cout << std::hex << "\nSecret: 0x" << secret << "\n";

    return SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq 0xa126(%rip), %rdi      # 0x15fb8
movq %rdi, -0xa8(%rbp)
leaq 0x3351(%rip), %rsi      # 0xf1f1
callq 0x3200
movq 0xa12c(%rip), %rdi      # 0x15fd8
leaq -0x2(%rbp), %rsi
callq 0x3120
leaq -0x20(%rbp), %rdi
callq 0xc690
movq -0xa8(%rbp), %rdi
movw $0x0, -0x22(%rbp)
movb $0x1, -0x23(%rbp)
leaq 0x3264(%rip), %rsi      # 0xf13a
callq 0x3200
jmp 0xbedd
jmp 0xbedf
movzwl -0x22(%rbp), %ecx
movzwl -0x2(%rbp), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0xa9(%rbp)
jl 0xbefc
movb -0x23(%rbp), %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0xbf0b
jmp 0xbfaf
leaq -0x78(%rbp), %rdi
callq 0xc6b0
jmp 0xbf16
leaq -0x78(%rbp), %rdi
callq 0xc050
movb %al, -0xaa(%rbp)
jmp 0xbf27
movb -0xaa(%rbp), %al
andb $0x1, %al
movb %al, -0x79(%rbp)
testb $0x1, -0x79(%rbp)
je 0xbf75
movzwl -0x22(%rbp), %eax
movzwl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jge 0xbf75
movq 0xa06d(%rip), %rdi      # 0x15fb8
leaq 0x3209(%rip), %rsi      # 0xf15b
callq 0x3200
jmp 0xbf59
jmp 0xbfaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc790
jmp 0xc042
testb $0x1, -0x79(%rbp)
je 0xbf8d
movzwl -0x22(%rbp), %eax
movzwl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jl 0xbf8d
movb $0x0, -0x23(%rbp)
jmp 0xbfa8
leaq -0x20(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xc6f0
jmp 0xbf9c
movw -0x22(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x22(%rbp)
jmp 0xbfaa
jmp 0xbedf
movzwl -0x2(%rbp), %edx
leaq -0xa0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc180
jmp 0xbfc5
movq 0x9fec(%rip), %rdi      # 0x15fb8
leaq 0x78d(%rip), %rsi       # 0xc760
callq 0x3070
movq %rax, -0xb8(%rbp)
jmp 0xbfe1
movq -0xb8(%rbp), %rdi
leaq 0x31a2(%rip), %rsi      # 0xf191
callq 0x3200
movq %rax, -0xc0(%rbp)
jmp 0xbffd
movq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0xa370
movq %rax, -0xc8(%rbp)
jmp 0xc019
movq -0xc8(%rbp), %rdi
leaq 0x3132(%rip), %rsi      # 0xf159
callq 0x3200
jmp 0xc02e
leaq -0x20(%rbp), %rdi
callq 0xc790
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3380
nopl (%rax,%rax)
// File: sokolcom[P]tp-blockchain-task06/src/recover.cpp
// Function: get_point(std::pair<uint256_t, uint256_t>&)
static bool get_point(std::pair<uint256_t, uint256_t> &pair)
{
    std::string str_x, str_y;
    std::cin >> str_x;

    if (str_x != "stop")
    {
        std::cin >> str_y;
        uint256_t x = str_x, y = str_y;
        pair = std::make_pair(x, y);
    }
    return (str_x == "stop");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x32e0
leaq -0x48(%rbp), %rdi
callq 0x32e0
movq -0xe0(%rbp), %rsi
movq 0x9f52(%rip), %rdi      # 0x15fd8
callq 0x32b0
jmp 0xc08d
leaq 0x3109(%rip), %rsi      # 0xf19d
leaq -0x28(%rbp), %rdi
callq 0xc8a0
movb %al, -0xe1(%rbp)
jmp 0xc0a5
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0xc0b1
jmp 0xc12f
movq 0x9f20(%rip), %rdi      # 0x15fd8
leaq -0x48(%rbp), %rsi
callq 0x32b0
jmp 0xc0c3
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6b50
jmp 0xc0d2
leaq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6b50
jmp 0xc0e4
leaq -0xd8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0xc8d0
jmp 0xc0fd
movq -0x8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0xb310
jmp 0xc12f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3140
leaq -0x28(%rbp), %rdi
callq 0x3140
jmp 0xc16a
leaq 0x3067(%rip), %rsi      # 0xf19d
leaq -0x28(%rbp), %rdi
callq 0xc900
movb %al, -0xe2(%rbp)
jmp 0xc147
leaq -0x48(%rbp), %rdi
callq 0x3140
leaq -0x28(%rbp), %rdi
callq 0x3140
movb -0xe2(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: sokolcom[P]tp-blockchain-task06/src/split.cpp
// Function: split_key(uint256_t, unsigned short, unsigned short)
void split_key(const uint256_t key, const uint16_t n, const uint16_t t)
{
    std::shared_ptr<uint256_t[]> equation_coeffs = create_coeffs(t, key);
    for (uint8_t i = 0; i < n; i++)
    {
        uint256_t x = generate_x();
        uint256_t y = calculate_equation(x, equation_coeffs, t);
        std::cout << std::hex << "0x" << x << " 0x" << y << "\n";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movw %si, %ax
movw %di, %cx
leaq 0x10(%rbp), %rdx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
movzwl -0x4(%rbp), %esi
callq 0xd690
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movzwl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jge 0xd65f
leaq -0x40(%rbp), %rdi
callq 0xd890
jmp 0xd559
leaq -0x80(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x18(%rbp), %rsi
callq 0xdc40
movq -0x88(%rbp), %rdx
movzwl -0x4(%rbp), %ecx
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd970
jmp 0xd587
leaq -0x80(%rbp), %rdi
callq 0xdc70
movq 0x8a21(%rip), %rdi      # 0x15fb8
leaq -0xe3e(%rip), %rsi      # 0xc760
callq 0x3070
movq %rax, -0x90(%rbp)
jmp 0xd5ac
movq -0x90(%rbp), %rdi
leaq 0x1be0(%rip), %rsi      # 0xf19a
callq 0x3200
movq %rax, -0x98(%rbp)
jmp 0xd5c8
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa370
movq %rax, -0xa0(%rbp)
jmp 0xd5e1
movq -0xa0(%rbp), %rdi
leaq 0x1baa(%rip), %rsi      # 0xf199
callq 0x3200
movq %rax, -0xa8(%rbp)
jmp 0xd5fd
movq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa370
movq %rax, -0xb0(%rbp)
jmp 0xd616
movq -0xb0(%rbp), %rdi
leaq 0x1b35(%rip), %rsi      # 0xf159
callq 0x3200
jmp 0xd62b
jmp 0xd62d
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0xd53e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xd671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xdc70
jmp 0xd671
leaq -0x18(%rbp), %rdi
callq 0xdc70
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xdc70
movq -0x48(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
// File: sokolcom[P]tp-blockchain-task06/src/split.cpp
// Function: create_coeffs(unsigned short, uint256_t const&)
static std::shared_ptr<uint256_t[]> create_coeffs(const uint16_t t, const uint256_t &private_key)
{
    const uint256_t modulo = FIELD_MODULO;
    std::shared_ptr<uint256_t[]> coeffs(new uint256_t[t]);

    coeffs[0] = private_key;
    for (uint8_t i = 1; i < t; i++)
    {
        uint8_t buffer[BYTES_PER_256_BIT] = { 0 };
        int8_t code = RAND_bytes(buffer, 32);
        if (!code)
        {
            throw std::runtime_error("Error!\nOpenSSL function failed!");
        }
        coeffs[i].from_bytes(buffer);
        coeffs[i] %= modulo;
    }

    return coeffs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x90(%rbp)
movw %si, %ax
movq %rdi, %rcx
movq %rcx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1ae0(%rip), %rsi      # 0xf1a2
leaq -0x38(%rbp), %rdi
callq 0x6cb0
movb $0x0, -0x39(%rbp)
movzwl -0xa(%rbp), %eax
shll $0x5, %eax
movl %eax, %edi
callq 0x3030
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0xdc90
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xdcc0
movq %rax, -0x80(%rbp)
jmp 0xd70d
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movb $0x1, -0x4d(%rbp)
movzbl -0x4d(%rbp), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jge 0xd855
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x20, %esi
callq 0x3310
movl %eax, -0x9c(%rbp)
jmp 0xd76b
movl -0x9c(%rbp), %eax
movb %al, -0x71(%rbp)
cmpb $0x0, -0x71(%rbp)
jne 0xd7ec
movl $0x10, %edi
callq 0x30e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
leaq 0x1a8a(%rip), %rsi      # 0xf222
callq 0x30a0
jmp 0xd79f
movq -0xa8(%rbp), %rdi
movq 0x8843(%rip), %rsi      # 0x15ff0
movq 0x87f4(%rip), %rdx      # 0x15fa8
callq 0x3360
jmp 0xd890
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xd87b
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3190
jmp 0xd87b
movq -0x90(%rbp), %rdi
movzbl -0x4d(%rbp), %eax
movl %eax, %esi
callq 0xdcc0
movq %rax, -0xb0(%rbp)
jmp 0xd807
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xaaf0
jmp 0xd819
movq -0x90(%rbp), %rdi
movzbl -0x4d(%rbp), %eax
movl %eax, %esi
callq 0xdcc0
movq %rax, -0xb8(%rbp)
jmp 0xd834
movq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9150
jmp 0xd846
jmp 0xd848
movb -0x4d(%rbp), %al
addb $0x1, %al
movb %al, -0x4d(%rbp)
jmp 0xd73a
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0xd86b
movq -0x90(%rbp), %rdi
callq 0xdc70
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xdc70
movq -0x48(%rbp), %rdi
callq 0x3380
// File: sokolcom[P]tp-blockchain-task06/src/split.cpp
// Function: generate_x()
static uint256_t generate_x()
{
    uint8_t buffer[BYTES_PER_256_BIT] = { 0 };
    int8_t code = RAND_bytes(buffer, 32);
    if (code != 1)
    {
        throw std::runtime_error("Error!\nOpenSSL function failed!");
    }

    uint256_t x;
    x.from_bytes(buffer);

    const uint256_t modulo = FIELD_MODULO;
    return x % modulo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3100
leaq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x3310
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x1, %eax
je 0xd929
movl $0x10, %edi
callq 0x30e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
leaq 0x1934(%rip), %rsi      # 0xf222
callq 0x30a0
jmp 0xd8f5
movq -0x90(%rbp), %rdi
movq 0x86ed(%rip), %rsi      # 0x15ff0
movq 0x869e(%rip), %rdx      # 0x15fa8
callq 0x3360
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3190
jmp 0xd967
leaq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xaaf0
leaq -0x78(%rbp), %rdi
leaq 0x1861(%rip), %rsi      # 0xf1a2
callq 0x6cb0
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0x90a0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3380
// File: sokolcom[P]tp-blockchain-task06/src/split.cpp
// Function: calculate_equation(uint256_t const&, std::shared_ptr<uint256_t []>, unsigned short)
static uint256_t calculate_equation(const uint256_t &x, std::shared_ptr<uint256_t[]> coeffs, const uint16_t t)
{
    const uint256_t modulo = FIELD_MODULO;
    uint256_t result = 0;

    for (uint16_t i = 0; i < t; i++)
    {
        uint256_t temp = coeffs[i].mulmod(x.powmod(i, modulo), modulo);
        result = result.addmod(temp, modulo);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdx, -0xd8(%rbp)
movq %rdi, -0xc8(%rbp)
movw %cx, %ax
movq %rdi, -0xd0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
leaq -0x38(%rbp), %rdi
leaq 0x17f8(%rip), %rsi      # 0xf1a2
callq 0x6cb0
movq -0xc8(%rbp), %rdi
movl $0x0, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0xabf0
movw $0x0, -0x3e(%rbp)
movzwl -0x3e(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jge 0xdae5
movq -0xd8(%rbp), %rdi
movzwl -0x3e(%rbp), %eax
movl %eax, %esi
callq 0xdcc0
movq %rax, -0xe0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x3e(%rbp), %rsi
callq 0xb370
movq -0xe8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rax
leaq -0x38(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa5f0
movq -0xe0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rax
leaq -0x38(%rbp), %rdx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa7f0
movq -0xc8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0xa9f0
movq -0xc8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xb8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xb0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0xa8(%rbp), %rcx
movq %rcx, 0x18(%rax)
movw -0x3e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x3e(%rbp)
jmp 0xd9cc
movq -0xd0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sokolcom[P]tp-blockchain-task06/src/split.cpp
// Function: mode_split()
int16_t mode_split()
{
    uint256_t private_key;
    uint16_t n, t;

    std::cout << "Secret: ";
    std::cin >> private_key;
    std::cout << "N, T: ";
    std::cin >> n >> t;

    if (((n > 2) && (n < 100)) && ((t >= 2) && (t <= n)))
    {
        split_key(private_key, n, t);
    }
    else
    {
        throw std::invalid_argument("Error!\nInvalid N, T parameters were entered!");
        return FAILURE;
    }

    return SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x84a6(%rip), %rdi      # 0x15fb8
leaq 0x16cc(%rip), %rsi      # 0xf1e5
callq 0x3200
movq 0x84b3(%rip), %rdi      # 0x15fd8
leaq -0x20(%rbp), %rsi
callq 0xa550
movq 0x8483(%rip), %rdi      # 0x15fb8
leaq 0x16b2(%rip), %rsi      # 0xf1ee
callq 0x3200
movq 0x8490(%rip), %rdi      # 0x15fd8
leaq -0x22(%rbp), %rsi
callq 0x3120
movq %rax, %rdi
leaq -0x24(%rbp), %rsi
callq 0x3120
movzwl -0x22(%rbp), %eax
cmpl $0x2, %eax
jle 0xdbdc
movzwl -0x22(%rbp), %eax
cmpl $0x64, %eax
jge 0xdbdc
movzwl -0x24(%rbp), %eax
cmpl $0x2, %eax
jl 0xdbdc
movzwl -0x24(%rbp), %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jg 0xdbdc
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movw -0x22(%rbp), %ax
leaq -0x48(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movzwl %ax, %edi
movzwl -0x24(%rbp), %esi
callq 0xd510
jmp 0xdc2c
movl $0x10, %edi
callq 0x30e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x15fe(%rip), %rsi      # 0xf1f5
callq 0x33b0
jmp 0xdbfe
movq -0x60(%rbp), %rdi
movq 0x83c7(%rip), %rsi      # 0x15fd0
movq 0x83b0(%rip), %rdx      # 0x15fc0
callq 0x3360
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3190
jmp 0xdc37
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3380
// File: JRLamontagne[P]cdice_sa/CDICEMain.cpp
// Function: readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
vector< vector<double> > readFile(string filename, int idx1, int idx2)
{
	ifstream inFile;
	inFile.open(filename.c_str());
	
	vector< vector <double> > params;
	vector<double> param_hold;
	string line;
	double p;
	int i=0;
	int j=0;
	
	while(getline(inFile, line))
	{
		param_hold.clear();
		stringstream inFile(line);
		if (i>=idx1)
		{
			if (i<idx2)
			{
				while(inFile >> p)
				{
					param_hold.push_back(p);
				}
				params.push_back(param_hold);
			}
		}
		i++;
	}
	
	return params;
}

// Assembly:
subq $0x448, %rsp            # imm = 0x448
movq %rsi, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x440(%rsp)
movq %rsi, 0x438(%rsp)
movl %edx, 0x434(%rsp)
movl %ecx, 0x430(%rsp)
leaq 0x228(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x97b0
movq 0x38(%rsp), %rdi
callq 0x9220
movq 0x40(%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x93b0
jmp 0xa247
movq 0x28(%rsp), %rdi
movb $0x0, 0x21b(%rsp)
callq 0xb790
leaq 0x200(%rsp), %rdi
callq 0xb7a0
leaq 0x1e0(%rsp), %rdi
callq 0x9970
movl $0x0, 0x1d4(%rsp)
movl $0x0, 0x1d0(%rsp)
leaq 0x228(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x9100
movq %rax, 0x20(%rsp)
jmp 0xa2a5
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x9880
movb %al, 0x1f(%rsp)
jmp 0xa2bf
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xa2cc
jmp 0xa410
leaq 0x200(%rsp), %rdi
callq 0xb7b0
movl $0x10, %edi
movl $0x8, %esi
callq 0xb7d0
movl %eax, 0x18(%rsp)
jmp 0xa2ee
movl 0x18(%rsp), %edx
leaq 0x48(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x9b20
jmp 0xa306
movl 0x1d4(%rsp), %eax
cmpl 0x434(%rsp), %eax
jl 0xa3f0
movl 0x1d4(%rsp), %eax
cmpl 0x430(%rsp), %eax
jge 0xa3ee
jmp 0xa330
leaq 0x48(%rsp), %rdi
leaq 0x1d8(%rsp), %rsi
callq 0x9540
movq %rax, 0x10(%rsp)
jmp 0xa349
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x9880
movb %al, 0xf(%rsp)
jmp 0xa363
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa36d
jmp 0xa3d8
leaq 0x200(%rsp), %rdi
leaq 0x1d8(%rsp), %rsi
callq 0xb7f0
jmp 0xa384
jmp 0xa330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x220(%rsp)
movl %eax, 0x21c(%rsp)
jmp 0xa488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x220(%rsp)
movl %eax, 0x21c(%rsp)
jmp 0xa43e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x220(%rsp)
movl %eax, 0x21c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x9460
jmp 0xa43e
movq 0x28(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0xb860
jmp 0xa3ec
jmp 0xa3ee
jmp 0xa3f0
movl 0x1d4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1d4(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x9460
jmp 0xa289
movb $0x1, 0x21b(%rsp)
leaq 0x1e0(%rsp), %rdi
callq 0x9390
leaq 0x200(%rsp), %rdi
callq 0xb8d0
testb $0x1, 0x21b(%rsp)
jne 0xa46e
jmp 0xa464
leaq 0x1e0(%rsp), %rdi
callq 0x9390
leaq 0x200(%rsp), %rdi
callq 0xb8d0
movq 0x28(%rsp), %rdi
callq 0xb930
jmp 0xa488
movq 0x28(%rsp), %rdi
callq 0xb930
leaq 0x228(%rsp), %rdi
callq 0x9170
movq 0x30(%rsp), %rax
addq $0x448, %rsp            # imm = 0x448
retq
leaq 0x228(%rsp), %rdi
callq 0x9170
movq 0x220(%rsp), %rdi
callq 0x9c80
nopw %cs:(%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateConfig(DICE*)
void allocateConfig(DICE *dice)
{
    // Allocate the configuration structure----------------------------------------------------

  dice->config.nPeriods = 100;	// Number of time steps
  dice->config.tstep = 5.0;	// Number of years per time step
  dice->config.startYear = 2015;	// Model start year	
  dice->config.dateSeries = new double[dice->config.nPeriods];	// Human-readable year

	if(dice->ctrl.use_doeclim == 1) {
	  dice->config.hind_ns = 116; // Number of hindcast timesteps (1900 - 2010)
  	dice->config.i1900 = 0;  // Index of year 1900
  	dice->config.dt = 1;
  	dice->config.ns = dice->config.hind_ns+(dice->config.tstep*(dice->config.nPeriods-1)); // 1-yr res.
  	dice->config.n_calpoints = 100;
  }

  return;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl $0x64, (%rax)
movq (%rsp), %rax
movsd 0x9875(%rip), %xmm0     # 0x1c160
movsd %xmm0, 0x8(%rax)
movq (%rsp), %rax
movl $0x7df, 0x10(%rax)      # imm = 0x7DF
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
cmpl $0x1, 0x58(%rax)
jne 0x12996
movq (%rsp), %rax
movl $0x74, 0x20(%rax)
movq (%rsp), %rax
movl $0x0, 0x2c(%rax)
movq (%rsp), %rax
movl $0x1, 0x24(%rax)
movq (%rsp), %rax
cvtsi2sdl 0x20(%rax), %xmm1
movq (%rsp), %rax
movsd 0x8(%rax), %xmm0
movq (%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq (%rsp), %rax
movl %ecx, 0x28(%rax)
movq (%rsp), %rax
movl $0x64, 0x30(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateCarb(DICE*)
void allocateCarb(DICE *dice)
{

  dice->carb.forcoth = new double[dice->config.nPeriods];	// Exogenous forcing for other GHG
  dice->carb.forc = new double[dice->config.nPeriods];		// Increase in radiative forcing [Wm-2 from 1900]
  dice->carb.mat = new double[dice->config.nPeriods];		// Carbon concentration increase in atmosphere [GtC from 1750]
  dice->carb.mu = new double[dice->config.nPeriods];		// Carbon concentration increase in shallow oceans [GtC from 1750]
  dice->carb.ml = new double[dice->config.nPeriods];		// Carbon concentration increase in lower oceans [GtC from 1750]
  
  dice->carb.atfrac = new double[dice->config.nPeriods];
  dice->carb.atfrac2010 = new double[dice->config.nPeriods];
  dice->carb.ppm = new double[dice->config.nPeriods];


  return;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x468(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x470(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x478(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x480(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x488(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x490(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x498(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x4a0(%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateLims(DICE*)
void allocateLims(DICE *dice)
{
  dice->lims.k_lo = 1.0;
  dice->lims.mat_lo = 10.0;
  dice->lims.mu_lo = 100.0;
  dice->lims.ml_lo = 1000.0;
  dice->lims.c_lo = 2.0;
  dice->lims.tocean_up = 20.0;
  dice->lims.tocean_lo = -1.0;
  dice->lims.tatm_lo = 0.0;
  dice->lims.tatm_up = 40.0;
  dice->lims.cpc_lo = 0.01;
  dice->lims.y_lo = 0.0;
  dice->lims.ygross_lo = 0.0;
  dice->lims.i_lo = 0.0;
  dice->lims.miu_up = new double[dice->config.nPeriods];	// Upper limit of control policy for each time period

}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movsd 0x8837(%rip), %xmm0     # 0x1c008
movsd %xmm0, 0x4b0(%rax)
movq (%rsp), %rax
movsd 0x89bb(%rip), %xmm0     # 0x1c1a0
movsd %xmm0, 0x4b8(%rax)
movq (%rsp), %rax
movsd 0x899f(%rip), %xmm0     # 0x1c198
movsd %xmm0, 0x4c0(%rax)
movq (%rsp), %rax
movsd 0x8983(%rip), %xmm0     # 0x1c190
movsd %xmm0, 0x4c8(%rax)
movq (%rsp), %rax
movsd 0x8967(%rip), %xmm0     # 0x1c188
movsd %xmm0, 0x4d0(%rax)
movq (%rsp), %rax
movsd 0x894b(%rip), %xmm0     # 0x1c180
movsd %xmm0, 0x4d8(%rax)
movq (%rsp), %rax
movsd 0x892f(%rip), %xmm0     # 0x1c178
movsd %xmm0, 0x4e0(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x4e8(%rax)
movq (%rsp), %rax
movsd 0x8904(%rip), %xmm0     # 0x1c170
movsd %xmm0, 0x4f0(%rax)
movq (%rsp), %rax
movsd 0x88e8(%rip), %xmm0     # 0x1c168
movsd %xmm0, 0x4f8(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x500(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x508(%rax)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x510(%rax)
movq (%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x9030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x528(%rax)
popq %rax
retq
nopl (%rax)
// File: JRLamontagne[P]cdice_sa/CDICEInit.cpp
// Function: allocateDICE(DICE*)
void allocateDICE(DICE *dice)
{
	allocateCtrl(dice);
	allocateConfig(dice);
	allocateCarb(dice);
	allocateEcon(dice);
	allocateDvars(dice);
	allocateLims(dice);
	allocateClim(dice);
	
	if(dice->ctrl.use_doeclim == 1) {	
  	doeclim_load_calibration(dice, dice->config.n_calpoints);
  }

	return;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x129a0
movq (%rsp), %rdi
callq 0x128d0
movq (%rsp), %rdi
callq 0x129c0
movq (%rsp), %rdi
callq 0x12ed0
movq (%rsp), %rdi
callq 0x13750
movq (%rsp), %rdi
callq 0x137c0
movq (%rsp), %rdi
callq 0x12b80
movq (%rsp), %rax
cmpl $0x1, 0x58(%rax)
jne 0x14b5e
movq (%rsp), %rdi
movq (%rsp), %rax
movl 0x30(%rax), %esi
callq 0x1b0e0
popq %rax
retq
// File: JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: calcCarb1(DICE*)
void calcCarb1(DICE *dice)
{

  Carb *carb = &dice->carb;
  Lims *lims = &dice->lims;
  
  // Carbon pools
  carb->mat[0] = carb->mat0;
  if(carb->mat[0] < lims->mat_lo) {
    carb->mat[0] = lims->mat_lo;
  }
  
  carb->mu[0] = carb->mu0;
  if(carb->mu[0] < lims->mu_lo) {
    carb->mu[0] = lims->mu_lo;
  }

  carb->ml[0] = carb->ml0;
  if(carb->ml[0] < lims->ml_lo) {
    carb->ml[0] = lims->ml_lo;
  }

  // Radiative forcing
  carb->forc[0] = carb->fco22x*(log(carb->mat[0]/588.000)/log(2.0))+carb->forcoth[0];
  
  return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x3e0, %rax            # imm = 0x3E0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movsd (%rax), %xmm1
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15eac
movq 0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movsd (%rax), %xmm1
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15f00
movq 0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movsd (%rax), %xmm1
movq 0x10(%rsp), %rax
movsd 0x20(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15f54
movq 0x10(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
movsd 0x68(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rax
movsd (%rax), %xmm0
movsd 0x6254(%rip), %xmm1     # 0x1c1d0
divsd %xmm1, %xmm0
callq 0x9510
movsd %xmm0, (%rsp)
movsd 0x61f6(%rip), %xmm0     # 0x1c188
callq 0x9510
movsd (%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm2
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movsd %xmm0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: calcClim1(DICE*)
void calcClim1(DICE *dice)
{
  Clim *clim = &dice->clim;
  Lims *lims = &dice->lims;

  // Atmospheric temperature
  clim->tatm[0] = clim->tatm0;
  if(clim->tatm[0] < lims->tatm_lo) {
    clim->tatm[0] = lims->tatm_lo;
  }
  if(clim->tatm[0] > lims->tatm_up) {
    clim->tatm[0] = lims->tatm_up;
  }
  
  // Oceanic temperature
  clim->tocean[0] = clim->tocean0;
  if(clim->tocean[0] < lims->tocean_lo) {
    clim->tocean[0] = lims->tocean_lo;
  }
  if(clim->tocean[0] > lims->tocean_up) {
    clim->tocean[0] = lims->tocean_up;
  }
  
  return;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x60, %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
addq $0x4a8, %rax            # imm = 0x4A8
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movsd (%rax), %xmm1
movq -0x18(%rsp), %rax
movsd 0x40(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x16057
movq -0x18(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
ucomisd 0x48(%rax), %xmm0
jbe 0x1608d
movq -0x18(%rsp), %rax
movsd 0x48(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0xc8(%rax), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movsd (%rax), %xmm1
movq -0x18(%rsp), %rax
movsd 0x38(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x160e1
movq -0x18(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
ucomisd 0x30(%rax), %xmm0
jbe 0x16117
movq -0x18(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq -0x10(%rsp), %rax
movq 0xd0(%rax), %rax
movsd %xmm0, (%rax)
retq
nopl (%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICE.cpp
// Function: processModel(DICE*)
void processModel(DICE *dice)
{
	
  // Calculate exogenous time series
  calcExog(dice);
  
   // Calculate the first time step of carbon model
  calcCarb1(dice);

  // Calculate the first time step of climate model
  if(dice->ctrl.use_doeclim == 1) {
    doeclim_hindcast(dice);
  }
  else {
    calcClim1(dice);
  }
  
  // Calculate the first time step of economic model
  calcEcon1(dice);
  
  // Calculate the rest of the time series
  for (int tIndex=1; tIndex<dice->config.nPeriods; tIndex++)
    {
      calcCarb(dice, tIndex);

      if(dice->ctrl.use_doeclim == 1) {
				doeclim_dice_ts(dice, tIndex);
    	}
      else {
				calcClim(dice, tIndex);
      }

      calcEcon(dice, tIndex);
    }
  
  // Do the post-processing
  postProcess(dice);
  
  return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15740
movq 0x10(%rsp), %rdi
callq 0x15e30
movq 0x10(%rsp), %rax
cmpl $0x1, 0x58(%rax)
jne 0x17fb4
movq 0x10(%rsp), %rdi
callq 0x1aa50
jmp 0x17fbe
movq 0x10(%rsp), %rdi
callq 0x15fe0
movq 0x10(%rsp), %rdi
callq 0x16120
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1802f
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x167e0
movq 0x10(%rsp), %rax
cmpl $0x1, 0x58(%rax)
jne 0x18006
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1ac20
jmp 0x18014
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x16b20
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x16e20
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17fd0
movq 0x10(%rsp), %rdi
callq 0x179f0
addq $0x18, %rsp
retq
nop
// File: JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: count_lines(char const*, int*)
void count_lines(const char *filename, int *numlines)
{
	int ch;	
	*numlines = 0;
	FILE * fp = fopen(filename, "r");
	
	do {
		ch = fgetc(fp);
		if(ch == '\n') { *numlines = *numlines + 1; }
	} while (ch != EOF);

//	if(ch != '\n' && *numlines != 0) 
//    *numlines = *numlines + 1;

	fclose(fp);
	
	return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movq 0x20(%rsp), %rdi
leaq 0x427b(%rip), %rsi      # 0x1c2e0
callq 0x97d0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x9af0
movl %eax, 0x14(%rsp)
cmpl $0xa, 0x14(%rsp)
jne 0x18095
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x18097
cmpl $-0x1, 0x14(%rsp)
jne 0x1806f
movq 0x8(%rsp), %rdi
callq 0x9670
addq $0x28, %rsp
retq
nopl (%rax)
// File: JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: invert_1d_2x2_matrix(double*, double*)
void invert_1d_2x2_matrix(double * x, double * y)
{
  double temp_d = (x[0]*x[3] - x[1]*x[2]);
  if(temp_d == 0) {
    fprintf(stderr, "Matrix inversion divide by zero. Aborting...\n");
    exit(EXIT_FAILURE);
  }
  double temp = 1/temp_d;
  y[0] = temp * x[3];
  y[1] = temp * -1 * x[1];
  y[2] = temp * -1 * x[2];
  y[3] = temp * x[0];

  return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm2
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x20(%rsp), %rax
mulsd 0x10(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1813d
jp 0x1813d
movq 0xaeb6(%rip), %rax      # 0x22fd8
movq (%rax), %rdi
leaq 0x41b6(%rip), %rsi      # 0x1c2e2
movb $0x0, %al
callq 0x9a20
movl $0x1, %edi
callq 0x9810
movsd 0x3ec3(%rip), %xmm0     # 0x1c008
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
mulsd 0x18(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x4006(%rip), %xmm0     # 0x1c178
mulsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
mulsd 0x8(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x3fe4(%rip), %xmm0     # 0x1c178
mulsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
mulsd 0x10(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
mulsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_DICE_init(DICE*)
void doeclim_DICE_init(DICE *dice)
{
  Clim *clim = &dice->clim;
  Config *config = &dice->config;
/*
  for(int i=0; i<clim->ns; i++) {
    clim->Ker[i] = 0.0;
    clim->temp[i] = 0.0;
    clim->temp_landair[i] = 0.0;
    clim->temp_sst[i] = 0.0;
    clim->heat_mixed[i] = 0.0;
    clim->heat_interior[i] = 0.0;
    clim->heatflux_mixed[i] = 0.0;
    clim->heatflux_interior[i] = 0.0;
    clim->forc[i] = 0.0;
  }
  for(int i=0; i<4; i++) {
		clim->IB[i] = 0.0;
    clim->A[i] = 0.0;
  }
*/
  // Initialize the doeclim model
  doeclim_init(clim->t2co, clim->kappa, config->dt, config->ns,
		 &clim->flnd, &clim->powtoheat, &clim->cal, &clim->cas,
		 &clim->taucfl, &clim->taukls, &clim->taucfs, &clim->tauksl,
		 &clim->bsi, clim->IB, clim->A, &clim->fso, &clim->taudif,
		 clim->Ker);
  
  // Run the hindcast
  //doeclim_hindcast(dice);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x68(%rsp), %rax
movsd 0x40(%rax), %xmm1
movq 0x60(%rsp), %rax
movl 0x24(%rax), %edi
movq 0x60(%rsp), %rax
movl 0x28(%rax), %esi
movq 0x68(%rsp), %rdx
addq $0x58, %rdx
movq 0x68(%rsp), %rcx
addq $0x60, %rcx
movq 0x68(%rsp), %r8
addq $0x68, %r8
movq 0x68(%rsp), %r9
addq $0x70, %r9
movq 0x68(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rbp
addq $0x80, %rbp
movq 0x68(%rsp), %r13
addq $0x88, %r13
movq 0x68(%rsp), %r12
addq $0x90, %r12
movq 0x68(%rsp), %r15
addq $0x98, %r15
movq 0x68(%rsp), %rax
movq 0xa0(%rax), %r14
movq 0x68(%rsp), %rax
movq 0xa8(%rax), %rbx
movq 0x68(%rsp), %r11
addq $0xb0, %r11
movq 0x68(%rsp), %r10
addq $0xb8, %r10
movq 0x68(%rsp), %rax
movq 0xc0(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rax
movq %rbp, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x18c50
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_hindcast(DICE*)
void doeclim_hindcast(DICE *dice)
{
  Clim *clim = &dice->clim;
  Config *config = &dice->config;
  
  for(int t=0; t<config->hind_ns; t++) {
    
    doeclim_ts(t, config->dt, config->ns, clim->forc, 
            clim->flnd, clim->powtoheat, clim->cal, clim->cas,
            clim->taucfl, clim->taukls, clim->taucfs, clim->tauksl,
            clim->bsi, clim->IB, clim->A, clim->fso,
            clim->taudif, clim->Ker, clim->temp, clim->temp_landair, clim->temp_sst, 
            clim->heat_mixed, clim->heat_interior, 
            clim->heatflux_mixed, clim->heatflux_interior);
  }
		
  // Index (config->hind_ns - 1) should now contain the initial values
  // of temperature and for running CDICE.

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq 0x68(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x1ac00
movl 0x64(%rsp), %edi
movq 0x68(%rsp), %rax
movl 0x24(%rax), %esi
movq 0x68(%rsp), %rax
movl 0x28(%rax), %edx
movq 0x70(%rsp), %rax
movq 0x50(%rax), %rcx
movq 0x70(%rsp), %rax
movsd 0x58(%rax), %xmm0
movq 0x70(%rsp), %rax
movsd 0x60(%rax), %xmm1
movq 0x70(%rsp), %rax
movsd 0x68(%rax), %xmm2
movq 0x70(%rsp), %rax
movsd 0x70(%rax), %xmm3
movq 0x70(%rsp), %rax
movsd 0x78(%rax), %xmm4
movq 0x70(%rsp), %rax
movsd 0x80(%rax), %xmm5
movq 0x70(%rsp), %rax
movsd 0x88(%rax), %xmm6
movq 0x70(%rsp), %rax
movsd 0x90(%rax), %xmm7
movq 0x70(%rsp), %rax
movsd 0x98(%rax), %xmm10
movq 0x70(%rsp), %rax
movq 0xa0(%rax), %r8
movq 0x70(%rsp), %rax
movq 0xa8(%rax), %r9
movq 0x70(%rsp), %rax
movsd 0xb0(%rax), %xmm9
movq 0x70(%rsp), %rax
movsd 0xb8(%rax), %xmm8
movq 0x70(%rsp), %rax
movq 0xc0(%rax), %r13
movq 0x70(%rsp), %rax
movq 0xe0(%rax), %r12
movq 0x70(%rsp), %rax
movq 0xe8(%rax), %r15
movq 0x70(%rsp), %rax
movq 0xf0(%rax), %r14
movq 0x70(%rsp), %rax
movq 0xf8(%rax), %rbx
movq 0x70(%rsp), %rax
movq 0x100(%rax), %r11
movq 0x70(%rsp), %rax
movq 0x108(%rax), %r10
movq 0x70(%rsp), %rax
movq 0x110(%rax), %rax
movsd %xmm10, (%rsp)
movsd %xmm9, 0x8(%rsp)
movsd %xmm8, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movq %r11, 0x40(%rsp)
movq %r10, 0x48(%rsp)
movq %rax, 0x50(%rsp)
callq 0x18230
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x1aa85
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
// File: JRLamontagne[P]cdice_sa/CDICE_doeclim.cpp
// Function: doeclim_load_hind_forc(DICE*)
void doeclim_load_hind_forc(DICE *dice)
{

  FILE * fp;
  fp = fopen("./giss_forc_component_1900_2015_extrap.txt", "r");

  int counter = 0;
  float temp_forc;
	float yr, ghg, o3, sh2o, refa, aie, bc, snow, stra, solar, land;
  while(!feof(fp)) {
    if (fscanf(fp, "%g %g %g %g %g %g %g %g %g %g %g", &yr, &ghg, &o3, &sh2o, &refa, &aie, &bc, &snow, &stra, &solar, &land) != 11) { break; }

    temp_forc = ghg + o3 + sh2o + stra + solar + land + (dice->clim.alpha * (refa + aie + bc + snow));

    dice->clim.forc[counter] = double(temp_forc);
    counter++;
    if (counter >= dice->config.hind_ns) {
      break;
    }
  }
  fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
leaq 0x13a3(%rip), %rdi      # 0x1c310
leaq 0x136c(%rip), %rsi      # 0x1c2e0
callq 0x97d0
movq %rax, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movq 0x78(%rsp), %rdi
callq 0x9aa0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1afa1
jmp 0x1b0c3
movq 0x78(%rsp), %rdi
leaq 0x138e(%rip), %rsi      # 0x1c33b
leaq 0x6c(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x64(%rsp), %r8
leaq 0x60(%rsp), %r9
leaq 0x5c(%rsp), %r12
leaq 0x58(%rsp), %r15
leaq 0x54(%rsp), %r14
leaq 0x50(%rsp), %rbx
leaq 0x4c(%rsp), %r11
leaq 0x48(%rsp), %r10
leaq 0x44(%rsp), %rax
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movb $0x0, %al
callq 0x9d20
cmpl $0xb, %eax
je 0x1b017
jmp 0x1b0c3
movss 0x68(%rsp), %xmm0
addss 0x64(%rsp), %xmm0
addss 0x60(%rsp), %xmm0
addss 0x4c(%rsp), %xmm0
addss 0x48(%rsp), %xmm0
addss 0x44(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movq 0x80(%rsp), %rax
movsd 0xa8(%rax), %xmm0
movss 0x5c(%rsp), %xmm2
addss 0x58(%rsp), %xmm2
addss 0x54(%rsp), %xmm2
addss 0x50(%rsp), %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x70(%rsp)
movss 0x70(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x80(%rsp), %rax
movq 0xb0(%rax), %rax
movslq 0x74(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x80(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jl 0x1b0be
jmp 0x1b0c3
jmp 0x1af86
movq 0x78(%rsp), %rdi
callq 0x9670
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)