LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/pritpal20[P]vector/./vector.hpp
// Function: double* lni::vector<double>::insert<double*>(double const*, double*, double*)
typename vector<T>::iterator vector<T>::insert(typename vector<T>::const_iterator it, InputIt first, InputIt last) {
		iterator f = &arr[it - arr];
		size_type cnt = last - first;
		if (!cnt) return f;
		if (vec_sz + cnt > rsrv_sz) {
			rsrv_sz = (vec_sz + cnt) << 2;
			reallocate();
		}
		memmove(f + cnt, f, (vec_sz - (it - arr)) * sizeof(T));
		for (iterator it = f; first != last; ++it, ++first)
			(*it) = *first;
		vec_sz += cnt;
		return f;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rcx, %rbp
subq %rdx, %rbp
shrq $0x3, %rbp
testl %ebp, %ebp
je 0x3e64
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl 0x4(%rdi), %r13d
leal (%r13,%rbp), %edi
cmpl (%r12), %edi
jbe 0x3e1b
movq 0x8(%r12), %rax
movq %rax, 0x8(%rsp)
shll $0x2, %edi
movl %edi, (%r12)
shlq $0x3, %rdi
callq 0x1030
shlq $0x3, %r13
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x10b0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3e11
callq 0x10f0
movq 0x10(%rsp), %rax
movq %rax, 0x8(%r12)
movl %ebp, %eax
leaq (%rbx,%rax,8), %rdi
movq %rbx, %rax
subq 0x8(%r12), %rax
movl 0x4(%r12), %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x1130
cmpq %r14, %r15
je 0x3e5f
movq %rbx, %rax
movsd (%r15), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rax
addq $0x8, %r15
cmpq %r14, %r15
jne 0x3e49
addl %ebp, 0x4(%r12)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::insert(double const*, unsigned int, double const&)
typename vector<T>::iterator vector<T>::insert(typename vector<T>::const_iterator it, typename vector<T>::size_type cnt, const T &val) {
		iterator f = &arr[it - arr];
		if (!cnt) return f;
		if (vec_sz + cnt > rsrv_sz) {
			rsrv_sz = (vec_sz + cnt) << 2;
			reallocate();
		}
		memmove(f + cnt, f, (vec_sz - (it - arr)) * sizeof(T));
		vec_sz += cnt;
		for (iterator it = f; cnt--; ++it)
			(*it) = val;
		return f;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testl %edx, %edx
je 0x3f24
movq %rcx, %rbx
movl %edx, %r15d
movq %rdi, %r12
movl 0x4(%rdi), %r13d
leal (%r15,%r13), %edi
cmpl (%r12), %edi
jbe 0x3ee4
movq 0x8(%r12), %rbp
shll $0x2, %edi
movl %edi, (%r12)
shlq $0x3, %rdi
callq 0x1030
shlq $0x3, %r13
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x3edb
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r12)
movl %r15d, %r13d
leaq (%r14,%r13,8), %rdi
movq %r14, %rax
subq 0x8(%r12), %rax
movl 0x4(%r12), %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %r14, %rsi
callq 0x1130
addl %r15d, 0x4(%r12)
xorl %eax, %eax
movsd (%rbx), %xmm0
movsd %xmm0, (%r14,%rax,8)
incq %rax
cmpl %eax, %r13d
jne 0x3f12
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::insert(double const*, std::initializer_list<double>)
typename vector<T>::iterator vector<T>::insert(typename vector<T>::const_iterator it, std::initializer_list<T> lst) {
		size_type cnt = lst.size();
		iterator f = &arr[it - arr];
		if (!cnt) return f;
		if (vec_sz + cnt > rsrv_sz) {
			rsrv_sz = (vec_sz + cnt) << 2;
			reallocate();
		}
		memmove(f + cnt, f, (vec_sz - (it - arr)) * sizeof(T));
		iterator iit = f;
		for (auto &item: lst) {
			(*iit) = item;
			++iit;
		}
		vec_sz += cnt;
		return f;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %rbx
testl %r14d, %r14d
je 0x3ff3
movq %rdx, %r15
movq %rdi, %r12
movl 0x4(%rdi), %r13d
leal (%r14,%r13), %edi
cmpl (%r12), %edi
jbe 0x3fa5
movq 0x8(%r12), %rbp
shll $0x2, %edi
movl %edi, (%r12)
shlq $0x3, %rdi
callq 0x1030
shlq $0x3, %r13
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x3f9c
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r12)
movl %r14d, %eax
leaq (%rbx,%rax,8), %rdi
movq %rbx, %rax
subq 0x8(%r12), %rax
movl 0x4(%r12), %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x1130
testq %r14, %r14
je 0x3fee
movq %r14, %rax
shlq $0x3, %rax
xorl %ecx, %ecx
movsd (%r15,%rcx), %xmm0
movsd %xmm0, (%rbx,%rcx)
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x3fda
addl %r14d, 0x4(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtmidi_build/tests/cmidiin.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications.
  std::cout << "\nuseage: cmidiin <port>\n";
  std::cout << "    where port = the device to use (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbx
movq 0x2cbc(%rip), %rbx      # 0x4fd0
leaq 0xce9(%rip), %rsi       # 0x3004
movq %rbx, %rdi
callq 0x20e0
leaq 0xcf3(%rip), %rsi       # 0x301d
movq %rbx, %rdi
callq 0x20e0
xorl %edi, %edi
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/tobias93[P]piano/rtmidi_build/tests/cmidiin.cpp
// Function: main
int main( int argc, char ** /*argv[]*/ )
{
  RtMidiIn *midiin = 0;

  // Minimal command-line check.
  if ( argc > 2 ) usage();

  try {

    // RtMidiIn constructor
    midiin = new RtMidiIn();

    // Call function to select port.
    if ( chooseMidiPort( midiin ) == false ) goto cleanup;

    // Set our callback function.  This should be done immediately after
    // opening the port to avoid having incoming messages written to the
    // queue instead of sent to the callback function.
    midiin->setCallback( &mycallback );

    // Don't ignore sysex, timing, or active sensing messages.
    midiin->ignoreTypes( false, false, false );

    std::cout << "\nReading MIDI input ... press <enter> to quit.\n";
    char input;
    std::cin.get(input);

  } catch ( RtMidiError &error ) {
    error.printMessage();
  }

 cleanup:

  delete midiin;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x3, %edi
jge 0x253c
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xbd6(%rip), %rsi       # 0x3063
leaq 0xbe2(%rip), %rdx       # 0x3076
leaq 0x8(%rsp), %rdi
callq 0x29f2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x64, %ecx
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2100
movq %rbx, %rdi
callq 0x25a2
testb %al, %al
je 0x2520
movq 0x8(%rbx), %rdi
leaq -0x1a7(%rip), %rsi      # 0x2339
xorl %edx, %edx
callq 0x2040
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x48(%rax)
movq 0x2ad2(%rip), %rdi      # 0x4fd0
leaq 0xb72(%rip), %rsi       # 0x3077
movl $0x2f, %edx
callq 0x2110
movq 0x2aca(%rip), %rdi      # 0x4fe0
leaq 0x7(%rsp), %rsi
callq 0x2140
testq %rbx, %rbx
je 0x252e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x230c
jmp 0x2579
movq %rdx, %r15
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2568
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2100
jmp 0x2568
movq %rdx, %r15
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2100
xorl %ebx, %ebx
jmp 0x257f
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x259d
callq 0x2060
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
callq 0x2180
jmp 0x2520
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/src/normalized/normalized.cpp
// Function: TFileValue::TCmp::_v(TFileValue const&) const
size_t _v(const TFileValue& x)const{
            size_t xi=x.fileIndex;
            if (isInSignDir(x.fileName)){
                xi+=_fileCount;
                     if (isEndWith(x.fileName,".SF"))  xi+=_fileCount;
                else if (isEndWith(x.fileName,".RSA")) xi+=_fileCount*2;
                else if (isSignMFFile(x.fileName))     xi+=_fileCount*3;
            }
            return  xi;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movslq 0x20(%rsi), %rbx
leaq 0x1ac83(%rip), %rsi     # 0x20fff
movl $0x9, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x34b0
testq %rax, %rax
je 0x63af
leaq 0x1ac72(%rip), %rsi     # 0x21009
movl $0x9, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x34b0
testq %rax, %rax
jne 0x6439
movslq (%r14), %rax
addq %rax, %rbx
leaq 0x1ac3a(%rip), %rsi     # 0x20ff6
movl $0x3, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x34b0
movq 0x8(%r15), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jne 0x63dd
movslq (%r14), %rax
jmp 0x6436
leaq 0x1ac16(%rip), %rsi     # 0x20ffa
movl $0x4, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x34b0
movq 0x8(%r15), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
jne 0x6409
movslq (%r14), %rax
leaq (%rbx,%rax,2), %rbx
jmp 0x6439
leaq 0x1ac03(%rip), %rsi     # 0x21013
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0x642f
leaq 0x1ac05(%rip), %rsi     # 0x21028
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x6439
movslq (%r14), %rax
leaq (%rax,%rax,2), %rax
addq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::CPU(int, int, int, int, int, int)
CPU::CPU(int reg1, int reg2, int reg3, int reg4, int reg5,
            int progcount)
{
    setR1(reg1);
    setR2(reg2);
    setR3(reg3);
    setR4(reg4);
    setR5(reg5);
    setPC(progcount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movl %eax, 0x14(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::print()
void CPU::print()
{
    cout <<"Register Values:" << endl
         << "[" << 0 << "]->" << getR1() << endl
         << "[" << 1 << "]->" << getR2() << endl
         << "[" << 2 << "]->" << getR3() << endl
         << "[" << 3 << "]->" << getR4() << endl
         << "[" << 4 << "]->" << getR5() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x9755(%rip), %r14      # 0xbfd0
leaq 0x67f5(%rip), %rsi      # 0x9077
movl $0x10, %edx
movq %r14, %rdi
callq 0x2130
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r15
leaq 0x67af(%rip), %r14      # 0x906f
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %r15, %rdi
xorl %esi, %esi
callq 0x21b0
movq %rax, %r12
leaq 0x67a4(%rip), %r15      # 0x9088
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movl (%rbx), %esi
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %r12, %rdi
movl $0x1, %esi
callq 0x21b0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movl 0x4(%rbx), %esi
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %r12, %rdi
movl $0x2, %esi
callq 0x21b0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movl 0x8(%rbx), %esi
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %r12, %rdi
movl $0x3, %esi
callq 0x21b0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movl 0xc(%rbx), %esi
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
movq %r12, %rdi
movl $0x4, %esi
callq 0x21b0
movq %rax, %r14
movl $0x3, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::split(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string CPU::split(int& i, string str)
{
    char temp[100];
    string result;
    int j= 0;
    while(str[i] != ' ' && str[i] != ',' && str[i] != ';' && str[i] != '\n'
            && str[i] != '\t' && str[i] != '\0')
    {
        temp[j] = str[i];
        ++(i);
        ++j;
    }

    temp[j] = '\0';

    result = temp;
    //set index for ignore space and coma and tab
    if(str[i] == ' ' || str[i] == ',' || str[i] == '\t')
    {
        i += 1;
    }
    //if result stay empty fonction call itself
    if(j == 0)
    {
        result = split(i, str);
    }
    return result;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movslq (%rdx), %rcx
leal 0x1(%rcx), %eax
addq (%r12), %rcx
xorl %r15d, %r15d
movabsq $0x800100100000601, %rdx # imm = 0x800100100000601
movzbl (%rcx,%r15), %esi
cmpq $0x3b, %rsi
ja 0x6c84
btq %rsi, %rdx
jb 0x6c98
movb %sil, -0xe0(%rbp,%r15)
leal (%rax,%r15), %esi
movl %esi, (%r14)
incq %r15
jmp 0x6c73
movl %r15d, %eax
movb $0x0, -0xe0(%rbp,%rax)
leaq -0xe0(%rbp), %r13
movq %r13, %rdi
callq 0x2080
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r13, %rcx
movq %rax, %r8
callq 0x2190
movslq (%r14), %rax
movq (%r12), %rsi
movzbl (%rsi,%rax), %ecx
cmpq $0x2c, %rcx
ja 0x6cea
movabsq $0x100100000200, %rdx   # imm = 0x100100000200
btq %rcx, %rdx
jae 0x6cea
incl %eax
movl %eax, (%r14)
testq %r15, %r15
jne 0x6d4a
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x6e5e
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq %r14, %rdx
callq 0x6c24
leaq -0x78(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq (%r14), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x6d3c
callq 0x2110
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x6d4a
callq 0x2110
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x6d77
callq 0x2110
jmp 0x6d77
jmp 0x6d74
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x6d85
callq 0x2110
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::doInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CPU::doInteger(string ch){
    int result = 0, x = 0, size= 0, i=0;
    bool negative = false;

    size = ch.length();
    if(ch[0] == '-'){
        negative = true;
        ++i;
    }
    else if(ch[0] == '#')
    {
        ++i;
    }

    while(i < size){
        result *= 10;
        x = ch[i] - '0';
        result += x;
        ++i;
    }

    if(negative)
        result *= -1;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rsi), %eax
movq (%rsi), %rdx
movb (%rdx), %cl
cmpb $0x2d, %cl
sete %sil
cmpb $0x23, %cl
sete %dil
orb %sil, %dil
movzbl %dil, %r8d
xorl %esi, %esi
cmpl %eax, %r8d
jge 0x6e31
cmpb $0x23, %cl
sete %sil
cmpb $0x2d, %cl
sete %dil
orb %sil, %dil
movzbl %dil, %edi
addl %edi, %eax
subl %r8d, %eax
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
movsbl (%rdx,%rdi), %r8d
leal (%r8,%rsi,2), %esi
addl $-0x30, %esi
incq %rdi
cmpq %rdi, %rax
jne 0x6e1a
movl %esi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %esi, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::CPUProgramDyn(CPUProgramDyn const&)
CPUProgramDyn::CPUProgramDyn(const CPUProgramDyn& obj)
{
    fileString = new string[obj.numberOfLines];
    numberOfLines = obj.numberOfLines;

    for(int i = 0; i < obj.numberOfLines; ++i)
    {
        fileString[i] = obj.fileString[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, -0x30(%rbp)
movq %rax, 0x10(%rdi)
leaq 0x2270(%rip), %rdx      # 0x92c5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x811a
movslq (%r14), %r12
movq %r12, %r13
shlq $0x5, %r13
leaq 0x8(%r13), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testl %r12d, %r12d
je 0x70aa
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x7091
movq %rcx, 0x8(%r15)
movl %r12d, (%r15)
cmpl $0x0, (%r14)
jle 0x70df
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r14), %rsi
addq %r12, %rsi
movq 0x8(%r15), %rdi
addq %r12, %rdi
callq 0x20a0
incq %r13
movslq (%r14), %rax
addq $0x20, %r12
cmpq %rax, %r13
jl 0x70bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70f0
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x7101
callq 0x2110
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::ReadFile(char const*)
void CPUProgramDyn::ReadFile(const char* fileName){

    numberOfLines = determineNumberOfLines(fileName);

    if(fileString != nullptr)
    {
        delete [] fileString;
    }

    fileString = new string[numberOfLines];
    fstream file;
    string line;
    file.open(fileName);

    for(int i = 0; i < numberOfLines; ++i)
    {
        getline (file,fileString[i]);
    }

    file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7378
movl %eax, (%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x71d2
leaq -0x8(%rax), %r15
movq -0x8(%rax), %r12
testq %r12, %r12
je 0x71ca
shlq $0x5, %r12
leaq (%r12,%rax), %r13
addq $-0x10, %r13
negq %r12
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x71c0
callq 0x2110
addq $-0x20, %r13
addq $0x20, %r12
jne 0x71b2
movq %r15, %rdi
callq 0x2170
movslq (%rbx), %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r12, (%rax)
testq %r12, %r12
je 0x721c
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x7203
movq %rcx, 0x8(%rbx)
leaq -0x258(%rbp), %r15
movq %r15, %rdi
callq 0x2140
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %r15, %rdi
movq %r14, %rsi
movl $0x18, %edx
callq 0x2100
cmpl $0x0, (%rbx)
jle 0x7299
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x8(%rbx), %r14
movq -0x258(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2120
addq %r13, %r14
movsbl %al, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x21e0
incq %r12
movslq (%rbx), %rax
addq $0x20, %r13
cmpq %rax, %r12
jl 0x725d
leaq -0x258(%rbp), %rdi
callq 0x2050
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x72b7
callq 0x2110
leaq -0x258(%rbp), %rdi
callq 0x2060
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72d7
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x72ec
callq 0x2110
leaq -0x258(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::determineNumberOfLines(char const*) const
const int CPUProgramDyn::determineNumberOfLines(const char* fileName)const
{
    int line = 0;
    string buffer;
    fstream file;

    file.open(fileName);

    for(getline(file, buffer); !(file.eof()) ; getline(file, buffer)){
        ++line;
    }

    file.close();
    return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x250(%rbp), %rdi
callq 0x2140
leaq -0x250(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x18, %edx
callq 0x2100
movq -0x250(%rbp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %edx
leaq -0x250(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21e0
xorl %ebx, %ebx
leaq -0x250(%rbp), %r14
leaq -0x40(%rbp), %r15
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x230(%rbp,%rax)
jne 0x743b
leaq (%rax,%rbp), %rdi
addq $-0x250, %rdi           # imm = 0xFDB0
movl $0xa, %esi
callq 0x2120
incl %ebx
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
jmp 0x73ff
leaq -0x250(%rbp), %rdi
callq 0x2050
leaq -0x250(%rbp), %rdi
callq 0x2060
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7461
callq 0x2110
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7489
jmp 0x747a
movq %rax, %rbx
leaq -0x250(%rbp), %rdi
callq 0x2060
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7497
callq 0x2110
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::getLine[abi:cxx11](int) const
const string CPUProgramDyn::getLine(int line) const
{

    if(line >= numberOfLines || line < 0){
            cout << "Error: Overflow fileString." << endl
                 << "Returned empty string" << endl;

            string empty;

            return empty;
        }

    return fileString[line];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %edx, %edx
js 0x74dc
cmpl %edx, (%rsi)
jle 0x74dc
movq 0x8(%rsi), %rax
movl %edx, %ecx
shlq $0x5, %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6e5e
jmp 0x756f
movq 0x4aed(%rip), %r14      # 0xbfd0
leaq 0x1d6f(%rip), %rsi      # 0x9259
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2130
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x1d4d(%rip), %rsi      # 0x9275
movl $0x15, %edx
movq %rax, %rdi
callq 0x2130
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator--()
const CPUProgramDyn CPUProgramDyn::operator--()
{
    CPUProgramDyn temp;
    temp = *this;
    delete [] fileString;
    --numberOfLines;
    fileString = new string[numberOfLines];
    for(int i = 0; i < numberOfLines; ++i)
    {
        fileString[i] = temp.fileString[i];
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x6ef8
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x7024
leaq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x76fa
leaq -0xb8(%rbp), %rdi
callq 0x7300
leaq -0x88(%rbp), %rdi
callq 0x7300
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7626
leaq -0x8(%rax), %r15
movq -0x8(%rax), %r12
testq %r12, %r12
je 0x761e
shlq $0x5, %r12
leaq (%r12,%rax), %r13
addq $-0x10, %r13
negq %r12
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x7614
callq 0x2110
addq $-0x20, %r13
addq $0x20, %r12
jne 0x7606
movq %r15, %rdi
callq 0x2170
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
movslq %ecx, %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovgq %rcx, %rdi
callq 0x2030
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testl %r12d, %r12d
je 0x7678
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x765f
movq %rcx, 0x8(%r14)
cmpl $0x0, (%r14)
jle 0x76aa
xorl %r15d, %r15d
xorl %r12d, %r12d
movq -0x50(%rbp), %rsi
addq %r15, %rsi
movq 0x8(%r14), %rdi
addq %r15, %rdi
callq 0x20a0
incq %r12
movslq (%r14), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x7688
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7024
leaq -0x58(%rbp), %rdi
callq 0x7300
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x7300
jmp 0x76e9
jmp 0x76e6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7300
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator=(CPUProgramDyn)
CPUProgramDyn CPUProgramDyn::operator = (CPUProgramDyn rSide)
{
    if(rSide.numberOfLines != numberOfLines)
    {
        delete [] fileString;
        fileString = new string[rSide.numberOfLines];
        numberOfLines = rSide.numberOfLines;
    }
    for(int i = 0; i < rSide.numberOfLines; ++i)
    {
        fileString[i] = rSide.fileString[i];
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
cmpl (%rsi), %eax
je 0x77b7
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7766
leaq -0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq -0x8(%rax), %r13
testq %r13, %r13
je 0x775d
shlq $0x5, %r13
leaq (%rax,%r13), %r12
addq $-0x10, %r12
negq %r13
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x7753
callq 0x2110
addq $-0x20, %r12
addq $0x20, %r13
jne 0x7744
movq -0x30(%rbp), %rdi
callq 0x2170
movslq (%r15), %r12
movq %r12, %r13
shlq $0x5, %r13
leaq 0x8(%r13), %rax
testq %r12, %r12
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r12, (%rax)
testq %r12, %r12
je 0x77b0
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x7797
movq %rcx, 0x8(%r14)
movl %r12d, (%r14)
cmpl $0x0, (%r15)
jle 0x77e5
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rsi
addq %r12, %rsi
movq 0x8(%r14), %rdi
addq %r12, %rdi
callq 0x20a0
incq %r13
movslq (%r15), %rax
addq $0x20, %r12
cmpq %rax, %r13
jl 0x77c3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7024
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_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator--(int)
const CPUProgramDyn CPUProgramDyn::operator--(int)
{
    CPUProgramDyn newObj;
    newObj = *this;
    delete [] fileString;
    --numberOfLines;
    fileString = new string[numberOfLines];
    for(int i = 0; i < numberOfLines; ++i)
    {
        fileString[i] = newObj.fileString[i];
    }

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6ef8
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x7024
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x76fa
leaq -0x88(%rbp), %rdi
callq 0x7300
leaq -0x58(%rbp), %rdi
callq 0x7300
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7897
leaq -0x8(%rax), %r15
movq -0x8(%rax), %r12
testq %r12, %r12
je 0x788f
shlq $0x5, %r12
leaq (%r12,%rax), %r13
addq $-0x10, %r13
negq %r12
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x7885
callq 0x2110
addq $-0x20, %r13
addq $0x20, %r12
jne 0x7877
movq %r15, %rdi
callq 0x2170
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
movslq %ecx, %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovgq %rcx, %rdi
callq 0x2030
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testl %r12d, %r12d
je 0x78e9
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x78d0
movq %rcx, 0x8(%r14)
cmpl $0x0, (%r14)
jle 0x791b
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq 0x8(%r14), %rdi
addq %r15, %rdi
callq 0x20a0
incq %r12
movslq (%r14), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x78f9
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x7300
jmp 0x7940
jmp 0x793d
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator[][abi:cxx11](int)
string& CPUProgramDyn::operator[](int line)
{
    if(line >= numberOfLines || line < 0){
        cout << "Error: Overflow fileString." << endl
             << "Returned empty string" << endl;

        return empty;
    }

    return fileString[line];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
js 0x7bbe
cmpl %esi, (%rbx)
jle 0x7bbe
movl %esi, %eax
shlq $0x5, %rax
addq 0x8(%rbx), %rax
movq %rax, %rbx
jmp 0x7c42
movq 0x440b(%rip), %r14      # 0xbfd0
leaq 0x168d(%rip), %rsi      # 0x9259
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2130
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
movq %rax, %r14
leaq 0x166b(%rip), %rsi      # 0x9275
movl $0x15, %edx
movq %rax, %rdi
callq 0x2130
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator+(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
CPUProgramDyn CPUProgramDyn::operator+(const string instraction) const
{
    CPUProgramDyn newObj;
    newObj = *this;
    newObj+= instraction;
    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6ef8
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x7024
leaq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
movq %rbx, %rsi
callq 0x76fa
leaq -0xc8(%rbp), %rdi
callq 0x7300
leaq -0x68(%rbp), %rdi
callq 0x7300
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x6e5e
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rbx, %rsi
callq 0x7950
leaq -0x98(%rbp), %rdi
callq 0x7300
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x7ce4
callq 0x2110
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x7d19
callq 0x2110
jmp 0x7d19
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x7300
jmp 0x7d19
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator+(CPUProgramDyn&) const
CPUProgramDyn CPUProgramDyn::operator+(CPUProgramDyn& rSide) const
{
    CPUProgramDyn newObj;
    newObj = *this;
    for(int i = 0; i < rSide.size(); ++i)
    {
        newObj += rSide.getLine(i);
    }

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x6ef8
leaq -0x78(%rbp), %rdi
movq %r15, %rsi
callq 0x7024
leaq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %rbx, %rsi
callq 0x76fa
leaq -0xa8(%rbp), %rdi
callq 0x7300
leaq -0x78(%rbp), %rdi
callq 0x7300
cmpl $0x0, (%r14)
jle 0x7dd2
xorl %r15d, %r15d
leaq -0x48(%rbp), %r12
leaq -0xd8(%rbp), %r13
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x74a0
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7950
movq %r13, %rdi
callq 0x7300
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x7dca
callq 0x2110
incl %r15d
cmpl (%r14), %r15d
jl 0x7d94
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x7300
jmp 0x7e11
jmp 0x7df7
movq %rax, %r14
jmp 0x7e11
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x7e11
callq 0x2110
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator()(int, int) const
const CPUProgramDyn CPUProgramDyn::operator()(int start, int end) const
{
    CPUProgramDyn newObj, emptyObj;

    if(start > size()-1 || end > size()-1){
        cout << "Error: Overflow fileString." << endl;

        return emptyObj;
    }

    for(int i = start; i <= end; ++i)
    {
        newObj += this->getLine(i);
    }

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r13
leaq -0xb8(%rbp), %r12
movq %r12, %rdi
callq 0x6ef8
leaq -0x88(%rbp), %rdi
callq 0x6ef8
movl (%r14), %eax
cmpl %r15d, %eax
setle %cl
cmpl %ebx, %eax
setle %al
orb %cl, %al
jne 0x7ed1
cmpl %ebx, %r15d
jg 0x7f1e
movq %r14, -0x38(%rbp)
movq %r13, -0x30(%rbp)
incl %ebx
leaq -0x58(%rbp), %r14
leaq -0xe8(%rbp), %r13
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movl %r15d, %edx
callq 0x74a0
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7950
movq %r13, %rdi
callq 0x7300
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7ec3
callq 0x2110
incl %r15d
cmpl %r15d, %ebx
jne 0x7e8c
movq -0x30(%rbp), %r13
jmp 0x7f1e
movq 0x40f8(%rip), %rbx      # 0xbfd0
leaq 0x137a(%rip), %rsi      # 0x9259
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x2130
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq 0x40c6(%rip), %rdi      # 0xbfd0
callq 0x2040
movq %rax, %rdi
callq 0x20c0
leaq -0x88(%rbp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x7024
leaq -0x88(%rbp), %rdi
callq 0x7300
leaq -0xb8(%rbp), %rdi
callq 0x7300
movq %r13, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7f83
jmp 0x7f5d
movq %rax, %rbx
jmp 0x7f77
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7f77
callq 0x2110
leaq -0x88(%rbp), %rdi
callq 0x7300
leaq -0xb8(%rbp), %rdi
callq 0x7300
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: operator<<(std::ostream&, CPUProgramDyn const&)
ostream& operator << (ostream& out, const CPUProgramDyn& myProg)
{
    for(int i = 0; i < myProg.size(); ++i)
    {
        out << myProg.getLine(i);

        if(i != myProg.size()-1)
            out << endl;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jle 0x80ef
movq %rsi, %r14
xorl %r15d, %r15d
leaq -0x38(%rbp), %r13
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x74a0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x2130
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x80b6
callq 0x2110
movl (%r14), %eax
decl %eax
cmpl %eax, %r15d
je 0x80e7
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20c0
incl %r15d
cmpl (%r14), %r15d
jl 0x808a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8112
callq 0x2110
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/salihbektas[P]Simple-CPU-emulator/computer.cpp
// Function: Computer::Computer(CPU, CPUProgramDyn, Memory, int)
Computer::Computer(CPU oCpu, CPUProgramDyn oCpuProgram, Memory oMemory, int option)
{
    setCPU(oCpu);
    setCPUProgram(oCpuProgram);
    setMemory(oMemory);
    debug = option;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, %r14
callq 0x2788
leaq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x6ef8
leaq 0x50(%r14), %r12
movq %r12, %rdi
callq 0x266c
leaq 0x10(%rbp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0xc(%r14)
movups %xmm0, (%r14)
leaq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x7024
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x8280
leaq 0x30(%rbp), %r15
leaq -0x58(%rbp), %rdi
callq 0x7300
movl $0xc8, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movl %ebx, 0x118(%r14)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7300
jmp 0x825a
movq %rax, %rbx
movq %r15, %rdi
callq 0x7300
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/CoinBlack[P]blackcoin-seeder/dns.cpp
// Function: write_record_ns(unsigned char**, unsigned char const*, char const*, int, dns_class, int, char const*)
int static write_record_ns(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_class cls, int ttl, const char *ns) {
  unsigned char *oldpos = *outpos;
  int ret = write_record(outpos, outend, name, offset, TYPE_NS, cls, ttl);
  if (ret) return ret;
  int error = 0;
  if (outend - *outpos < 2) {
    error = -5;
  } else {
    (*outpos) += 2;
    unsigned char *curpos = *outpos;
    ret = write_name(outpos, outend, ns, -1);
    if (ret) {
      error = ret;
    } else {
      curpos[-2] = (*outpos - curpos) >> 8;
      curpos[-1] = (*outpos - curpos) & 0xFF;
      return 0;
    }
  }
  *outpos = oldpos;
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r8d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
movl $0x2, %ecx
callq 0x5034
testl %eax, %eax
jne 0x4e33
movq (%rbx), %rbp
movq %r15, %rcx
subq %rbp, %rcx
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
cmpq $0x2, %rcx
jl 0x4e30
leaq 0x2(%rbp), %r13
movq %r13, (%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x50ec
movl %eax, %ecx
testl %eax, %eax
jne 0x4e2c
movl (%rbx), %eax
subl %r13d, %eax
movb %ah, (%rbp)
movl (%rbx), %eax
subl %r13d, %eax
movb %al, 0x1(%rbp)
xorl %eax, %eax
testl %ecx, %ecx
je 0x4e42
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x4e33
// File: /workspace/github_cpp_makefile_star2_O1/CoinBlack[P]blackcoin-seeder/dns.cpp
// Function: write_record(unsigned char**, unsigned char const*, char const*, int, dns_type, dns_class, int)
int static write_record(unsigned char** outpos, const unsigned char *outend, const char *name, int offset, dns_type typ, dns_class cls, int ttl) {
  unsigned char *oldpos = *outpos;
  int error = 0;
  // name
  int ret = write_name(outpos, outend, name, offset);
  if (ret) {
    error = ret;
  } else {
    if (outend - *outpos < 8) {
      error = -4;
    } else {
      // type
      *((*outpos)++) = typ >> 8; *((*outpos)++) = typ & 0xFF;
      // class
      *((*outpos)++) = cls >> 8; *((*outpos)++) = cls & 0xFF;
      // ttl
      *((*outpos)++) = (ttl >> 24) & 0xFF; *((*outpos)++) = (ttl >> 16) & 0xFF; *((*outpos)++) = (ttl >> 8) & 0xFF; *((*outpos)++) = ttl & 0xFF;
      return 0;
    }
  }
  *outpos = oldpos;
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0xf6eb(%rip), %rdx      # 0x1473e
callq 0x50ec
testl %eax, %eax
jne 0x506d
movq (%rbx), %rcx
subq %rcx, %r14
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
cmpq $0x8, %r14
jge 0x5079
movq %r15, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movb %al, (%rcx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %bpl, (%rcx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb $0x1, (%rcx)
movl %r12d, %ecx
shrl $0x18, %ecx
movq (%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, (%rbx)
movb %cl, (%rdx)
movl %r12d, %ecx
shrl $0x10, %ecx
movq (%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, (%rbx)
movb %cl, (%rdx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movl %r12d, %edx
movb %dh, (%rcx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %r12b, (%rcx)
jmp 0x5070
// File: /workspace/github_cpp_makefile_star2_O1/CoinBlack[P]blackcoin-seeder/bitcoin.cpp
// Function: CNode::PushVersion()
void PushVersion() {
    int64 nTime = time(NULL);
    uint64 nLocalNonce = BITCOIN_SEED_NONCE;
    int64 nLocalServices = 0;
    CAddress me(CService("0.0.0.0"));
    BeginMessage("version");
    int nBestHeight = GetRequireHeight();
    string ver = "/blackcoin-seeder:26.2.0/";
    uint8_t fRelayTxs = 0;
    vSend << PROTOCOL_VERSION << nLocalServices << nTime << you << me << nLocalNonce << ver << nBestHeight << fRelayTxs;
    EndMessage();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33b0
movq %rax, %r15
leaq 0xe859(%rip), %rsi      # 0x14014
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xa418
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0xb388
leaq 0xe82a(%rip), %rsi      # 0x1401c
movq %rbx, %rdi
callq 0x5d4e
leaq 0x17caf(%rip), %rax     # 0x1d4b0
leaq 0x17c9c(%rip), %rcx     # 0x1d4a4
movl (%rcx), %ecx
cmpb $0x0, (%rax)
movl $0x1f0c0c, %eax         # imm = 0x1F0C0C
movl $0x4df828, %ebp         # imm = 0x4DF828
cmovnel %eax, %ebp
testl %ecx, %ecx
cmovnel %ecx, %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe7f4(%rip), %rsi      # 0x14024
leaq 0xe806(%rip), %rdx      # 0x1403d
leaq 0x20(%rsp), %rdi
callq 0x61d4
leaq 0x8(%rbx), %r14
leaq 0x1c(%rsp), %rcx
movl $0x11180, -0x4(%rcx)    # imm = 0x11180
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f86
leaq 0x20(%rsp), %rcx
movq $0x0, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f86
leaq 0x20(%rsp), %rcx
movq %r15, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f86
leaq 0xa8(%rbx), %rdi
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
movq %r14, %rsi
callq 0x6264
movl 0x28(%rbx), %edx
movl 0x2c(%rbx), %ecx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x6264
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
leaq 0x20(%rsp), %rcx
movq %rax, -0x8(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f86
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x633f
movq 0x28(%rsp), %rdx
testq %rdx, %rdx
je 0x590a
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x5f46
leaq 0x1c(%rsp), %rcx
movl %ebp, -0x4(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f86
leaq 0x19(%rsp), %rcx
movb $0x0, -0x1(%rcx)
movq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x5f86
movq %rbx, %rdi
callq 0x5dba
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5954
callq 0x33c0
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x5976
callq 0x33c0
movq %rbx, %rdi
callq 0x3690
// File: /workspace/github_cpp_makefile_star2_O1/CoinBlack[P]blackcoin-seeder/protocol.cpp
// Function: CMessageHeader::CMessageHeader(char const*, unsigned int)
CMessageHeader::CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn)
{
    memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
    size_t command_len = strnlen(pszCommand, COMMAND_SIZE);
    memcpy(pchCommand, pszCommand, command_len);
    memset(pchCommand + command_len, 0, COMMAND_SIZE - command_len);
    nMessageSize = nMessageSizeIn;
    nChecksum = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x121cb(%rip), %eax     # 0x1d3e4
movl %eax, (%rdi)
movl $0xc, %r12d
movl $0xc, %esi
movq %r14, %rdi
callq 0x3610
movq %rax, %r13
leaq 0x4(%r15), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3340
leaq (%r15,%r13), %rdi
addq $0x4, %rdi
subq %r13, %r12
xorl %esi, %esi
movq %r12, %rdx
callq 0x3210
movl %ebx, 0x10(%r15)
movl $0x0, 0x14(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop