LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateIntArray
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count)
{
    size_t i = 0;
    cJSON *n = NULL;
    cJSON *p = NULL;
    cJSON *a = NULL;

    if ((count < 0) || (numbers == NULL))
    {
        return NULL;
    }

    a = cJSON_CreateArray();

    for(i = 0; a && (i < (size_t)count); i++)
    {
        n = cJSON_CreateNumber(numbers[i]);
        if (!n)
        {
            cJSON_Delete(a);
            return NULL;
        }
        if(!i)
        {
            a->child = n;
        }
        else
        {
            suffix_object(p, n);
        }
        p = n;
    }

    if (a && a->child) {
        a->child->prev = n;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x297e0
movl %esi, %ebp
movq %rdi, %r14
callq 0x29448
movq %rax, %rbx
movl %ebp, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x297c4
cmpq %r15, %r12
jae 0x297c4
cvtsi2sdl (%r14,%r12,4), %xmm0
callq 0x2921b
testq %rax, %rax
je 0x297d8
testq %r12, %r12
je 0x297b8
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x297bc
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
jmp 0x2978f
testq %rbx, %rbx
je 0x297e0
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x297e2
movq %r13, 0x8(%rax)
jmp 0x297e2
movq %rbx, %rdi
callq 0x27f56
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateFloatArray
CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count)
{
    size_t i = 0;
    cJSON *n = NULL;
    cJSON *p = NULL;
    cJSON *a = NULL;

    if ((count < 0) || (numbers == NULL))
    {
        return NULL;
    }

    a = cJSON_CreateArray();

    for(i = 0; a && (i < (size_t)count); i++)
    {
        n = cJSON_CreateNumber((double)numbers[i]);
        if(!n)
        {
            cJSON_Delete(a);
            return NULL;
        }
        if(!i)
        {
            a->child = n;
        }
        else
        {
            suffix_object(p, n);
        }
        p = n;
    }

    if (a && a->child) {
        a->child->prev = n;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x29875
movl %esi, %ebp
movq %rdi, %r14
callq 0x29448
movq %rax, %rbx
movl %ebp, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x29859
cmpq %r15, %r12
jae 0x29859
cvtss2sd (%r14,%r12,4), %xmm0
callq 0x2921b
testq %rax, %rax
je 0x2986d
testq %r12, %r12
je 0x2984d
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x29851
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
jmp 0x29824
testq %rbx, %rbx
je 0x29875
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x29877
movq %r13, 0x8(%rax)
jmp 0x29877
movq %rbx, %rdi
callq 0x27f56
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateStringArray
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count)
{
    size_t i = 0;
    cJSON *n = NULL;
    cJSON *p = NULL;
    cJSON *a = NULL;

    if ((count < 0) || (strings == NULL))
    {
        return NULL;
    }

    a = cJSON_CreateArray();

    for (i = 0; a && (i < (size_t)count); i++)
    {
        n = cJSON_CreateString(strings[i]);
        if(!n)
        {
            cJSON_Delete(a);
            return NULL;
        }
        if(!i)
        {
            a->child = n;
        }
        else
        {
            suffix_object(p,n);
        }
        p = n;
    }

    if (a && a->child) {
        a->child->prev = n;
    }

    return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x2999d
movl %esi, %ebp
movq %rdi, %r14
callq 0x29448
movq %rax, %rbx
movl %ebp, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %rbx, %rbx
je 0x29981
cmpq %r15, %r12
jae 0x29981
movq (%r14,%r12,8), %rdi
callq 0x292bf
testq %rax, %rax
je 0x29995
testq %r12, %r12
je 0x29975
movq %rax, (%r13)
movq %r13, 0x8(%rax)
jmp 0x29979
movq %rax, 0x10(%rbx)
incq %r12
movq %rax, %r13
jmp 0x2994e
testq %rbx, %rbx
je 0x2999d
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x2999f
movq %r13, 0x8(%rax)
jmp 0x2999f
movq %rbx, %rdi
callq 0x27f56
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_Minify
CJSON_PUBLIC(void) cJSON_Minify(char *json)
{
    char *into = json;

    if (json == NULL)
    {
        return;
    }

    while (json[0] != '\0')
    {
        switch (json[0])
        {
            case ' ':
            case '\t':
            case '\r':
            case '\n':
                json++;
                break;

            case '/':
                if (json[1] == '/')
                {
                    skip_oneline_comment(&json);
                }
                else if (json[1] == '*')
                {
                    skip_multiline_comment(&json);
                } else {
                    json++;
                }
                break;

            case '\"':
                minify_string(&json, (char**)&into);
                break;

            default:
                into[0] = json[0];
                json++;
                into++;
        }
    }

    /* and null-terminate. */
    *into = '\0';
}

// Assembly:
testq %rdi, %rdi
je 0x29b99
movabsq $0x100002600, %rax      # imm = 0x100002600
movq %rdi, %rcx
movq %rdi, %rdx
movzbl (%rdi), %esi
cmpq $0x2f, %rsi
ja 0x29b0c
btq %rsi, %rax
jae 0x29ad6
incq %rdx
movq %rdx, %rdi
jmp 0x29abc
cmpq $0x22, %rsi
je 0x29b22
cmpq $0x2f, %rsi
jne 0x29b0c
movzbl 0x1(%rdx), %esi
cmpl $0x2a, %esi
je 0x29b5f
leaq 0x1(%rdx), %rdi
cmpl $0x2f, %esi
jne 0x29abc
addq $0x2, %rdx
movq %rdx, %rdi
movzbl (%rdi), %edx
testl %edx, %edx
je 0x29abc
incq %rdi
cmpl $0xa, %edx
jne 0x29afb
jmp 0x29abc
testl %esi, %esi
je 0x29b96
movb %sil, (%rcx)
incq %rdx
incq %rcx
movq %rdx, %rdi
jmp 0x29abc
movq %rdx, %rdi
movb $0x22, (%rcx)
addq $0x2, %rdi
incq %rcx
movb -0x1(%rdi), %dl
testb %dl, %dl
je 0x29b57
movb %dl, (%rcx)
movzbl -0x1(%rdi), %edx
cmpl $0x5c, %edx
je 0x29b48
cmpl $0x22, %edx
jne 0x29b4d
jmp 0x29b82
cmpb $0x22, (%rdi)
je 0x29b52
incq %rdi
jmp 0x29b2c
incq %rcx
jmp 0x29b25
decq %rdi
jmp 0x29abc
addq $0x2, %rdx
movq %rdx, %rdi
movzbl (%rdi), %edx
cmpl $0x2a, %edx
je 0x29b77
testl %edx, %edx
jne 0x29b7d
jmp 0x29abc
cmpb $0x2f, 0x1(%rdi)
je 0x29b8d
incq %rdi
jmp 0x29b66
movb $0x22, (%rcx)
incq %rcx
jmp 0x29abc
addq $0x2, %rdi
jmp 0x29abc
movb $0x0, (%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: parse_hex4(unsigned char const*)
static unsigned parse_hex4(const unsigned char * const input)
{
    unsigned int h = 0;
    size_t i = 0;

    for (i = 0; i < 4; i++)
    {
        /* parse digit */
        if ((input[i] >= '0') && (input[i] <= '9'))
        {
            h += (unsigned int) input[i] - '0';
        }
        else if ((input[i] >= 'A') && (input[i] <= 'F'))
        {
            h += (unsigned int) 10 + input[i] - 'A';
        }
        else if ((input[i] >= 'a') && (input[i] <= 'f'))
        {
            h += (unsigned int) 10 + input[i] - 'a';
        }
        else /* invalid */
        {
            return 0;
        }

        if (i < 3)
        {
            /* shift left to make place for the next nibble */
            h = h << 4;
        }
    }

    return h;
}

// Assembly:
xorl %eax, %eax
pushq $-0x4
popq %rcx
pushq $-0x30
popq %rdx
pushq $-0x37
popq %rsi
pushq $-0x57
popq %r8
testq %rcx, %rcx
je 0x2a124
movzbl 0x4(%rdi,%rcx), %r9d
leal -0x30(%r9), %r11d
movl %edx, %r10d
cmpb $0xa, %r11b
jb 0x2a10d
leal -0x41(%r9), %r11d
movl %esi, %r10d
cmpb $0x6, %r11b
jb 0x2a10d
leal -0x61(%r9), %r11d
movl %r8d, %r10d
cmpb $0x5, %r11b
ja 0x2a122
addl %eax, %r10d
addl %r9d, %r10d
movl %r10d, %eax
shll $0x4, %eax
incq %rcx
cmovel %r10d, %eax
jmp 0x2a0db
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/agorenst[P]trie/prefixtree.cpp
// Function: main
int main(int argc, char* argv[]) {
    string line;
    prefix_tree<int> t;
    while (cin) {
        getline(cin, line);
        istringstream int_parser(line);
        int x;
        vector<int> int_stream;
        while (!int_parser.eof()) {
            int_parser >> x;
            int_stream.push_back(x);
        }
        t.insert(int_stream.rbegin(), int_stream.rend());
    }
    cout << 
"\\documentclass{standalone}\
\\usepackage{tikz}\
\\begin{document}\
\\usetikzlibrary{graphdrawing,graphdrawing.trees}\
\\begin{tikzpicture}\\begin{scope}[tree layout]";
    t.tikz_print(cout);
    cout <<
"\\end{scope}\
\\end{tikzpicture}\
\\end{document}";
    cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x25c0
movq 0x2cb0(%rip), %rbx      # 0x4fe0
leaq -0x88(%rbp), %r14
leaq -0x208(%rbp), %r15
leaq -0x64(%rbp), %r13
leaq -0x50(%rbp), %r12
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x23e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movq %r15, %rdi
movq %r14, %rsi
pushq $0x8
popq %rdx
callq 0x2190
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1e8(%rbp,%rax)
jne 0x23aa
movq %r15, %rdi
movq %r13, %rsi
callq 0x20c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2490
jmp 0x237d
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x24b6
movq %r12, %rdi
callq 0x27e0
movq %r15, %rdi
callq 0x2090
jmp 0x2346
movq 0x2be9(%rip), %rdi      # 0x4fd0
leaq 0xc32(%rip), %rsi       # 0x3020
callq 0x2110
movq 0x2bd6(%rip), %rsi      # 0x4fd0
leaq -0x38(%rbp), %rdi
callq 0x24e0
movq 0x2bc6(%rip), %rdi      # 0x4fd0
leaq 0xca8(%rip), %rsi       # 0x30b9
callq 0x2110
movq 0x2bb3(%rip), %rdi      # 0x4fd0
callq 0x20a0
leaq -0x30(%rbp), %rdi
callq 0x2522
leaq -0x88(%rbp), %rdi
callq 0x2080
xorl %eax, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x247c
jmp 0x2456
jmp 0x245b
jmp 0x2456
movq %rax, %rbx
jmp 0x2473
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x27e0
leaq -0x208(%rbp), %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2522
leaq -0x88(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/agorenst[P]trie/./prefixtree.h
// Function: void prefix_tree<int>::node::insert<std::reverse_iterator<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>>(std::reverse_iterator<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>, std::reverse_iterator<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>)
void insert(Iter b, Iter e) {
            if (b == e) { return; } // we are the end of this input
    
            auto symb = *b++; // we advance b, having read from it.
            // we need to make a new child!
            if (edges.find(symb) == edges.end()) {
                edges[symb] = std::make_shared<node>();
            }
    
            // recursive call.
            edges[symb]->insert(b, e);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %rax
cmpq (%rdx), %rax
je 0x29d4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x4(%rax), %rcx
movq %rcx, (%rsi)
movl -0x4(%rax), %eax
leaq -0x1c(%rbp), %rsi
movl %eax, (%rsi)
callq 0x2a46
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
jne 0x29ac
leaq -0x30(%rbp), %rdi
callq 0x25c0
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x29f4
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x2d28
leaq -0x28(%rbp), %rdi
callq 0x2522
leaq -0x1c(%rbp), %rsi
movq %r15, %rdi
callq 0x29f4
movq (%rax), %rdi
movq (%r14), %rax
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movq (%rbx), %rax
leaq -0x38(%rbp), %rdx
movq %rax, (%rdx)
callq 0x2946
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2522
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/agorenst[P]trie/./prefixtree.h
// Function: prefix_tree<int>::node::tikz_print(std::ostream&)
void tikz_print(std::ostream& o) {
            o << "node[circle, draw]{}" << std::endl;
            for (auto it = edges.begin(); it != edges.end(); ++it) {
                o << "child {" << std::endl;
                it->second->tikz_print(o);
                o << "edge from parent node[left]{" << it->first << "}" << std::endl;
                o << "}" << std::endl;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x385(%rip), %rsi       # 0x3102
movq %rbx, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20a0
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x383(%rip), %r13       # 0x311f
leaq 0x33f(%rip), %r15       # 0x30e2
cmpq %r14, %r12
je 0x2e17
movq %rbx, %rdi
leaq 0x365(%rip), %rsi       # 0x3117
callq 0x2110
movq %rax, %rdi
callq 0x20a0
movq 0x28(%r12), %rdi
movq %rbx, %rsi
callq 0x2d62
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2110
movl 0x20(%r12), %esi
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x20a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x20a0
movq %r12, %rdi
callq 0x20d0
movq %rax, %r12
jmp 0x2da3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::operator()(int) const
const double& Vector::operator()(int i) const
{

  if (i < 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mSize)
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }


  return mData[i-1];

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testl %esi, %esi
jle 0x1f0f
cmpl %esi, 0x8(%rdi)
jl 0x1f75
movq (%rdi), %rax
movl %esi, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x72bc(%rip), %rsi      # 0x91dd
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1060
leaq 0x72b3(%rip), %rsi      # 0x91ea
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xbe3c(%rip), %rsi      # 0xdda0
leaq 0x80f(%rip), %rdx       # 0x277a
movq %rbx, %rdi
callq 0x1150
jmp 0x1fd9
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x71ad(%rip), %rsi      # 0x9134
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1060
leaq 0x727b(%rip), %rsi      # 0x9218
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xbdd6(%rip), %rsi      # 0xdda0
leaq 0x7a9(%rip), %rdx       # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1070
jmp 0x1fee
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
jmp 0x200f
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x1070
jmp 0x200a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x2020
jmp 0x2028
jmp 0x201d
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: linspace(double, double, int)
Vector linspace(double start, double end, int points)
{
  Vector out(points);
  double len = end - start;
  double interval = (len*1.0)/(points-1);
  out(1) = start;
  out(points) = end;
  for (int i=2;i<points;i++)
  {
      out(i) = start + ((i-1)*interval);
  }
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x186c
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1ee2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1ee2
movsd 0x10(%rsp), %xmm1
movapd %xmm1, %xmm2
leal -0x1(%r14), %ecx
cvtsi2sd %ecx, %xmm0
subsd 0x8(%rsp), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, (%rax)
pushq $0x2
popq %r15
cmpl %r14d, %r15d
jge 0x2258
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1ee2
leal -0x1(%r15), %ecx
cvtsi2sd %ecx, %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incl %r15d
jmp 0x222b
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2267
movq %rax, %r14
movq %rbx, %rdi
callq 0x1908
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: reshape(Vector&, int, int)
Matrix reshape(Vector& u, int rows, int cols)
{
  if (length(u) != rows*cols)
	{
		  throw Exception("dimension mismatch",
			  "number of elements in vector not equal to entries in output matrix");
	}

  Matrix out(rows,cols);
  int count =1;
  for (int j = 1;j<=cols;j++)
  {
    for (int i = 1; i<=rows; i++)
    {
        out(i,j) = u(count);
        count++;
    }
  }
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %eax
imull %edx, %eax
cmpl %eax, 0x8(%rsi)
jne 0x2335
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl %edx, %esi
movl %ecx, %edx
callq 0x285c
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
testl %r13d, %r13d
cmovlel %r14d, %r13d
incl %r13d
movl %ebp, 0x8(%rsp)
negl %ebp
pushq $0x1
popq %r12
movl %r13d, 0xc(%rsp)
cmpl %r13d, %r12d
je 0x2323
pushq $0x1
popq %rax
movl %eax, %r13d
leal (%rbp,%r13), %eax
cmpl $0x1, %eax
je 0x2314
leal (%r14,%r13), %esi
movq %r15, %rdi
callq 0x1ee2
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x4b12
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
incl %r13d
jmp 0x22d7
incl %r12d
addl 0x8(%rsp), %r14d
movl 0xc(%rsp), %r13d
jmp 0x22cc
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x6f01(%rip), %rsi      # 0x9248
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x6efe(%rip), %rsi      # 0x925b
leaq 0x18(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xba16(%rip), %rsi      # 0xdda0
leaq 0x3e9(%rip), %rdx       # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x1070
jmp 0x23ae
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x23c2
jmp 0x23d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
jmp 0x23d7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a78
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: ones(int)
Vector ones(int length)
{
    Vector out(length);
    for (int i = 1; i<=length;i++)
    {
      out(i) = 1;
    }
    return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x186c
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
negl %r15d
pushq $0x1
popq %r14
movabsq $0x3ff0000000000000, %r12 # imm = 0x3FF0000000000000
leal (%r15,%r14), %eax
cmpl $0x1, %eax
je 0x2427
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1ee2
movq %r12, (%rax)
incl %r14d
jmp 0x240b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1908
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::getValues(int, int) const
Vector Vector::getValues(int i,int j) const
{
	int l = j-i+1;
	Vector splice(l);
	for (int k = 1; k<=l; k++)
	{
		splice.mData[k-1] = mData[k-1];
	}
	return splice;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rsi, %r15
movq %rdi, %r14
subl %edx, %ebx
incl %ebx
movl %ebx, %esi
callq 0x186c
movq (%r15), %rax
movq (%r14), %rcx
xorl %edx, %edx
testl %ebx, %ebx
cmovlel %edx, %ebx
cmpq %rdx, %rbx
je 0x247f
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
jmp 0x246b
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::setValues(int, int, Vector) const
void Vector::setValues(int istart, int iend, Vector v) const
{
	if (istart < 1 || iend < 1)
		{
		  throw Exception("out of range",
			  "accessing vector through () - index too small");
		}
	else if (iend > mSize || istart > mSize)
		{
		  throw Exception("length mismatch",
			  "accessing vector through () - index too high");
		}

		int l = iend - istart + 1;
		for (int i = 0; i<l; i++)
		{
			mData[istart -1 + i] = v(i+1);
		}


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testl %esi, %esi
jle 0x2505
testl %edx, %edx
jle 0x2505
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl %edx, %eax
jl 0x256b
cmpl %esi, %eax
jl 0x256b
movq %rcx, %rbx
subl %esi, %edx
movslq %edx, %r12
movl %esi, %eax
leaq -0x8(,%rax,8), %r13
xorl %ebp, %ebp
cmpq %r12, %rbp
jg 0x24f3
leaq 0x1(%rbp), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1ee2
movsd (%rax), %xmm0
movq (%r14), %rax
addq %r13, %rax
movsd %xmm0, (%rax,%rbp,8)
movq %r15, %rbp
jmp 0x24cb
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x6cc6(%rip), %rsi      # 0x91dd
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x6cbd(%rip), %rsi      # 0x91ea
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xb846(%rip), %rsi      # 0xdda0
leaq 0x219(%rip), %rdx       # 0x277a
movq %rbx, %rdi
callq 0x1150
jmp 0x25cf
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x6bb7(%rip), %rsi      # 0x9134
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x6c85(%rip), %rsi      # 0x9218
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xb7e0(%rip), %rsi      # 0xdda0
leaq 0x1b3(%rip), %rdx       # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1070
jmp 0x25e4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
jmp 0x2605
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x1070
jmp 0x2600
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x2616
jmp 0x261e
jmp 0x2613
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Vector.cpp
// Function: Vector::setValue(int, int) const
void Vector::setValue(int loc, int set) const
{
	if (loc < 1)
		{
		  throw Exception("out of range",
			  "accessing vector through () - index too small");
		}
	else if (loc > mSize)
		{
		  throw Exception("length mismatch",
			  "accessing vector through () - index too high");
		}

			mData[loc-1] = set;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testl %esi, %esi
jle 0x2659
cmpl %esi, 0x8(%rdi)
jl 0x26bf
cvtsi2sd %edx, %xmm0
movq (%rdi), %rax
movl %esi, %ecx
movsd %xmm0, -0x8(%rax,%rcx,8)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x6b72(%rip), %rsi      # 0x91dd
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1060
leaq 0x6b69(%rip), %rsi      # 0x91ea
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xb6f2(%rip), %rsi      # 0xdda0
leaq 0xc5(%rip), %rdx        # 0x277a
movq %rbx, %rdi
callq 0x1150
jmp 0x2723
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x6a63(%rip), %rsi      # 0x9134
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1060
leaq 0x6b31(%rip), %rsi      # 0x9218
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xb68c(%rip), %rsi      # 0xdda0
leaq 0x5f(%rip), %rdx        # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1070
jmp 0x2738
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
jmp 0x2759
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x1070
jmp 0x2754
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x276a
jmp 0x2772
jmp 0x2767
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix(int i, int j)
{
	mRows = i;
	mColumns = j;
	mElements = new double*[i];

	for (int k = 0; k<i; k++)
	{
		mElements[k]= new double[j];
		for (int l = 0; l<j; l++)
		{
			mElements[k][l] = 0;
		}
	}
	// std::cout<<"constructor called\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %esi, %edi
shlq $0x3, %rdi
xorl %ebp, %ebp
testl %esi, %esi
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
cmovlel %ebp, %r14d
callq 0x1030
movq %rax, %r12
movq %rax, (%r15)
movl %ebx, %r13d
shlq $0x3, %r13
testl %ebx, %ebx
pushq $-0x1
popq %rax
cmovsq %rax, %r13
cmovlel %ebp, %ebx
cmpq %r14, %rbp
je 0x28d6
movq %r13, %rdi
callq 0x1030
movq %rax, (%r12,%rbp,8)
movq (%r15), %r12
xorl %eax, %eax
cmpq %rax, %rbx
je 0x28d1
movq (%r12,%rbp,8), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x28be
incq %rbp
jmp 0x28a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::Matrix(int, int, std::initializer_list<double>)
Matrix::Matrix(int i, int j, std::initializer_list<double> entries)
{

	mRows = i;
	mColumns = j;
	mElements = new double*[i];
	int count = 0;
	int len = entries.size();
	for (int k = 0; k<i; k++)
	{
		mElements[k]= new double[j];
		for (int l = 0; l<j; l++)
		{
			if (count<len){ mElements[k][l] = entries.begin()[count];}
			else {mElements[k][l] = 0.0;}
			count+=1;
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movl %edx, %r14d
movq %rdi, %r12
movl %esi, 0x8(%rdi)
movl %edx, 0xc(%rdi)
movl %esi, %edi
shlq $0x3, %rdi
xorl %ebx, %ebx
testl %esi, %esi
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
cmovlel %ebx, %esi
movq %rsi, 0x20(%rsp)
callq 0x1030
movq %rax, %r13
movq %r12, 0x10(%rsp)
movq %rax, (%r12)
movl %r14d, %ebp
shlq $0x3, %rbp
testl %r14d, %r14d
cmovsq %r15, %rbp
movslq 0x8(%rsp), %r12
cmovlel %ebx, %r14d
xorl %r15d, %r15d
cmpq 0x20(%rsp), %rbx
je 0x29a3
movq %rbp, %rdi
callq 0x1030
movq %rax, (%r13,%rbx,8)
movq 0x10(%rsp), %rax
movq (%rax), %r13
movslq %r15d, %rax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,8), %rcx
xorl %edx, %edx
leaq (%rax,%rdx), %r15
cmpq %rdx, %r14
je 0x299e
xorps %xmm0, %xmm0
cmpq %r12, %r15
jge 0x298f
movsd (%rcx,%rdx,8), %xmm0
movq (%r13,%rbx,8), %rsi
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x2979
incq %rbx
jmp 0x294f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& original)
{
  mRows = original.mRows;
  mColumns = original.mColumns;
  mElements= new double*[mRows];
  for (int k = 0; k<mRows; k++)
  {
	  mElements[k]= new double[mColumns];
  }
  for (int k = 0; k<mRows; k++)
  {
	  for (int l = 0; l<mColumns; l++)
	  {
		  mElements[k][l] = original.mElements[k][l];
	  }
  }
	// std::cout<<"copy constructor called\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x8(%rsi), %r13
leaq (,%r13,8), %rdi
testq %r13, %r13
movl %r13d, 0x8(%r14)
movslq 0xc(%rsi), %rbp
movl %ebp, 0xc(%r14)
pushq $-0x1
popq %r12
cmovsq %r12, %rdi
callq 0x1030
leaq (,%rbp,8), %r15
movq %rbp, (%rsp)
testq %rbp, %rbp
movq %rax, (%r14)
cmovsq %r12, %r15
xorl %ebp, %ebp
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
cmpq %rbp, %r12
je 0x2a29
movq %r15, %rdi
callq 0x1030
movq (%r14), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
jmp 0x2a10
xorl %eax, %eax
movq (%rsp), %rdx
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %r12, %rax
je 0x2a69
movq (%rbx), %rdx
movq (%r14), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x2a64
movq (%rdx,%rax,8), %r8
movsd (%r8,%rdi,8), %xmm0
movq (%rsi,%rax,8), %r8
movsd %xmm0, (%r8,%rdi,8)
incq %rdi
jmp 0x2a46
incq %rax
jmp 0x2a39
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream& operator<<(std::ostream& output, const Matrix& A)
{
	for (int i=0; i<A.mRows; i++)
	{
		output << "[ ";
		for (int j = 0; j<A.mColumns; j++)
			{
				output <<  A.mElements[i][j];
				if (j != A.mColumns-1)
					output  << "  ";
				else
					output  << " ]";
			}
		output << "\n";
	}
	  return output;  // for multiple << operators.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x6816(%rip), %rbp      # 0x9306
leaq 0x680c(%rip), %r15      # 0x9303
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x2b61
movq %rbx, %rdi
leaq 0x67f6(%rip), %rsi      # 0x9300
callq 0x10e0
xorl %r12d, %r12d
movslq 0xc(%r14), %rax
cmpq %rax, %r12
jge 0x2b4d
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %rbx, %rdi
callq 0x1130
movl 0xc(%r14), %eax
decl %eax
cmpq %rax, %r12
movq %r15, %rsi
cmoveq %rbp, %rsi
movq %rbx, %rdi
callq 0x10e0
incq %r12
jmp 0x2b12
movq %rbx, %rdi
leaq 0x6773(%rip), %rsi      # 0x92ca
callq 0x10e0
incq %r13
jmp 0x2af7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::getElements(int, int, int, int)
Matrix Matrix:: getElements(int istart, int iend, int jstart, int jend)
{
	if (istart < 1 || jstart < 1 || iend < 1 || jend < 1)
	    {
	      throw Exception("out of range",
			  "accessing vector through () - index too small");
	    }
	  else if (iend > mRows || jend > mColumns || istart > mRows || jstart > mColumns)
	    {
	      throw Exception("length mismatch",
			  "accessing vector through () - index too high");
	    }

	int sRows = iend - istart + 1; int sColumns = jend - jstart + 1;
	Matrix slice(sRows, sColumns);
	for (int i = 0; i<sRows; i++)
	{
		for (int j = 0; j<sColumns; j++)
		{
			slice.mElements[i][j] = mElements[istart -1 + i][jstart -1 + j];
		}
	}
	return slice;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
testl %r9d, %r9d
jle 0x2ce2
movl %ecx, %r13d
testl %ecx, %ecx
jle 0x2ce2
movl %edx, %r12d
testl %edx, %edx
jle 0x2ce2
movl %r8d, %ebp
testl %r8d, %r8d
jle 0x2ce2
movq %rsi, %r14
movl 0x8(%rsi), %eax
cmpl %r13d, %eax
jl 0x2c7c
movl 0xc(%r14), %ecx
cmpl %ebp, %ecx
jl 0x2c7c
cmpl %r12d, %eax
jb 0x2c7c
movl %r9d, %r15d
cmpl %r9d, %ecx
jl 0x2c7c
movq %rdi, %rbx
subl %r12d, %r13d
leal 0x1(%r13), %esi
subl %ebp, %r15d
leal 0x1(%r15), %edx
callq 0x285c
movq (%rbx), %rax
movslq %r15d, %rcx
movslq %r13d, %rdx
movl %r12d, %esi
movl %ebp, %edi
leaq -0x8(,%rdi,8), %rdi
xorl %r8d, %r8d
cmpq %rdx, %r8
jg 0x2c67
leaq (,%r8,8), %r9
addq (%r14), %r9
xorl %r10d, %r10d
cmpq %rcx, %r10
jg 0x2c62
movq -0x8(%r9,%rsi,8), %r11
addq %rdi, %r11
movsd (%r11,%r10,8), %xmm0
movq (%rax,%r8,8), %r11
movsd %xmm0, (%r11,%r10,8)
incq %r10
jmp 0x2c40
incq %r8
jmp 0x2c2d
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x64a6(%rip), %rsi      # 0x9134
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x6574(%rip), %rsi      # 0x9218
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xb0cf(%rip), %rsi      # 0xdda0
leaq -0x55e(%rip), %rdx      # 0x277a
movq %rbx, %rdi
callq 0x1150
jmp 0x2d46
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x64e9(%rip), %rsi      # 0x91dd
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x64e0(%rip), %rsi      # 0x91ea
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xb069(%rip), %rsi      # 0xdda0
leaq -0x5c4(%rip), %rdx      # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x1070
jmp 0x2d5b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
jmp 0x2d7c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x1070
jmp 0x2d77
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x2d8d
jmp 0x2d95
jmp 0x2d8a
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1180
nop
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator*(double, Matrix const&)
Matrix operator*(double c, const Matrix& A)
{
	Matrix ans(A.mRows, A.mColumns);
	for (int i=0; i<A.mRows; i++)
	{
		for (int j=0; j< A.mColumns; j++)
		{
			ans.mElements[i][j] = c * A.mElements[i][j];
		}
	}
	return ans;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd %xmm0, (%rsp)
movq %rdi, %r14
movl 0x8(%rsi), %esi
movl 0xc(%rbx), %edx
callq 0x285c
movsd (%rsp), %xmm1
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movq (%r14), %rsi
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rax, %rdx
je 0x3752
movq (%rbx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x374d
movq (%rdi,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm0
mulsd %xmm1, %xmm0
movq (%rsi,%rdx,8), %r9
movsd %xmm0, (%r9,%r8,8)
incq %r8
jmp 0x372b
incq %rdx
jmp 0x3720
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator*(Matrix const&, Vector const&)
Vector operator*(const Matrix& A, const Vector& v)
{
	if (A.mColumns!=length(v)) { throw Exception("Dimensions mismatch",
			  "cannot perform matrix-vector multiplication");}
	Vector ans(A.mRows);
	for (int i= 0;i<A.mRows;i++)
		{
			for (int j = 0; j<A.mColumns; j++)
			{
				ans(i+1) += A(i+1,j+1)*v(j+1);
			}
		}
	return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0xc(%rsi), %ebp
movq %rdx, %rdi
callq 0x2141
cmpl %eax, %ebp
jne 0x3970
movl 0x8(%r15), %esi
movq %rbx, %rdi
callq 0x186c
xorl %ebp, %ebp
pushq $0x1
popq %r13
cmpl 0x8(%r15), %ebp
jge 0x395e
incl %ebp
movl %r13d, %r12d
leal -0x1(%r12), %eax
cmpl 0xc(%r15), %eax
jge 0x38f9
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x3a1a
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl %r12d, %esi
callq 0x1ee2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2030
movsd 0x10(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
incl %r12d
jmp 0x3904
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x5abc(%rip), %rsi      # 0x943e
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x5adf(%rip), %rsi      # 0x9477
leaq 0x18(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xa3db(%rip), %rsi      # 0xdda0
leaq -0x1252(%rip), %rdx     # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x1070
jmp 0x39e9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x39fd
jmp 0x3a12
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
jmp 0x3a12
movq %rax, %r14
movq %rbx, %rdi
callq 0x1908
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: Matrix::operator()(int, int) const
const double& Matrix::operator()(int i, int j) const // 'const' because then can be used in the body of other functions which take const arguments
{

  if (i < 1 || j < 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mRows || j > mColumns)
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }

  return mElements[i-1][j-1];

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
testl %esi, %esi
jle 0x3a5f
testl %edx, %edx
jle 0x3a5f
cmpl %esi, 0x8(%rdi)
jl 0x3ac5
cmpl %edx, 0xc(%rdi)
jl 0x3ac5
movq (%rdi), %rax
movl %esi, %ecx
movq -0x8(%rax,%rcx,8), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x576c(%rip), %rsi      # 0x91dd
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1060
leaq 0x5763(%rip), %rsi      # 0x91ea
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xa2ec(%rip), %rsi      # 0xdda0
leaq -0x1341(%rip), %rdx     # 0x277a
movq %rbx, %rdi
callq 0x1150
jmp 0x3b29
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x565d(%rip), %rsi      # 0x9134
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1060
leaq 0x572b(%rip), %rsi      # 0x9218
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xa286(%rip), %rsi      # 0xdda0
leaq -0x13a7(%rip), %rdx     # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x1070
jmp 0x3b3e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
jmp 0x3b5f
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x1070
jmp 0x3b5a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x3b70
jmp 0x3b78
jmp 0x3b6d
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator*(Vector const&, Matrix const&)
Vector operator*(const Vector& v, const Matrix& A)
{
	if (A.mRows!=length(v)) { throw Exception("Dimensions mismatch",
			  "cannot perform vector-matrix multiplication");}
	Vector ans(A.mColumns);
	for (int i= 0;i<A.mColumns;i++)
		{
			for (int j = 0; j<A.mRows; j++)
			{
				ans(i+1) += A(i+1,j+1)*v(j+1);
			}
		}
	return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %ebp
movq %rsi, %rdi
callq 0x2141
cmpl %eax, %ebp
jne 0x3c33
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x186c
xorl %ebp, %ebp
pushq $0x1
popq %r13
cmpl 0xc(%r14), %ebp
jge 0x3c21
incl %ebp
movl %r13d, %r12d
leal -0x1(%r12), %eax
cmpl 0x8(%r14), %eax
jge 0x3bbc
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x3a1a
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x1ee2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2030
movsd 0x10(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
incl %r12d
jmp 0x3bc7
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %rbx
leaq 0x57f9(%rip), %rsi      # 0x943e
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x5848(%rip), %rsi      # 0x94a3
leaq 0x18(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0xa118(%rip), %rsi      # 0xdda0
leaq -0x1515(%rip), %rdx     # 0x277a
movq %rbx, %rdi
callq 0x1150
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x1070
jmp 0x3cac
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x3cc0
jmp 0x3cd5
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
jmp 0x3cd5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1908
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator/(Matrix const&, Vector const&)
Vector operator/(const Matrix& A, const Vector& b)
{
	boost::tuple<Matrix, Matrix, Matrix> LUP = LU(A);
	Matrix L = LUP.get<0>();
	Matrix U = LUP.get<1>();
	Matrix P = LUP.get<2>();
	Vector newb = P*b;
	Vector y = forwardsubst(L,newb);
	Vector x = backsubst(U,y);
	return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x3e05
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x29b2
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x29b2
leaq 0x70(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x29b2
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x38bd
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x44c6
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x46e5
movq %rsp, %rdi
callq 0x1908
leaq 0x10(%rsp), %rdi
callq 0x1908
leaq 0x20(%rsp), %rdi
callq 0x2a78
leaq 0x30(%rsp), %rdi
callq 0x2a78
leaq 0x40(%rsp), %rdi
callq 0x2a78
leaq 0x50(%rsp), %rdi
callq 0x8bc6
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1908
jmp 0x3db7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1908
jmp 0x3dc6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2a78
jmp 0x3dd5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2a78
jmp 0x3de4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2a78
leaq 0x50(%rsp), %rdi
callq 0x8bc6
movq %rbx, %rdi
callq 0x1180
movq %rax, %rbx
jmp 0x3dee
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: forwardsubst(Matrix const&, Vector const&)
Vector forwardsubst(const Matrix& A, const Vector& b)
{
	int n = length(b);
	Vector x(n);
	for (int i=1;i<=n;i++)
	{
		if (A(i,i)==0)
		{
			throw Exception("Singular Matrix",
									  "no solution to equation as coefficient matrix is singular");
		}
		x(i) = b(i);
		for (int j = 1; j<=(i-1); j++)
		{
			x(i) = x(i) - A(i,j)*x(j);
		}
		x(i) = x(i)/A(i,i);
	}
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rdx, %rdi
callq 0x2141
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x186c
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
incl %ebp
pushq $0x1
popq %r12
cmpl %ebp, %r12d
je 0x4627
movq %r15, %rdi
movl %r12d, %esi
movl %r12d, %edx
callq 0x3a1a
movsd (%rax), %xmm0
ucomisd 0x4dab(%rip), %xmm0     # 0x92d0
jne 0x452d
jnp 0x4639
movq 0x18(%rsp), %rdi
movl %r12d, %esi
callq 0x1ee2
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2030
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
pushq $0x1
popq %rax
movl %eax, %r13d
leal (%r14,%r13), %eax
cmpl $0x1, %eax
je 0x45d4
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2030
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x3a1a
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2030
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2030
movsd 0x10(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
incl %r13d
jmp 0x455f
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2030
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %r12d, %esi
movl %r12d, %edx
callq 0x3a1a
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2030
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
incl %r12d
decl %r14d
jmp 0x4502
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x40
popq %rdi
callq 0x1080
movq %rax, %r14
leaq 0x4ef1(%rip), %rsi      # 0x953c
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1060
leaq 0x4eeb(%rip), %rsi      # 0x954c
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1060
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x2790
xorl %ebp, %ebp
leaq 0x9712(%rip), %rsi      # 0xdda0
leaq -0x1f1b(%rip), %rdx     # 0x277a
movq %r14, %rdi
callq 0x1150
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x1070
jmp 0x46b2
movq %rax, %r15
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x1070
testb %bpl, %bpl
jne 0x46c6
jmp 0x46d5
movq %rax, %r15
movq %r14, %rdi
callq 0x10b0
jmp 0x46d5
jmp 0x46d2
movq %rax, %r15
movq %rbx, %rdi
callq 0x1908
movq %r15, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator!(Matrix const&)
Matrix operator!(const Matrix& A)
{
	Matrix T(A.mColumns, A.mRows);
	for (int i=0;i<A.mRows; i++)
	{
		for (int j=0; j<A.mColumns; j++)
		{
			T(j+1,i+1) = A.mElements[i][j];
		}
	}
	return T;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %esi
callq 0x285c
xorl %r12d, %r12d
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jge 0x4b88
leaq 0x1(%r12), %r15
xorl %r13d, %r13d
movslq 0xc(%r14), %rax
cmpq %rax, %r13
jge 0x4b83
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
leal 0x1(%r13), %esi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x3a1a
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
jmp 0x4b49
movq %r15, %r12
jmp 0x4b38
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2a78
movq %r14, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/IlanPrice[P]Linear-Algebra-Library-in-Cplusplus/Matrix.cpp
// Function: operator-(Matrix const&)
Matrix operator-(const Matrix& A)
{
  Matrix ans(A.mRows, A.mColumns);

  for (int i=0; i<A.mRows; i++)
  {
	  for (int j=0; j< A.mColumns; j++)
	  {
		  ans.mElements[i][j] = -A.mElements[i][j];
	  }
  }
  return ans;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r14), %edx
callq 0x285c
movl 0x8(%r14), %eax
movl 0xc(%r14), %ecx
movq (%rbx), %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
testl %eax, %eax
cmovlel %esi, %eax
movaps 0x4460(%rip), %xmm0     # 0x9040
cmpq %rax, %rsi
je 0x4c10
movq (%r14), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x4c0b
movq (%rdi,%rsi,8), %r9
movsd (%r9,%r8,8), %xmm1
xorps %xmm0, %xmm1
movq (%rdx,%rsi,8), %r9
movlps %xmm1, (%r9,%r8,8)
incq %r8
jmp 0x4beb
incq %rsi
jmp 0x4be0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop