LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::operator==(lni::vector<double> const&) const
bool vector<T>::operator == (const vector<T> &rhs) const {
		if (vec_sz != rhs.vec_sz) return false;
		size_type i;
		for (i = 0; i < vec_sz; ++i)
			if (arr[i] != rhs.arr[i])
				return false;
		return true;
	}

// Assembly:
movl 0x4(%rdi), %ecx
cmpl 0x4(%rsi), %ecx
jne 0x37f9
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
sete %al
je 0x37f8
movsd (%rdx,%rdi,8), %xmm0
ucomisd (%rsi,%rdi,8), %xmm0
leaq 0x1(%rdi), %rdi
jne 0x37f8
jnp 0x37de
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::operator!=(lni::vector<double> const&) const
bool vector<T>::operator != (const vector<T> &rhs) const {
		if (vec_sz != rhs.vec_sz) return true;
		size_type i;
		for (i = 0; i < vec_sz; ++i)
			if (arr[i] != rhs.arr[i])
				return true;
		return false;
	}

// Assembly:
movl 0x4(%rdi), %ecx
movb $0x1, %al
cmpl 0x4(%rsi), %ecx
jne 0x382a
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
setne %al
je 0x382a
movsd (%rdx,%rdi,8), %xmm0
ucomisd (%rsi,%rdi,8), %xmm0
leaq 0x1(%rdi), %rdi
jne 0x382a
jnp 0x3810
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::operator<(lni::vector<double> const&) const
bool vector<T>::operator < (const vector<T> &rhs) const {
		size_type i, j, ub = vec_sz < rhs.vec_sz ? vec_sz : rhs.vec_sz;
		for (i = 0; i < ub; ++i)
			if (arr[i] != rhs.arr[i])
				return arr[i] < rhs.arr[i];
		return vec_sz < rhs.vec_sz;
	}

