LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: GodOfProgramming[P]cspec/src/evaluation.cpp
// Function: cspec::Evaluation::Run()
void Evaluation::Run()
  {
    std::sort(Tests->begin(), Tests->end(), [](Evaluation* a, Evaluation* b) -> bool {
      return strcmp(a->Name, b->Name) < 0;
    });

    cspec::print("Running ", Tests->size(), " evaluations\n");
    for (auto& test : *Tests) {
      cspec::print('\n', "Evaluating: ", "\x1b[35m", test->Name);
      std::cout << std::endl;
      test->body();
    }
  }

// Assembly:
subq $0xa8, %rsp
movq 0xc2a2(%rip), %rdi      # 0x33fc0
callq 0x1c3a0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x1b6c0
movq 0xc286(%rip), %rdi      # 0x33fc0
callq 0x1c3a0
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
callq 0x1c430
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x27e40
movq 0xc25b(%rip), %rdi      # 0x33fc0
callq 0x1c3a0
movq %rax, %rdi
callq 0x1bdb0
movq %rax, 0x58(%rsp)
leaq 0x4282(%rip), %rdi      # 0x2c000
leaq 0x58(%rsp), %rsi
leaq 0x4465(%rip), %rdx      # 0x2c1ef
callq 0x1b7e0
movq 0xc22a(%rip), %rdi      # 0x33fc0
callq 0x1ad80
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1b6c0
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1c430
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b860
testb $0x1, %al
jne 0x27dd3
jmp 0x27e37
leaq 0x30(%rsp), %rdi
callq 0x1aef0
movq %rax, 0x8(%rsp)
movb $0xa, 0x7(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
leaq 0x7(%rsp), %rdi
leaq 0x43fe(%rip), %rsi      # 0x2c1fd
leaq 0x4404(%rip), %rdx      # 0x2c20a
callq 0x1a2a0
movq 0xc18e(%rip), %rdi      # 0x33fa0
movq 0xc11f(%rip), %rsi      # 0x33f38
callq 0x1b500
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x30(%rsp), %rdi
callq 0x1bd00
jmp 0x27dbe
addq $0xa8, %rsp
retq
nop
// File: greenpau[P]mnpa/main.cpp
// Function: ipv4_from_s_addr[abi:cxx11](unsigned long)
std::string ipv4_from_s_addr(unsigned long saddr) {
    char ipv4[MAX];
    // The htonl() function converts the unsigned integer hostlong
    // from host byte order to network byte order.
    // The converted value remains unsigned long
    unsigned long ip = htonl(saddr);
    sprintf(ipv4, "%lu.%lu.%lu.%lu", (ip >> 24) & 0xFF, (ip >> 16) & 0xFF, (ip >> 8) & 0xFF, ip & 0xFF);
    return string(ipv4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, -0x158(%rbp)
movq %rdi, %rax
movq %rax, -0x160(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x167f0
movl %eax, %eax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movl %eax, %ebx
movl %ebx, %ecx
shrl $0x18, %ecx
movl %ecx, %edx
movl %ebx, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
movb %bh, %bl
movzbl %bl, %esi
movl %esi, %r8d
movzbl %al, %eax
movl %eax, %r9d
leaq 0xe8b11(%rip), %rsi     # 0x102174
xorl %eax, %eax
leaq -0x120(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x16420
leaq -0x129(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x54db0
movq -0x158(%rbp), %rdi
movq -0x150(%rbp), %rsi
movq -0x148(%rbp), %rdx
callq 0x235f0
jmp 0x196a7
leaq -0x129(%rbp), %rdi
callq 0x54dd0
movq -0x160(%rbp), %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x129(%rbp), %rdi
callq 0x54dd0
movq -0x138(%rbp), %rdi
callq 0xfeff0
nop
// File: greenpau[P]mnpa/main.cpp
// Function: logit(severity, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void logit(severity lvl, std::string s) {
    if (VERBOSE == 0) return;
    std::lock_guard<std::mutex> guard(mu_cout);
    switch(lvl) {
        case INFO  : printf("[INFO] %s\n", s.c_str()); break;
        case WARN  : printf("[WARN] %s\n", s.c_str()); break;
        case ERROR : fprintf(stderr, "[ERROR] %s\n", s.c_str()); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x142d86(%rip)    # 0x15c490
jne 0x19711
jmp 0x197c9
leaq 0x143300(%rip), %rsi    # 0x15ca18
leaq -0x18(%rbp), %rdi
callq 0x236a0
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x19741
jmp 0x1972d
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x19776
jmp 0x19737
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x19794
jmp 0x197c0
movq -0x30(%rbp), %rdi
callq 0xd0eb0
movq %rax, %rsi
leaq 0xe8a30(%rip), %rdi     # 0x102184
xorl %eax, %eax
callq 0x160a0
jmp 0x1975d
jmp 0x197c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x236d0
jmp 0x197cf
movq -0x30(%rbp), %rdi
callq 0xd0eb0
movq %rax, %rsi
leaq 0xe8a06(%rip), %rdi     # 0x10218f
xorl %eax, %eax
callq 0x160a0
jmp 0x19792
jmp 0x197c0
movq -0x30(%rbp), %rdi
movq 0x1426f9(%rip), %rax    # 0x15be98
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0xd0eb0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0xe89e1(%rip), %rsi     # 0x10219a
movb $0x0, %al
callq 0x16840
leaq -0x18(%rbp), %rdi
callq 0x236d0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfeff0
nopl (%rax,%rax)
// File: greenpau[P]mnpa/main.cpp
// Function: fill_pkt_payload()
void fill_pkt_payload() {
    std::uniform_int_distribution<> distr(32, 126);
    int i = 0;
    while ( i < MAX_PAYLOAD_SIZE) {
        rand_pkt_payload[i] = static_cast<char>(distr(eng));
        i++;
    }
    //logit(INFO, pktpld);
    //exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
movl $0x20, %esi
movl $0x7e, %edx
callq 0x23700
movl $0x0, -0xc(%rbp)
cmpl $0x7d0, -0xc(%rbp)      # imm = 0x7D0
jge 0x19836
leaq -0x8(%rbp), %rdi
leaq 0x144e42(%rip), %rsi    # 0x15e658
callq 0x23730
movb %al, %dl
movslq -0xc(%rbp), %rcx
leaq 0x1432d8(%rip), %rax    # 0x15cb00
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19802
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: greenpau[P]mnpa/main.cpp
// Function: signal_handler(int)
void signal_handler(int id) {
    if (stopped == true) {
        logit(INFO, "process termination is already in progress. be patient ...");
    } else {
        logit(INFO, "terminated by signal id #" + std::to_string(id));
        stopped = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movb 0x14218d(%rip), %al     # 0x15ca11
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1a90c
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x54db0
movq -0x88(%rbp), %rdx
leaq 0xe81d5(%rip), %rsi     # 0x102a81
leaq -0x28(%rbp), %rdi
callq 0x235f0
jmp 0x1a8b7
xorl %edi, %edi
leaq -0x28(%rbp), %rsi
callq 0x196f0
jmp 0x1a8c4
leaq -0x28(%rbp), %rdi
callq 0xcf470
leaq -0x29(%rbp), %rdi
callq 0x54dd0
jmp 0x1a98e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1a8fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcf470
leaq -0x29(%rbp), %rdi
callq 0x54dd0
jmp 0x1a997
movl -0x4(%rbp), %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x23760
movq -0x90(%rbp), %rdx
leaq 0xe818f(%rip), %rsi     # 0x102abc
leaq -0x60(%rbp), %rdi
callq 0x23c90
jmp 0x1a938
xorl %edi, %edi
leaq -0x60(%rbp), %rsi
callq 0x196f0
jmp 0x1a945
leaq -0x60(%rbp), %rdi
callq 0xcf470
leaq -0x80(%rbp), %rdi
callq 0xcf470
movb $0x1, 0x1420b3(%rip)    # 0x15ca11
jmp 0x1a98e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1a983
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xcf470
leaq -0x80(%rbp), %rdi
callq 0xcf470
jmp 0x1a997
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xfeff0
// File: greenpau[P]mnpa/main.cpp
// Function: format_t[abi:cxx11](unsigned long long)
std::string format_t(unsigned long long n) {
    std::string s;
    int i = 0;
    do {
        s.insert(0, 1, char('0' + n % 10));
        n /= 10;
        if (++i == 3 && n) {
            s.insert(0, 1, ',');
            i = 0;
        }
    } while (n);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xcf360
movl $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
movq %rcx, %rax
mulq %rdx
shrq $0x3, %rdx
addl %edx, %edx
movl %edx, %eax
leal (%rax,%rax,4), %eax
subl %eax, %ecx
orl $0x30, %ecx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xcff10
jmp 0x1aa03
movq -0x10(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x3, %eax
jne 0x1aa63
cmpq $0x0, -0x10(%rbp)
je 0x1aa63
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
movl $0x2c, %ecx
callq 0xcff10
jmp 0x1aa43
movl $0x0, -0x18(%rbp)
jmp 0x1aa63
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xcf470
jmp 0x1aa8d
jmp 0x1aa65
cmpq $0x0, -0x10(%rbp)
jne 0x1a9cb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1aa83
movq -0x38(%rbp), %rdi
callq 0xcf470
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfeff0
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khashlmpp/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	klib::KHashMap<uint32_t, int, 6, aux_hash> h;
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t k;
		int absent;
		x = hash32(x);
		k = h.put(get_key(n, x), &absent);
		if (absent) h.value(k) = 0;
		z += ++h.value(k);
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", (long)h.size(), z);
	return h.size();
}

// Assembly:
subq $0x678, %rsp            # imm = 0x678
movl %edi, 0x674(%rsp)
movl %esi, 0x670(%rsp)
movl $0x0, 0x664(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x17b0
movl $0x0, 0x66c(%rsp)
movl 0x670(%rsp), %eax
movl %eax, 0x668(%rsp)
movl 0x66c(%rsp), %eax
cmpl 0x674(%rsp), %eax
jae 0x16f8
movl 0x668(%rsp), %edi
callq 0x1250
movl %eax, 0x44(%rsp)
jmp 0x1619
movl 0x44(%rsp), %eax
movl %eax, 0x668(%rsp)
movl 0x674(%rsp), %edi
movl 0x668(%rsp), %esi
callq 0x12c0
movl %eax, 0x40(%rsp)
jmp 0x163d
movl 0x40(%rsp), %eax
movl %eax, 0x48(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x17c0
movq %rax, 0x38(%rsp)
jmp 0x1660
movq 0x38(%rsp), %rax
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x58(%rsp)
je 0x16b1
movl 0x5c(%rsp), %eax
movl %eax, %esi
leaq 0x60(%rsp), %rdi
callq 0x1800
movq %rax, 0x30(%rsp)
jmp 0x1687
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
jmp 0x16b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x18a0
jmp 0x1767
movl 0x5c(%rsp), %eax
movl %eax, %esi
leaq 0x60(%rsp), %rdi
callq 0x1800
movq %rax, 0x28(%rsp)
jmp 0x16c8
movq 0x28(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0x664(%rsp), %eax
movl %eax, 0x664(%rsp)
movl 0x66c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x66c(%rsp)
jmp 0x15f3
movq 0x38e1(%rip), %rax      # 0x4fe0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1830
movq %rax, 0x20(%rsp)
jmp 0x1718
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rdi
movl 0x664(%rsp), %ecx
leaq 0x1945(%rip), %rsi      # 0x3075
xorl %eax, %eax
callq 0x10a0
leaq 0x60(%rsp), %rdi
callq 0x1830
movq %rax, 0x10(%rsp)
jmp 0x1748
movq 0x10(%rsp), %rax
movl %eax, 0xc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x18a0
movl 0xc(%rsp), %eax
addq $0x678, %rsp            # imm = 0x678
retq
movq 0x50(%rsp), %rdi
callq 0x10d0
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khashlmpp/./khashlm.hpp
// Function: klib::KHashSet<klib::KHashMapBucket<unsigned int, int>, 6, klib::KHashMapHash<klib::KHashMapBucket<unsigned int, int>, aux_hash, unsigned int>, klib::KHashMapEq<klib::KHashMapBucket<unsigned int, int>, std::equal_to<unsigned int>>, unsigned int>::put(klib::KHashMapBucket<unsigned int, int> const&, int*)
uint64_t put(const T &key, int *absent) {
		uint64_t hash = kh_base_hash(Hash()(key));
		khint_t pre = get_pre(hash);
		khint_t k = h[pre].put(key, hash, absent, pre_len);
		return (uint64_t)k << pre_len | pre;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
leaq 0x17(%rsp), %rdi
callq 0x1aa0
movl %eax, %eax
movl %eax, %edi
callq 0x1780
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1ad0
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x6, %r8d
callq 0x1ae0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shlq $0x6, %rax
movl 0x10(%rsp), %ecx
orq %rcx, %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::Matrix(unsigned int, unsigned int, double)
Matrix::Matrix(unsigned rowSize, unsigned colSize, double initial) {
    rows = rowSize;
    cols = colSize;
    data.resize(rowSize);
    for (unsigned i = 0; i < data.size(); i++) {
        data[i].resize(colSize, initial);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x4e90
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4eb0
jmp 0x259b
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %eax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x4f40
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x260b
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdx
callq 0x4f90
jmp 0x25e7
jmp 0x25e9
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x25a2
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5040
jmp 0x2611
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::Matrix(std::vector<double, std::allocator<double>>)
Matrix::Matrix(vector<double> array) {
    this->cols = 1;
    this->rows = array.size();
    this->data.resize(rows);
    for (unsigned i = 0; i < data.size(); i++) {
        data[i].resize(cols, array[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x4e90
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl $0x1, 0x4(%rax)
callq 0x5400
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl (%rax), %eax
movl %eax, %esi
callq 0x4eb0
jmp 0x2c35
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x4f40
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2cc4
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x50(%rbp)
movl 0x4(%rax), %eax
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5190
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x4f90
jmp 0x2ca0
jmp 0x2ca2
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2c3c
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5040
jmp 0x2cca
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::operator+(Matrix&)
Matrix Matrix::operator+(Matrix &B) {
    Matrix sum(rows, cols, 0.0);
    //sum.print();
    if ((this->rows != B.getRows()) || (this->cols != B.getCols())) {
        return "Error";
    }
    unsigned i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            sum(i, j) = data[i][j] + B(i, j);
        }
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
leaq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2550
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bd0
movl %eax, -0x54(%rbp)
jmp 0x2d72
movl -0x58(%rbp), %eax
movl -0x54(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2d9e
movq -0x60(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bb0
movl %eax, -0x74(%rbp)
jmp 0x2d94
movl -0x78(%rbp), %eax
movl -0x74(%rbp), %ecx
cmpl %ecx, %eax
je 0x2dd6
movq -0x70(%rbp), %rdi
leaq 0xa2bf(%rip), %rsi      # 0xd068
callq 0x2650
jmp 0x2db0
movl $0x1, -0x48(%rbp)
jmp 0x2ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5420
jmp 0x2ed8
movl $0x0, -0x4c(%rbp)
movq -0x60(%rbp), %rcx
movl -0x4c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x2eac
movl $0x0, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movl -0x50(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x2e9c
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2ef0
movq %rax, -0x80(%rbp)
jmp 0x2e45
movsd -0x88(%rbp), %xmm0
movq -0x80(%rbp), %rax
movsd (%rax), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2ef0
movq %rax, -0x90(%rbp)
jmp 0x2e7b
movq -0x90(%rbp), %rax
movsd -0x98(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x2df3
jmp 0x2e9e
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x2ddd
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2b20
jmp 0x2ebb
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5420
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::operator-(Matrix&)
Matrix Matrix::operator-(Matrix &B) {
    Matrix diff(rows, cols, 0.0);
    if ((this->rows != B.getRows()) || (this->cols != B.getCols())) {
        return "Error";
    }
    unsigned i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            diff(i, j) = this->data[i][j] - B(i, j);
        }
    }

    return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
leaq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2550
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bd0
movl %eax, -0x54(%rbp)
jmp 0x2f82
movl -0x58(%rbp), %eax
movl -0x54(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2fae
movq -0x60(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bb0
movl %eax, -0x74(%rbp)
jmp 0x2fa4
movl -0x78(%rbp), %eax
movl -0x74(%rbp), %ecx
cmpl %ecx, %eax
je 0x2fe6
movq -0x70(%rbp), %rdi
leaq 0xa0af(%rip), %rsi      # 0xd068
callq 0x2650
jmp 0x2fc0
movl $0x1, -0x48(%rbp)
jmp 0x30d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5420
jmp 0x30e8
movl $0x0, -0x4c(%rbp)
movq -0x60(%rbp), %rcx
movl -0x4c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x30bc
movl $0x0, -0x50(%rbp)
movq -0x60(%rbp), %rcx
movl -0x50(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x30ac
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2ef0
movq %rax, -0x80(%rbp)
jmp 0x3055
movsd -0x88(%rbp), %xmm0
movq -0x80(%rbp), %rax
movsd (%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2ef0
movq %rax, -0x90(%rbp)
jmp 0x308b
movq -0x90(%rbp), %rax
movsd -0x98(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x3003
jmp 0x30ae
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x2fed
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2b20
jmp 0x30cb
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5420
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::operator*(Matrix&)
Matrix Matrix::operator*(Matrix &B) {
    Matrix multip(this->rows, B.getCols(), 0.0);
    if (this->cols == B.getRows()) {
        unsigned i, j, k;
        double temp = 0.0;
        for (i = 0; i < this->rows; i++) {
            for (j = 0; j < B.getCols(); j++) {
                temp = 0.0;
                for (k = 0; k < this->cols; k++) {
                    temp += data[i][k] * B(k, j);
                }
                multip(i, j) = temp;
            }
        }
        return multip;
    } else {
        return "Error";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl (%rax), %eax
movl %eax, -0x74(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bb0
movl -0x74(%rbp), %esi
movl %eax, %edx
leaq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x2550
movq -0x70(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bd0
movl %eax, -0x60(%rbp)
jmp 0x3164
movl -0x64(%rbp), %eax
movl -0x60(%rbp), %ecx
cmpl %ecx, %eax
jne 0x32e9
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x70(%rbp), %rcx
movl -0x48(%rbp), %eax
cmpl (%rcx), %eax
jae 0x32ce
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bb0
movl %eax, -0x8c(%rbp)
jmp 0x31b1
movl -0x90(%rbp), %eax
movl -0x8c(%rbp), %ecx
cmpl %ecx, %eax
jae 0x32be
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x50(%rbp)
movq -0x70(%rbp), %rcx
movl -0x50(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x3276
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x50(%rbp), %eax
movl %eax, %esi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x2ef0
movq %rax, -0x98(%rbp)
jmp 0x3229
movsd -0xa0(%rbp), %xmm0
movq -0x98(%rbp), %rax
movsd (%rax), %xmm2
movsd -0x58(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x31d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5420
jmp 0x331b
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x2ef0
movq %rax, -0xa8(%rbp)
jmp 0x329d
movq -0xa8(%rbp), %rax
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x3197
jmp 0x32c0
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x3181
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2b20
jmp 0x32e0
movl $0x1, -0x5c(%rbp)
jmp 0x3305
movq -0x88(%rbp), %rdi
leaq 0x9d71(%rip), %rsi      # 0xd068
callq 0x2650
jmp 0x32fe
movl $0x1, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5420
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::operator+=(Matrix&)
Matrix Matrix::operator+=(Matrix &B) {
    //sum.print();
    if ((this->rows != B.getRows()) || (this->cols != B.getCols())) {
        return "Error";
    }
    unsigned i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            this->data[i][j] = this->data[i][j] + B(i, j);
        }
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bd0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jne 0x338a
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bb0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
je 0x339f
movq -0x40(%rbp), %rdi
leaq 0x9cd3(%rip), %rsi      # 0xd068
callq 0x2650
jmp 0x3462
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x3455
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x3445
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2ef0
movsd -0x58(%rbp), %xmm0
movq -0x30(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5190
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x33bc
jmp 0x3447
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x33a6
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2b20
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::operator+(double)
Matrix Matrix::operator+(double scalar) {
    Matrix result(rows, cols, 0.0);
    unsigned i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            result(i, j) = this->data[i][j] + scalar;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x19(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
xorps %xmm0, %xmm0
callq 0x2550
movl $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jae 0x38d9
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x38c9
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x5190
movq -0x50(%rbp), %rdi
movsd (%rax), %xmm0
movsd -0x18(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x2ef0
movq %rax, -0x58(%rbp)
jmp 0x389a
movq -0x58(%rbp), %rax
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3846
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5420
jmp 0x38f6
jmp 0x38cb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3830
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x38ec
movq -0x50(%rbp), %rdi
callq 0x5420
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2350
nop
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::operator+=(double)
Matrix Matrix::operator+=(double scalar) {
    unsigned i, j;
    for (i = 0; i < rows; i++) {
        for (j = 0; j < cols; j++) {
            this->data[i][j] = this->data[i][j] + scalar;
        }
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x3cf1
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x3ce1
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5190
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5190
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3c75
jmp 0x3ce3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c5f
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2b20
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::toArray()
vector<double> Matrix::toArray() {
    vector<double> array;
    for (unsigned i = 0; i < rows; i++) {
        for (unsigned j = 0; j < cols; j++) {
            array.push_back(data[i][j]);
        }
    }
    return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5480
movl $0x0, -0x18(%rbp)
movq -0x38(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jae 0x405f
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4052
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5190
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x54a0
jmp 0x402e
jmp 0x4030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ff5
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5510
jmp 0x407c
jmp 0x4054
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3fe3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4072
movq -0x48(%rbp), %rdi
callq 0x5510
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::transpose()
Matrix Matrix::transpose() {
    Matrix Transpose(rows, cols, 0.0);
    for (unsigned i = 0; i < cols; i++) {
        for (unsigned j = 0; j < rows; j++) {
            Transpose(i, j) = this->data[j][i];
        }
    }
    return Transpose;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x11(%rbp)
movl (%rax), %esi
movl 0x4(%rax), %edx
xorps %xmm0, %xmm0
callq 0x2550
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4143
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x4136
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x4f70
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5190
movq -0x38(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x2ef0
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40de
jmp 0x4138
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x40cb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4156
movq -0x38(%rbp), %rdi
callq 0x5420
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::print() const
void Matrix::print() const {
    if (this->rows == 0) std::cout << "[Empty Matrix]\n";
    for (unsigned i = 0; i < rows; i++) {
        for (unsigned j = 0; j < cols; j++) {
            std::cout << "[" << data[i][j] << "] ";
        }
        std::cout << '\n';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0x418c
movq 0xee58(%rip), %rdi      # 0x12fd8
leaq 0x8f31(%rip), %rsi      # 0xd0b8
callq 0x21d0
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0x4231
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4212
movq 0xee1c(%rip), %rdi      # 0x12fd8
leaq 0x8f05(%rip), %rsi      # 0xd0c8
callq 0x21d0
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x5570
movq %rax, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x5590
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x23a0
movq %rax, %rdi
leaq 0x8ec8(%rip), %rsi      # 0xd0ca
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x41a9
movq 0xedbf(%rip), %rdi      # 0x12fd8
movl $0xa, %esi
callq 0x2260
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4193
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream &operator<<(std::ostream &os, const Matrix &matrix) {
    if (matrix.rows == 0) os << "[Empty Matrix]\n";
    for (unsigned i = 0; i < matrix.rows; i++) {
        for (unsigned j = 0; j < matrix.cols; j++) {
            os << "[" << matrix.data[i][j] << "] ";
        }
        os << '\n';
    }
    return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4269
movq -0x8(%rbp), %rdi
leaq 0x8e54(%rip), %rsi      # 0xd0b8
callq 0x21d0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x4308
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x42ec
movq -0x8(%rbp), %rdi
leaq 0x8e2b(%rip), %rsi      # 0xd0c8
callq 0x21d0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x5570
movq %rax, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x5590
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x23a0
movq %rax, %rdi
leaq 0x8dee(%rip), %rsi      # 0xd0ca
callq 0x21d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4286
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x2260
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4270
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::deflation(Matrix&, double&)
Matrix Matrix::deflation(Matrix &X, double &eigenvalue) {
    // Deflation formula exactly applied
    double denominator = eigenvalue / (X.transpose() * X)(0, 0);
    Matrix Xtrans = X.transpose();
    Matrix RHS = (X * Xtrans);
    Matrix RHS2 = RHS * denominator;
    Matrix A2 = *this - RHS2;
    return A2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xf8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x4090
movq -0xf0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3100
jmp 0x4841
movl $0x0, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0x78(%rbp), %rsi
leaq -0x7c(%rbp), %rdx
callq 0x2ef0
movsd -0xf8(%rbp), %xmm0
movq -0x128(%rbp), %rdi
movsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x120(%rbp)
callq 0x5420
leaq -0x68(%rbp), %rdi
callq 0x5420
movsd -0x120(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x4090
movq -0x118(%rbp), %rdx
movq -0x18(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x3100
jmp 0x48d1
movsd -0x28(%rbp), %xmm0
leaq -0xe0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3a10
jmp 0x48eb
movq -0x100(%rbp), %rsi
movq -0x110(%rbp), %rdi
movb $0x0, -0xe1(%rbp)
leaq -0xe0(%rbp), %rdx
callq 0x2f30
jmp 0x490e
movb $0x1, -0xe1(%rbp)
testb $0x1, -0xe1(%rbp)
jne 0x497c
jmp 0x4970
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5420
jmp 0x49c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x49bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x49b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x5420
jmp 0x49b0
movq -0x110(%rbp), %rdi
callq 0x5420
leaq -0xe0(%rbp), %rdi
callq 0x5420
leaq -0xc0(%rbp), %rdi
callq 0x5420
leaq -0xa0(%rbp), %rdi
callq 0x5420
movq -0x108(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0xc0(%rbp), %rdi
callq 0x5420
leaq -0xa0(%rbp), %rdi
callq 0x5420
movq -0x70(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::randomize()
void Matrix::randomize() {
    std::random_device dev;
    std::mt19937 rng(dev());
    std::uniform_real_distribution<> dist(-1.0f, 1.0f);
    for (int i = 0; i < this->rows; i++) {
        for (int j = 0; j < this->cols; j++) {
            double value = this->data[i][j];
            this->data[i][j] = dist(rng);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2770, %rsp           # imm = 0x2770
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2760(%rbp)
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x2758(%rbp)
callq 0x5680
movq -0x2758(%rbp), %rdi
callq 0x5720
movl %eax, -0x274c(%rbp)
jmp 0x4a21
movl -0x274c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2718(%rbp), %rdi
callq 0x5740
jmp 0x4a39
leaq -0x2738(%rbp), %rdi
movsd 0x85d0(%rip), %xmm0     # 0xd018
movsd 0x85b8(%rip), %xmm1     # 0xd008
callq 0x5770
jmp 0x4a57
movl $0x0, -0x273c(%rbp)
movq -0x2760(%rbp), %rcx
movl -0x273c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x4b61
movl $0x0, -0x2740(%rbp)
movq -0x2760(%rbp), %rcx
movl -0x2740(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4b4b
movq -0x2760(%rbp), %rdi
addq $0x8, %rdi
movslq -0x273c(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x2740(%rbp), %rsi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0x2748(%rbp)
leaq -0x2738(%rbp), %rdi
leaq -0x2718(%rbp), %rsi
callq 0x57a0
movsd %xmm0, -0x2768(%rbp)
jmp 0x4ae5
movq -0x2760(%rbp), %rdi
addq $0x8, %rdi
movslq -0x273c(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x2740(%rbp), %rsi
callq 0x5190
movsd -0x2768(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x2740(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2740(%rbp)
jmp 0x4a80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2720(%rbp)
movl %eax, -0x2724(%rbp)
leaq -0x1390(%rbp), %rdi
callq 0x57d0
jmp 0x4b76
jmp 0x4b4d
movl -0x273c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x273c(%rbp)
jmp 0x4a61
leaq -0x1390(%rbp), %rdi
callq 0x57d0
addq $0x2770, %rsp           # imm = 0x2770
popq %rbp
retq
movq -0x2720(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::sigmod()
Matrix Matrix::sigmod() {
    for (int i = 0; i < this->rows; i++) {
        for (int j = 0; j < this->cols; j++) {
            double value = this->data[i][j];
            this->data[i][j] = 1 / (1 + std::exp(-value));
        }
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jae 0x4c88
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4c78
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x2370
movq -0x28(%rbp), %rdi
movsd 0x83d5(%rip), %xmm1     # 0xd008
addsd %xmm0, %xmm1
movsd 0x83c9(%rip), %xmm0     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5190
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4bd0
jmp 0x4c7a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4bba
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2b20
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::dSigmod()
Matrix Matrix::dSigmod() {
    for (int i = 0; i < this->rows; i++) {
        for (int j = 0; j < this->cols; j++) {
            double value = this->data[i][j];
            this->data[i][j] = 1 - (value * value);
        }
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jae 0x4d90
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4d80
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5190
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x82c1(%rip), %xmm1     # 0xd008
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x5190
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ce0
jmp 0x4d82
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4cca
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2b20
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Krymancer[P]Matrix-cpp/src/Matrix.cpp
// Function: Matrix::map(double (*)(double))
Matrix Matrix::map(functioncall func) {
    for (int i = 0; i < this->rows; i++) {
        for (int j = 0; j < this->cols; j++) {
            double value = this->data[i][j];
            this->data[i][j] = func(value);
        }
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x4e77
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x4e67
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0x5190
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsd -0x28(%rbp), %xmm0
callq *%rax
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4f70
movq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0x5190
movsd -0x48(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4df4
jmp 0x4e69
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4dde
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2b20
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: registerInterval::set_code(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void registerInterval::set_code(string s){
	code = s;
	registerInterval_numberOfInstructions = 0;

	int found = 0;
	found = code.find(";", found + 1, 1);
	while (found != string::npos){
		registerInterval_numberOfInstructions++;
		found = code.find(";", found + 1, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x38, %rdi
callq 0x3040
movq -0x20(%rbp), %rdi
movl $0x0, 0x58(%rdi)
movl $0x0, -0x14(%rbp)
addq $0x38, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0x148aa(%rip), %rsi     # 0x18111
movl $0x1, %ecx
callq 0x3430
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $-0x1, %rax
je 0x38ae
movq -0x20(%rbp), %rdi
movl 0x58(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x58(%rdi)
addq $0x38, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0x14872(%rip), %rsi     # 0x18111
movl $0x1, %ecx
callq 0x3430
movl %eax, -0x14(%rbp)
jmp 0x3874
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: registerInterval::set_register_list(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void registerInterval::set_register_list(set<string> s){
	register_list = s;

	int pos;
	string str;
	set<string>::iterator it;
	for(int i = 0; i < 64; i++){
		register_vector.push_back(false);
	}

	for(it = register_list.begin(); it != register_list.end(); ++it){
		str = *it;
		str.erase(str.begin());
		pos = stoi(str);
		register_vector[pos] = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x60, %rdi
callq 0xb8d0
leaq -0x38(%rbp), %rdi
callq 0x3360
leaq -0x40(%rbp), %rdi
callq 0xb900
movl $0x0, -0x44(%rbp)
cmpl $0x40, -0x44(%rbp)
jge 0x39d1
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0xb920
jmp 0x39aa
jmp 0x39ac
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3990
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x3b07
movq -0x98(%rbp), %rdi
addq $0x60, %rdi
callq 0xb9f0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x98(%rbp), %rdi
addq $0x60, %rdi
callq 0xba50
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xba20
testb $0x1, %al
jne 0x3a17
jmp 0x3af5
leaq -0x40(%rbp), %rdi
callq 0xba80
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3040
jmp 0x3a2e
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3200
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xbab0
movq -0xa8(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x32d0
movq %rax, -0xa0(%rbp)
jmp 0x3a68
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movl $0xa, %edx
callq 0xbaf0
movl %eax, -0xac(%rbp)
jmp 0x3a8d
movq -0x98(%rbp), %rdi
movl -0xac(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0xbb30
movq %rdx, -0xc0(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x3aba
movq -0xc0(%rbp), %rax
movq -0xb8(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x88(%rbp)
leaq -0x90(%rbp), %rdi
movl $0x1, %esi
callq 0xbb90
leaq -0x40(%rbp), %rdi
callq 0xbbe0
jmp 0x39ed
leaq -0x38(%rbp), %rdi
callq 0x31a0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3440