// Assembly:
movl 0x4(%rdi), %eax
movl 0x4(%rsi), %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
setb %al
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x3865
movsd (%rdx,%rdi,8), %xmm0
movsd (%rsi,%rdi,8), %xmm1
incq %rdi
ucomisd %xmm1, %xmm0
jne 0x385e
jnp 0x3844
ucomisd %xmm0, %xmm1
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cac(%rip), %rbx      # 0x4fd0
leaq 0xcd9(%rip), %rsi       # 0x3004
movq %rbx, %rdi
callq 0x2100
leaq 0xce3(%rip), %rsi       # 0x301d
movq %rbx, %rdi
callq 0x2100
xorl %edi, %edi
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24ec
xorl %r12d, %r12d
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %rbx
leaq 0xc16(%rip), %rsi       # 0x3063
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2828
leaq 0x8(%rsp), %rdx
pushq $0x64
popq %rcx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %r12
movq %rbx, %rdi
callq 0x2551
testb %al, %al
je 0x24d5
leaq -0x145(%rip), %rsi      # 0x2349
movq %rbx, %r12
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2864
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %rbx, %r12
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x48(%rax)
movq 0x2b1b(%rip), %rdi      # 0x4fd0
leaq 0xbbb(%rip), %rsi       # 0x3077
movq %rbx, %r12
callq 0x2100
movq 0x2b15(%rip), %rdi      # 0x4fe0
leaq 0x7(%rsp), %rsi
callq 0x2160
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 0x231c
movq %rdx, %r15
movq %rax, %r14
jmp 0x2529
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x2511
movq %rdx, %r15
movq %rax, %r14
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x2120
xorl %ebx, %ebx
jmp 0x2529
movq %rdx, %r15
movq %rax, %r14
movq %r12, %rbx
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x254c
callq 0x2060
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
callq 0x21a0
testq %rbx, %rbx
jne 0x24d5
jmp 0x24de
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rdi
callq 0x5afe
testb %al, %al
je 0x5af5
movslq (%r14), %rax
addq %rax, %rbx
leaq 0x18546(%rip), %rsi     # 0x1dff6
movq %r15, %rdi
callq 0x5b32
testb %al, %al
je 0x5ac4
movslq (%r14), %rax
addq %rax, %rbx
jmp 0x5af5
leaq 0x1852f(%rip), %rsi     # 0x1dffa
movq %r15, %rdi
callq 0x5b32
testb %al, %al
je 0x5ae0
movslq (%r14), %rax
leaq (%rbx,%rax,2), %rbx
jmp 0x5af5
movq %r15, %rdi
callq 0x5b62
testb %al, %al
je 0x5af5
movslq (%r14), %rax
leaq (%rax,%rax,2), %rax
jmp 0x5abf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/salihbektas[P]Simple-CPU-emulator/main.cpp
// Function: main
int main(int argc, char* argv[])
{
    int option;

    //Console argumans check
    if(argc != 3){
        cerr<< "Wrong Usage" << endl
            << "Example Usage: "<<argv[0]<<" <file_name.txt> <option>" << endl;
        return 1;
    }
    //Option check
    if (argv[2][0] != '0' && argv[2][0] != '1' && argv[2][0] != '2'){
        cerr << "Wrong option" << endl
             << "Option must be 0, 1 or 2" << endl;
        return 1;
    }

    if (argv[2][0] == '0')
        option = 0;
    else if (argv[2][0] == '1')
        option = 1;
    else if (argv[2][0] == '2')
        option = 2;

    CPU myCPU;
    CPUProgramDyn myProg(argv[1]);
    Memory myMemory;

    Computer myComputer(myCPU, myProg, myMemory, option);
    myComputer.execute();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x370, %rsp            # imm = 0x370
movq %rsi, %r14
cmpl $0x3, %edi
jne 0x2492
movq 0x10(%r14), %rax
movb (%rax), %al
leal -0x30(%rax), %ecx
cmpb $0x3, %cl
jae 0x24d0
xorl %ecx, %ecx
cmpb $0x31, %al
sete %cl
cmpb $0x32, %al
pushq $0x2
popq %rbx
cmovnel %ecx, %ebx
leaq -0x4c(%rbp), %rdi
callq 0x261c
movq 0x8(%r14), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x5c7a
leaq -0x298(%rbp), %rdi
callq 0x2544
movups -0x4c(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movaps %xmm0, -0x30(%rbp)
movups %xmm1, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x5bb0
leaq 0x20(%rsp), %rdi
pushq $0x19
popq %rcx
leaq -0x298(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movups -0x24(%rbp), %xmm0
movups %xmm0, 0xc(%rsp)
movaps -0x30(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x1d0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movl %ebx, %edx
callq 0x69b4
leaq -0x80(%rbp), %rdi
callq 0x5e20
leaq -0x1d0(%rbp), %rdi
callq 0x6b98
leaq -0x1b0(%rbp), %rdi
callq 0x5e20
leaq -0xb0(%rbp), %rdi
callq 0x5e20
xorl %eax, %eax
jmp 0x2505
movq 0x7b57(%rip), %rdi      # 0x9ff0
leaq 0x4b64(%rip), %rsi      # 0x7004
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0x4b5c(%rip), %rsi      # 0x7010
movq %rax, %rdi
callq 0x2100
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2100
leaq 0x4b52(%rip), %rsi      # 0x7020
jmp 0x24f2
movq 0x7b19(%rip), %rdi      # 0x9ff0
leaq 0x4b5c(%rip), %rsi      # 0x703a
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0x4b55(%rip), %rsi      # 0x7047
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
pushq $0x1
popq %rax
addq $0x370, %rsp            # imm = 0x370
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
jmp 0x2524
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x5e20
jmp 0x2530
jmp 0x252d
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x5e20
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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
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_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78c8(%rip), %rdi      # 0x9fd0
leaq 0x4968(%rip), %rsi      # 0x7077
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0x494c(%rip), %r14      # 0x706f
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
movq %rax, %rdi
xorl %esi, %esi
callq 0x2180
leaq 0x4949(%rip), %r15      # 0x7088
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movl (%rbx), %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2100
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movslq (%rdx), %rcx
leal 0x1(%rcx), %eax
addq (%r12), %rcx
xorl %r13d, %r13d
movabsq $0x800100100000601, %rdx # imm = 0x800100100000601
movzbl (%rcx,%r13), %esi
cmpq $0x3b, %rsi
ja 0x591e
btq %rsi, %rdx
jb 0x5932
movb %sil, -0xd0(%rbp,%r13)
leal (%rax,%r13), %esi
movl %esi, (%r14)
incq %r13
jmp 0x590d
movl %r13d, %eax
movb $0x0, -0xd0(%rbp,%rax)
leaq -0xd0(%rbp), %rsi
movq %rbx, %rdi
callq 0x21a0
movslq (%r14), %rax
movq (%r12), %rcx
movzbl (%rcx,%rax), %ecx
cmpq $0x2c, %rcx
ja 0x5972
movabsq $0x100100000200, %rdx   # imm = 0x100100000200
btq %rcx, %rdx
jae 0x5972
incl %eax
movl %eax, (%r14)
testq %r13, %r13
jne 0x59b6
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x2160
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0x58c6
leaq -0x68(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2090
leaq -0x48(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2090
jmp 0x59de
jmp 0x59db
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::isInteger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CPU::isInteger(string ch)
{
    bool result = true;
    int size;
    size = ch.length();

    for(int i = 0; i < size; ++i){
        if((ch[i] < '0' || ch[i] > '9') && ch[i] != '-')
            result = false;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rsi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movb $0x1, %al
cmpq %rdx, %rcx
je 0x5a2c
movq (%rsi), %rdi
movb (%rdi,%rdx), %dil
leal -0x3a(%rdi), %r8d
cmpb $0x2d, %dil
sete %dil
andb %al, %dil
cmpb $-0xa, %r8b
movzbl %dil, %edi
movzbl %al, %eax
cmovbl %edi, %eax
incq %rdx
jmp 0x59fe
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movslq 0x8(%rsi), %rax
movq (%rsi), %rdx
movb (%rdx), %cl
cmpb $0x2d, %cl
sete %sil
cmpb $0x23, %cl
sete %dil
orb %sil, %dil
movzbl %dil, %esi
xorl %edi, %edi
cmpq %rax, %rsi
jge 0x5a6c
imull $0xa, %edi, %edi
movsbl (%rdx,%rsi), %r8d
addl %r8d, %edi
addl $-0x30, %edi
incq %rsi
jmp 0x5a54
movl %edi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x16c6(%rip), %rsi      # 0x729b
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x2080
movslq (%r14), %r12
movq %r12, %r13
shlq $0x5, %r13
leaq 0x8(%r13), %rax
testq %r12, %r12
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %r12, (%rax)
leaq 0x8(%rax), %rcx
testl %r12d, %r12d
je 0x5c24
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x5c0e
movq %rcx, 0x8(%r15)
movl %r12d, (%r15)
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x5c55
movq 0x8(%r14), %rsi
addq %r12, %rsi
movq 0x8(%r15), %rdi
addq %r12, %rdi
callq 0x20b0
incq %r13
addq $0x20, %r12
jmp 0x5c31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c66
movq %rax, %r14
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e78
movl %eax, (%rbx)
movq 0x8(%rbx), %r12
testq %r12, %r12
je 0x5d2a
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x5d20
addq $-0x20, %r12
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x2090
addq $-0x20, %r13
jne 0x5d11
movq %r15, %rdi
callq 0x2150
movl (%rbx), %eax
movslq %eax, %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rax
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r12, (%rax)
testl %r12d, %r12d
je 0x5d6d
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x5d57
movq %rcx, 0x8(%rbx)
leaq -0x258(%rbp), %r15
movq %r15, %rdi
callq 0x2120
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x20f0
xorl %r15d, %r15d
leaq -0x258(%rbp), %r14
xorl %r12d, %r12d
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x5dcb
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x2050
incq %r12
addq $0x20, %r15
jmp 0x5dab
leaq -0x258(%rbp), %rdi
callq 0x2040
leaq -0x48(%rbp), %rdi
callq 0x2090
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 0x5e00
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2090
leaq -0x258(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %rbx
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x248(%rbp), %rdi
callq 0x2120
leaq -0x248(%rbp), %rdi
pushq $0x18
popq %rdx
movq %rbx, %rsi
callq 0x20f0
leaq -0x248(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2050
xorl %ebx, %ebx
leaq -0x248(%rbp), %r14
leaq -0x38(%rbp), %r15
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x228(%rbp,%rax)
jne 0x5efa
incl %ebx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
jmp 0x5ed6
leaq -0x248(%rbp), %rdi
callq 0x2040
leaq -0x248(%rbp), %rdi
callq 0x2060
leaq -0x38(%rbp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5f41
jmp 0x5f32
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x2060
leaq -0x38(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
js 0x5f7a
cmpl %edx, (%rsi)
jle 0x5f7a
movl %edx, %eax
shlq $0x5, %rax
addq 0x8(%rsi), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2160
jmp 0x5fbc
movq 0x404f(%rip), %rdi      # 0x9fd0
leaq 0x12a7(%rip), %rsi      # 0x722f
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0x12af(%rip), %rsi      # 0x724b
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5aa8
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x5bb0
leaq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x6134
leaq -0xb8(%rbp), %rdi
callq 0x5e20
leaq -0x88(%rbp), %rdi
callq 0x5e20
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x6066
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x605e
addq $-0x20, %r12
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x2090
addq $-0x20, %r13
jne 0x604f
movq %r15, %rdi
callq 0x2150
movl (%r14), %eax
leal -0x1(%rax), %r15d
movl %r15d, (%r14)
movslq %r15d, %r13
movq %r13, %r12
shlq $0x5, %r12
leaq 0x8(%r12), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovgq %rcx, %rdi
callq 0x2030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0x60b3
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r12
jne 0x609d
movq %rcx, 0x8(%r14)
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq %r15d, %rax
cmpq %rax, %r13
jge 0x60e4
movq -0x50(%rbp), %rsi
addq %r12, %rsi
movq 0x8(%r14), %rdi
addq %r12, %rdi
callq 0x20b0
incq %r13
movl (%r14), %r15d
addq $0x20, %r12
jmp 0x60bd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5bb0
leaq -0x58(%rbp), %rdi
callq 0x5e20
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 0x5e20
jmp 0x6123
jmp 0x6120
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x5e20
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12d
cmpl (%rsi), %r12d
je 0x61e4
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x6194
leaq -0x8(%r13), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%r13), %r12
testq %r12, %r12
je 0x6188
addq $-0x20, %r13
shlq $0x5, %r12
leaq (%r12,%r13), %rdi
callq 0x2090
addq $-0x20, %r12
jne 0x6179
movq -0x30(%rbp), %rdi
callq 0x2150
movl (%r15), %r12d
movq %rbx, -0x30(%rbp)
movslq %r12d, %rbx
movq %rbx, %r13
shlq $0x5, %r13
leaq 0x8(%r13), %rax
testl %ebx, %ebx
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %rbx, (%rax)
testl %ebx, %ebx
je 0x61d9
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x61c3
movq %rcx, 0x8(%r14)
movl %r12d, (%r14)
movq -0x30(%rbp), %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x620e
movq 0x8(%r15), %rsi
addq %r12, %rsi
movq 0x8(%r14), %rdi
addq %r12, %rdi
callq 0x20b0
incq %r13
addq $0x20, %r12
jmp 0x61ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5bb0
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_O2/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 0x5aa8
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x5bb0
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x6134
leaq -0x88(%rbp), %rdi
callq 0x5e20
leaq -0x58(%rbp), %rdi
callq 0x5e20
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x62b3
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x62ab
addq $-0x20, %r12
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x2090
addq $-0x20, %r13
jne 0x629c
movq %r15, %rdi
callq 0x2150
movl (%r14), %eax
leal -0x1(%rax), %r15d
movl %r15d, (%r14)
movslq %r15d, %r13
movq %r13, %r12
shlq $0x5, %r12
leaq 0x8(%r12), %rcx
testl %eax, %eax
pushq $-0x1
popq %rdi
cmovgq %rcx, %rdi
callq 0x2030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0x6300
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r12
jne 0x62ea
movq %rcx, 0x8(%r14)
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq %r15d, %rax
cmpq %rax, %r13
jge 0x6331
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movq 0x8(%r14), %rdi
addq %r12, %rdi
callq 0x20b0
incq %r13
movl (%r14), %r15d
addq $0x20, %r12
jmp 0x630a
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 0x5e20
jmp 0x6356
jmp 0x6353
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e20
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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+=(string instraction)
{
    if( instraction != ""){
        CPUProgramDyn temp;
        temp = *this;
        delete [] fileString;
        fileString = new string[numberOfLines+1];
        for(int i = 0; i < numberOfLines; ++i)
        {
            fileString[i] = temp.fileString[i];
        }
        fileString[numberOfLines] = instraction;
        ++numberOfLines;
        return *this;
    }

    else{
        cout << "Error: Empty string try to add object." << endl
             << "+= not proceed." << endl;

        CPUProgramDyn emptyObj;
        return emptyObj;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf11(%rip), %rsi       # 0x729b
movq %rdx, %rdi
callq 0x69a4
testb %al, %al
je 0x6495
movq %rbx, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5aa8
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x5bb0
leaq -0xc0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x6134
leaq -0xc0(%rbp), %rdi
callq 0x5e20
leaq -0x90(%rbp), %rdi
callq 0x5e20
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x641a
leaq -0x8(%rbx), %r12
movq -0x8(%rbx), %r13
testq %r13, %r13
je 0x6412
addq $-0x20, %rbx
shlq $0x5, %r13
leaq (%rbx,%r13), %rdi
callq 0x2090
addq $-0x20, %r13
jne 0x6403
movq %r12, %rdi
callq 0x2150
movl (%r14), %r12d
leal 0x1(%r12), %eax
movslq %eax, %rbx
movq %rbx, %r13
shlq $0x5, %r13
leaq 0x8(%r13), %rax
cmpl $-0x1, %r12d
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x2030
movq %rbx, (%rax)
leaq 0x8(%rax), %rcx
testl %ebx, %ebx
je 0x6465
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x644f
movq %rcx, 0x8(%r14)
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq %r12d, %rdi
cmpq %rdi, %rbx
jge 0x64d4
movq -0x58(%rbp), %rsi
addq %r13, %rsi
movq 0x8(%r14), %rdi
addq %r13, %rdi
callq 0x20b0
incq %rbx
movl (%r14), %r12d
addq $0x20, %r13
jmp 0x646e
movq 0x3b34(%rip), %rdi      # 0x9fd0
leaq 0xdbe(%rip), %rsi       # 0x7261
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0xdd1(%rip), %rsi       # 0x7288
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x5aa8
movq %rbx, %rax
jmp 0x6500
shlq $0x5, %rdi
addq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x20b0
incl (%r14)
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x5bb0
leaq -0x60(%rbp), %rdi
callq 0x5e20
movq -0x30(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x5e20
jmp 0x6528
jmp 0x6525
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x5e20
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
js 0x655a
cmpl %esi, (%rbx)
jle 0x655a
movl %esi, %eax
shlq $0x5, %rax
addq 0x8(%rbx), %rax
movq %rax, %rbx
jmp 0x6590
movq 0x3a6f(%rip), %rdi      # 0x9fd0
leaq 0xcc7(%rip), %rsi       # 0x722f
callq 0x2100
movq %rax, %rdi
callq 0x20a0
leaq 0xccf(%rip), %rsi       # 0x724b
movq %rax, %rdi
callq 0x2100
movq %rax, %rdi
callq 0x20a0
addq $0x10, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5aa8
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x5bb0
leaq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
movq %rbx, %rsi
callq 0x6134
leaq -0xc8(%rbp), %rdi
callq 0x5e20
leaq -0x68(%rbp), %rdi
callq 0x5e20
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2160
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rbx, %rsi
callq 0x6366
leaq -0x98(%rbp), %rdi
callq 0x5e20
leaq -0x38(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x6650
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x5e20
jmp 0x6650
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e20
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5aa8
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x5bb0
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x6134
leaq -0xa8(%rbp), %rdi
callq 0x5e20
leaq -0x58(%rbp), %rdi
callq 0x5e20
xorl %r15d, %r15d
leaq -0x78(%rbp), %r12
leaq -0xd8(%rbp), %r13
cmpl (%r14), %r15d
jge 0x66fa
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x5f52
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x6366
movq %r13, %rdi
callq 0x5e20
movq %r12, %rdi
callq 0x2090
incl %r15d
jmp 0x66c4
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x5e20
jmp 0x6730
jmp 0x672d
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2090
jmp 0x6730
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e20
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xb8, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5aa8
leaq -0xb0(%rbp), %rbx
movq %rbx, %rdi
callq 0x5aa8
movl (%r12), %eax
cmpl %r15d, %eax
setle %cl
cmpl %r14d, %eax
setle %al
orb %cl, %al
jne 0x67cf
leaq -0x80(%rbp), %rbx
leaq -0xe0(%rbp), %r13
cmpl %r14d, %r15d
jg 0x67ec
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x5f52
movq %r13, %rdi
leaq -0x60(%rbp), %rsi
movq %rbx, %rdx
callq 0x6366
movq %r13, %rdi
callq 0x5e20
movq %rbx, %rdi
callq 0x2090
incl %r15d
jmp 0x6798
movq 0x37fa(%rip), %rdi      # 0x9fd0
leaq 0xa52(%rip), %rsi       # 0x722f
callq 0x2100
movq %rax, %rdi
callq 0x20a0
jmp 0x67f0
leaq -0x60(%rbp), %rbx
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x5bb0
leaq -0xb0(%rbp), %rdi
callq 0x5e20
leaq -0x60(%rbp), %rdi
callq 0x5e20
movq -0x30(%rbp), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x684b
jmp 0x682e
movq %rax, %rbx
jmp 0x683f
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2090
leaq -0xb0(%rbp), %rdi
callq 0x5e20
leaq -0x60(%rbp), %rdi
callq 0x5e20
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
leaq -0x40(%rbp), %r12
cmpl (%r14), %r15d
jge 0x6980
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x5f52
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20e0
movq %r12, %rdi
callq 0x2090
movl (%r14), %eax
decl %eax
cmpl %eax, %r15d
je 0x697b
movq %rbx, %rdi
callq 0x20a0
incl %r15d
jmp 0x6943
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/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 0x261c
leaq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x5aa8
leaq 0x50(%r14), %r12
movq %r12, %rdi
callq 0x2544
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 0x5bb0
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x6a80
leaq 0x30(%rbp), %r15
leaq -0x58(%rbp), %rdi
callq 0x5e20
movl $0xc8, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x20c0
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 0x5e20
jmp 0x6a5a
movq %rax, %rbx
movq %r15, %rdi
callq 0x5e20
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_04.cc
// Function: main
int main(int argc, char const *argv[])
{
	std::vector<int> v = {1, 2, 3, 4, 5, 6};
	auto iterv = find(v.begin(), v.end(), 3);
	std::cout << (iterv != v.end() ? "found\n" : "not found\n");

	std::list<std::string> l = {"hello", "world", "cplusplus", "primer"};
	auto iterl = find(l.begin(), l.end(), "cplusplus");
	std::cout << (iterl != l.end() ? "found\n" : "not found\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movups 0xd6f(%rip), %xmm0      # 0x2004
leaq -0xe0(%rbp), %rbx
movaps %xmm0, (%rbx)
movabsq $0x600000005, %rax      # imm = 0x600000005
movq %rax, 0x10(%rbx)
leaq -0x58(%rbp), %r14
pushq $0x6
popq %rdx
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x144e
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movl $0x3, (%rbx)
leaq -0xe0(%rbp), %rdx
callq 0x1484
cmpq 0x8(%r14), %rax
leaq 0xd35(%rip), %r12       # 0x201c
leaq 0xd32(%rip), %rbx       # 0x2020
movq %rbx, %rsi
cmoveq %r12, %rsi
movq 0x2cdc(%rip), %rdi      # 0x3fd8
callq 0x10d0
leaq 0xd1f(%rip), %rsi       # 0x2027
leaq -0xe0(%rbp), %r14
leaq -0x25(%rbp), %rdx
movq %r14, %rdi
callq 0x1070
leaq -0xc0(%rbp), %r15
leaq 0xd04(%rip), %rsi       # 0x202d
leaq -0x24(%rbp), %rdx
movq %r15, %rdi
callq 0x1070
leaq -0xa0(%rbp), %r15
leaq 0xcf0(%rip), %rsi       # 0x2033
leaq -0x23(%rbp), %rdx
movq %r15, %rdi
callq 0x1070
leaq -0x80(%rbp), %r15
leaq 0xce3(%rip), %rsi       # 0x203d
leaq -0x22(%rbp), %rdx
movq %r15, %rdi
callq 0x1070
leaq -0x40(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
pushq $0x4
popq %rdx
leaq -0x21(%rbp), %rcx
callq 0x149e
pushq $0x60
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xe0, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1381
leaq -0x40(%rbp), %r14
movq (%r14), %rdi
leaq 0xc8a(%rip), %rdx       # 0x2033
movq %r14, %rsi
callq 0x14d8
cmpq %r14, %rax
cmoveq %r12, %rbx
movq 0x2c19(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10d0
leaq -0x40(%rbp), %rdi
callq 0x1514
leaq -0x58(%rbp), %rdi
callq 0x15be
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13ed
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1514
jmp 0x143d
movq %rax, %rbx
pushq $0x60
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xe0, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1402
jmp 0x143d
jmp 0x1422
jmp 0x1422
movq %rax, %rbx
addq $-0x20, %r15
movq %r15, %rdi
callq 0x1090
cmpq %r14, %r15
jne 0x1425
jmp 0x143d
jmp 0x143a
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x15be
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_04.cc
// Function: std::_List_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> find<std::_List_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char [10]>(std::_List_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::_List_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char const (&) [10])
InputIt find(InputIt first, InputIt last, const T& value)
{
	for (; first != last; ++first)
		if (*first == value)
			return first;
	return first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq %r15, %r14
je 0x1505
leaq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x17a8
testb %al, %al
jne 0x1505
movq (%r14), %r14
jmp 0x14eb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rcx
callq 0x46e8
testl %eax, %eax
jne 0x44fe
movq (%rbx), %rbp
movq %r15, %rax
subq %rbp, %rax
cmpq $0x2, %rax
jge 0x44df
pushq $-0x5
popq %rax
jmp 0x44fb
leaq 0x2(%rbp), %r13
movq %r13, (%rbx)
pushq $-0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x479e
testl %eax, %eax
je 0x450d
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%rbx), %eax
subl %r13d, %eax
movb %ah, (%rbp)
movl (%rbx), %eax
subl %r13d, %eax
movb %al, 0x1(%rbp)
xorl %eax, %eax
jmp 0x44fe
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe007(%rip), %rdx      # 0x1270e
callq 0x479e
testl %eax, %eax
jne 0x471f
movq (%rbx), %rcx
subq %rcx, %r14
cmpq $0x8, %r14
jge 0x472b
pushq $-0x4
popq %rax
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 0x4722
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x33c0
movq %rax, 0x30(%rsp)
movabsq $0x539a019ca550825, %rax # imm = 0x539A019CA550825
movq %rax, 0x28(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0xd2bf(%rip), %rsi      # 0x12004
leaq 0x58(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x8e4e
movzwl 0x10(%r14), %eax
movw %ax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x70(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x9cfc
leaq 0xd292(%rip), %rsi      # 0x1200c
movq %rbx, %rdi
callq 0x51c8
leaq 0x18757(%rip), %rax     # 0x1d4e0
leaq 0x18744(%rip), %rcx     # 0x1d4d4
movl (%rcx), %ecx
cmpb $0x0, (%rax)
movl $0x1f0c0c, %eax         # imm = 0x1F0C0C
movl $0x4df828, %edx         # imm = 0x4DF828
cmovnel %eax, %edx
testl %ecx, %ecx
cmovnel %ecx, %edx
movl %edx, 0x1c(%rsp)
leaq 0xd262(%rip), %rsi      # 0x12014
leaq 0x38(%rsp), %rdi
leaq 0x1b(%rsp), %r14
movq %r14, %rdx
callq 0x3180
movb $0x0, (%r14)
leaq 0x8(%rbx), %rdi
leaq 0xd485(%rip), %rsi      # 0x12258
callq 0x522e
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x5244
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x5244
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0x525c
leaq 0x70(%rsp), %rsi
movq %rax, %rdi
callq 0x525c
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x5276
leaq 0x38(%rsp), %rsi
movq %rax, %rdi
callq 0x528e
leaq 0x1c(%rsp), %rsi
movq %rax, %rdi
callq 0x522e
leaq 0x1b(%rsp), %rsi
movq %rax, %rdi
callq 0x52a2
movq %rbx, %rdi
callq 0x52ba
leaq 0x38(%rsp), %rdi
callq 0x31d0
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x36d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13865(%rip), %eax     # 0x1d414
movl %eax, (%rdi)
pushq $0xc
popq %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x3640
movq %rax, %r13
leaq 0x4(%r15), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3350
leaq (%r15,%r13), %rdi
addq $0x4, %rdi
subq %r13, %r12
xorl %esi, %esi
movq %r12, %rdx
callq 0x3220
movl %ebx, 0x10(%r15)
andl $0x0, 0x14(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq