LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zvrba[P]nonogram/Solver.cpp
// Function: nonogram::ColumnAgent::setCell(unsigned long)
bool ColumnAgent::setCell(size_t pos)
{
  using std::get;
  
  if (pos >= _lineSize)
    throw std::logic_error("ColumnAgent::setCell: invalid pos");
  if (_blocks.size() > _description.size())
    throw std::logic_error("Agent::setCell: too many blocks");

  // Determine whether to extend existing block or create a new one.
  if (!_blocks.empty())
  {
    auto& lastBlock = _blocks.back();

    const auto lastBlockIndex = _blocks.size()-1;
    const auto blockBegin = get<0>(lastBlock);
    const auto blockEnd = get<1>(lastBlock);

    if (blockEnd - blockBegin > _description[lastBlockIndex])
      throw std::logic_error("Agent::setCell: too long block");
    if (pos < blockEnd-1)
      throw std::logic_error("Agent::setCell: going backwards");

    // Extending last block if possible.
    if (pos == blockEnd) {
      if (blockEnd - blockBegin == _description[lastBlockIndex])
        return false;
      ++get<1>(lastBlock);
      return true;
    }
    // Not extending last block, proceed to create new.
  }
  
  // New block.
  if (_blocks.size() == _description.size())
    return false;
  _blocks.push_back(Block(pos, pos+1));
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, 0x10(%rdi)
jbe 0xad1f
movq 0x20(%rdi), %rax
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %r9
movq %rax, %rcx
subq %r9, %rcx
sarq $0x4, %rcx
movq (%rdx), %r8
movq 0x8(%rdx), %rdx
subq %r8, %rdx
sarq $0x2, %rdx
cmpq %rdx, %rcx
ja 0xad3d
cmpq %rax, %r9
je 0xacf0
movq -0x10(%rax), %r10
movq %r10, %r9
subq -0x8(%rax), %r9
movl -0x4(%r8,%rcx,4), %r8d
cmpq %r8, %r9
ja 0xad5b
leaq -0x1(%r10), %r11
cmpq %rsi, %r11
ja 0xad79
cmpq %rsi, %r10
jne 0xacf0
cmpq %r8, %r9
je 0xacf5
incq %rsi
movq %rsi, -0x10(%rax)
jmp 0xad15
cmpq %rdx, %rcx
jne 0xacf9
xorl %eax, %eax
jmp 0xad17
addq $0x18, %rdi
leaq 0x1(%rsi), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, %rsi
callq 0xb6aa
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x36b3(%rip), %rsi      # 0xe3e6
movq %rax, %rdi
callq 0x21f0
jmp 0xad95
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x36b7(%rip), %rsi      # 0xe408
movq %rax, %rdi
callq 0x21f0
jmp 0xad95
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x36b9(%rip), %rsi      # 0xe428
movq %rax, %rdi
callq 0x21f0
jmp 0xad95
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x36ba(%rip), %rsi      # 0xe447
movq %rax, %rdi
callq 0x21f0
movq 0xa234(%rip), %rsi      # 0x14fd0
movq 0xa215(%rip), %rdx      # 0x14fb8
movq %rbx, %rdi
callq 0x2250
jmp 0xadb1
jmp 0xadb1
jmp 0xadb1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/zvrba[P]nonogram/Solver.cpp
// Function: nonogram::ColumnAgent::clearCell(unsigned long)
void ColumnAgent::clearCell(size_t pos)
{
  using std::get;
  
  if (pos >= _lineSize)
    throw std::logic_error("ColumnAgent::clearCell: invalid pos");
  if (_blocks.empty())
    throw std::logic_error("Agent::clearCell: no blocks");
  
  auto& lastBlock = _blocks.back();
  
  if (pos != get<1>(lastBlock)-1)
    throw std::logic_error("Agent::clearCell: not last cell");
  if (get<1>(lastBlock) == get<0>(lastBlock))
    throw std::logic_error("Agent::clearCell: empty block");
  
  if (--get<1>(lastBlock) == get<0>(lastBlock))
    _blocks.pop_back();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x10(%rdi)
jbe 0xae06
movq 0x20(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xae24
movq -0x10(%rax), %rdx
leaq -0x1(%rdx), %rcx
cmpq %rsi, %rcx
jne 0xae42
movq -0x8(%rax), %rcx
cmpq %rcx, %rdx
je 0xae60
addq $-0x10, %rax
movq %rsi, (%rax)
cmpq %rsi, %rcx
jne 0xadfe
movq %rax, 0x20(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x364d(%rip), %rsi      # 0xe467
movq %rax, %rdi
callq 0x21f0
jmp 0xae7c
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x3653(%rip), %rsi      # 0xe48b
movq %rax, %rdi
callq 0x21f0
jmp 0xae7c
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x3651(%rip), %rsi      # 0xe4a7
movq %rax, %rdi
callq 0x21f0
jmp 0xae7c
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x3653(%rip), %rsi      # 0xe4c7
movq %rax, %rdi
callq 0x21f0
movq 0xa14d(%rip), %rsi      # 0x14fd0
movq 0xa12e(%rip), %rdx      # 0x14fb8
movq %rbx, %rdi
callq 0x2250
jmp 0xae98
jmp 0xae98
jmp 0xae98
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/zvrba[P]nonogram/Solver.cpp
// Function: nonogram::Solver::buildAgents()
void Solver::buildAgents()
{
  for (size_t i = 0; i < _description.width(); ++i)
    _columnAgents.push_back(ColumnAgent(i, _description.columns[i], _description.height()));
  for (size_t i = 0; i < _description.height(); ++i) {
    auto rowColorings = enumerateColorings(_description.rows[i], _description.width());
    _rowAgents.push_back(RowAgent(i, rowColorings, _columnAgents));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbp
movq (%rdi), %rax
movq 0x18(%rax), %rcx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
cmpq %rcx, 0x20(%rax)
je 0xb1c5
leaq 0x10(%rbp), %r14
leaq 0x30(%rsp), %r12
xorl %r13d, %r13d
leaq 0x18(%rsp), %rbx
xorl %r15d, %r15d
movq 0x8(%rax), %rdx
subq (%rax), %rdx
addq %r13, %rcx
sarq $0x3, %rdx
imulq %rdi, %rdx
movq %r15, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb9ae
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xb194
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
incq %r15
movq (%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
addq $0x18, %r13
cmpq %rdx, %r15
jb 0xb140
movq (%rax), %rsi
cmpq %rsi, 0x8(%rax)
je 0xb2a7
leaq 0x20(%rsp), %rbx
leaq 0x10(%rbp), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x28(%rbp), %rcx
movq %rcx, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x60(%rsp), %r13
xorl %r12d, %r12d
movq %rbp, %r15
addq %r14, %rsi
movq 0x20(%rax), %rdx
subq 0x18(%rax), %rdx
sarq $0x3, %rdx
imulq %rdi, %rdx
movq %r13, %rdi
callq 0x2cc1
movq %r12, 0x18(%rsp)
movq %rbx, %rbp
movq %rbx, %rdi
movq %r13, %rsi
callq 0xb51e
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $-0x1, 0x40(%rsp)
leaq 0x48(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xbbdc
movq %rbx, %rdi
callq 0xb662
movq %rbp, %rbx
movq %rbp, %rdi
callq 0x3cd2
movq %r13, %rdi
callq 0x3cd2
incq %r12
movq %r15, %rbp
movq (%r15), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rcx
addq $0x18, %r14
cmpq %rcx, %r12
jb 0xb1f4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xb2ce
movq %rbx, %rdi
movq %rax, %rbx
callq 0xb662
movq %rbp, %rdi
callq 0x3cd2
leaq 0x60(%rsp), %rdi
callq 0x3cd2
jmp 0xb2f4
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xb2f4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2190
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/zvrba[P]nonogram/Solver.cpp
// Function: nonogram::Solver::solve(unsigned long)
void Solver::solve(size_t i)
{
  if (i == _rowAgents.size()) {
    Solution solution;
    for (const auto& a : _rowAgents)
      solution.push_back(a.coloring());
    _solutions.push_back(solution);
    return;
  }
  
  while (_rowAgents[i].next())
    solve(i+1);
  
  for (; i < _rowAgents.size(); ++i)
    _rowAgents[i].reset();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r13
movq %r13, %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
imulq %r12, %rax
cmpq %rsi, %rax
jne 0xb383
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpq %r13, %r15
je 0xb36a
movq %rsp, %r14
movq 0x28(%r15), %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3c00
addq $0x48, %r15
cmpq %r13, %r15
jne 0xb349
movq 0x8(%rbx), %rdi
movq %rsp, %rsi
callq 0xb448
movq %rsp, %rdi
callq 0x3cd2
jmp 0xb405
movq %rsi, %r14
leaq (%rsi,%rsi,8), %r13
leaq (%r15,%r13,8), %rdi
callq 0xaeac
testb %al, %al
je 0xb3ba
leaq 0x1(%r14), %r15
shlq $0x3, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2fc
movq 0x28(%rbx), %rdi
addq %r13, %rdi
callq 0xaeac
testb %al, %al
jne 0xb39f
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
cmpq %r14, %rax
jbe 0xb405
leaq (,%r14,8), %rax
leaq (%rax,%rax,8), %r15
addq %r15, %rdi
callq 0xb474
incq %r14
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x48, %r15
cmpq %rax, %r14
jb 0xb3de
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xb415
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3cd2
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<test>::push_back(test&&)
void vector<T>::push_back(T &&val) {
		if (vec_sz == rsrv_sz) {
			rsrv_sz <<= 2;
			reallocate();
		}
		arr[vec_sz] = std::move(val);
		++vec_sz;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %r13d
cmpl (%rdi), %r13d
jne 0x4b58
leal (,%r13,4), %eax
movl %eax, (%rbx)
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%rbx), %r12
leaq (,%r13,4), %rax
leaq (%rax,%rax,2), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x4b52
movq %r12, %rdi
callq 0x10f0
movl 0x4(%rbx), %r13d
movq %r15, 0x8(%rbx)
jmp 0x4b5c
movq 0x8(%rbx), %r15
movl %r13d, %eax
leaq (%rax,%rax,2), %rax
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%r15,%rax,4)
movq (%r14), %rcx
movq %rcx, (%r15,%rax,4)
incl 0x4(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: void lni::vector<test>::emplace_back<int, int, int>(int&&, int&&, int&&)
void vector<T>::emplace_back(Args && ... args) {
		if (vec_sz == rsrv_sz) {
			rsrv_sz <<= 2;
			reallocate();
		}
		arr[vec_sz] = std::move( T( std::forward<Args>(args) ... ) );
		++vec_sz;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x4(%rdi), %r14d
cmpl (%rdi), %r14d
jne 0x4bf1
movq %rcx, (%rsp)
leal (,%r14,4), %eax
movl %eax, (%rbx)
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x1030
movq %rax, %r13
movq 0x8(%rbx), %rbp
leaq (,%r14,4), %rax
leaq (%rax,%rax,2), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10b0
testq %rbp, %rbp
je 0x4be7
movq %rbp, %rdi
callq 0x10f0
movl 0x4(%rbx), %r14d
movq %r13, 0x8(%rbx)
movq (%rsp), %rcx
jmp 0x4bf5
movq 0x8(%rbx), %r13
movl (%r12), %eax
movl (%r15), %edi
movl (%rcx), %edx
movl %r14d, %esi
leaq (%rsi,%rsi,2), %rsi
movl %eax, (%r13,%rsi,4)
movl %edi, 0x4(%r13,%rsi,4)
movl %edx, 0x8(%r13,%rsi,4)
incl 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: test* lni::vector<test>::emplace<int, int, int>(test const*, int&&, int&&, int&&)
typename vector<T>::iterator vector<T>::emplace(typename vector<T>::const_iterator it, Args && ... args) {
		iterator iit = &arr[it - arr];
		if (vec_sz == rsrv_sz) {
			rsrv_sz <<= 2;
			reallocate();
		}
		memmove(iit + 1, iit, (vec_sz - (it - arr)) * sizeof(T));
		(*iit) = std::move( T( std::forward<Args>(args) ... ) );
		++vec_sz;
		return iit;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movl 0x4(%rdi), %r12d
cmpl (%rdi), %r12d
jne 0x4c9d
leal (,%r12,4), %eax
movl %eax, (%r14)
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
callq 0x1030
movq %rax, %rbp
leaq (,%r12,4), %rax
leaq (%rax,%rax,2), %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x10b0
testq %r15, %r15
je 0x4c97
movq %r15, %rdi
callq 0x10f0
movl 0x4(%r14), %r12d
movq %rbp, 0x8(%r14)
jmp 0x4ca0
movq %r15, %rbp
leaq 0xc(%rbx), %rdi
movl %r12d, %eax
movq %rbx, %rcx
subq %rbp, %rcx
shrq $0x2, %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
imulq %rcx, %rdx
addq %rax, %rdx
shlq $0x2, %rdx
leaq (%rdx,%rdx,2), %rdx
movq %rbx, %rsi
callq 0x1130
movl (%r13), %eax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movq 0x10(%rsp), %rdx
movl (%rdx), %edx
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
incl 0x4(%r14)
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_O3/pritpal20[P]vector/./vector.hpp
// Function: void lni::vector<int>::assign<int*>(int*, int*)
void vector<T>::assign(InputIt first, InputIt last) {
		size_type i, count = last - first;
		if (count > rsrv_sz) {
			rsrv_sz = count << 2;
			reallocate();
		}
		for (i = 0; i < count; ++i, ++first)
			arr[i] = *first;
		vec_sz = count;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
subq %rsi, %rbx
shrq $0x2, %rbx
cmpl %ebx, (%rdi)
jae 0x4d5f
leal (,%rbx,4), %edi
movl %edi, (%r14)
shlq $0x2, %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%r14), %r13
movl 0x4(%r14), %edx
shlq $0x2, %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x4d59
movq %r13, %rdi
callq 0x10f0
movq %r12, 0x8(%r14)
jmp 0x4d63
testl %ebx, %ebx
je 0x4d7a
movq 0x8(%r14), %rax
movl %ebx, %ecx
xorl %edx, %edx
movl (%r15,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x4d6b
movl %ebx, 0x4(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::insert(double const*, double&&)
typename vector<T>::iterator vector<T>::insert(typename vector<T>::const_iterator it, T &&val) {
		iterator iit = &arr[it - arr];
		if (vec_sz == rsrv_sz) {
			rsrv_sz <<= 2;
			reallocate();
		}
		memmove(iit + 1, iit, (vec_sz - (it - arr)) * sizeof(T));
		(*iit) = std::move(val);
		++vec_sz;
		return iit;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r13
movl 0x4(%rdi), %ebp
cmpl (%rdi), %ebp
jne 0x4de7
leal (,%rbp,4), %edi
movl %edi, (%r14)
shlq $0x3, %rdi
callq 0x1030
movq %rax, %r12
leaq (,%rbp,8), %rdx
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x4de1
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r14), %ebp
movq %r12, 0x8(%r14)
jmp 0x4dea
movq %r13, %r12
leaq 0x8(%rbx), %rdi
movl %ebp, %edx
movq %rbx, %rax
subq %r12, %rax
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x1130
movsd (%r15), %xmm0
movsd %xmm0, (%rbx)
incl 0x4(%r14)
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_O3/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 0x4ef9
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rcx
movl 0x4(%rdi), %r13d
leal (%r13,%rbp), %edi
cmpl (%r12), %edi
jbe 0x4eb4
shll $0x2, %edi
movl %edi, (%r12)
shlq $0x3, %rdi
movq %rcx, 0x8(%rsp)
callq 0x1030
leaq (,%r13,8), %rdx
movq %rax, 0x10(%rsp)
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x10b0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4eaa
callq 0x10f0
movl 0x4(%r12), %r13d
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%r12)
movq %rbx, %rax
subq %rcx, %rax
movl %ebp, %ecx
leaq (%rbx,%rcx,8), %rdi
movl %r13d, %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x1130
cmpq %r14, %r15
je 0x4ef4
movq %rbx, %rax
movsd (%r15), %xmm0
movsd %xmm0, (%rax)
addq $0x8, %rax
addq $0x8, %r15
cmpq %r14, %r15
jne 0x4ede
addl %ebp, 0x4(%r12)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rsi, %r14
testl %edx, %edx
je 0x5052
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r13
movq %rcx, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq 0x8(%rdi), %rbp
movl 0x4(%rdi), %r14d
leal (%r14,%r12), %edi
cmpl (%r13), %edi
jbe 0x4f8d
shll $0x2, %edi
movl %edi, (%r13)
shlq $0x3, %rdi
callq 0x1030
movq %rax, %r15
leaq (,%r14,8), %rdx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x10b0
testq %rbp, %rbp
je 0x4f81
movq %rbp, %rdi
callq 0x10f0
movl 0x4(%r13), %r14d
movq %r15, 0x8(%r13)
movq %rbx, %rax
subq %r15, %rax
jmp 0x4f93
movq %rbx, %rax
subq %rbp, %rax
movl %r12d, %r15d
leaq (%rbx,%r15,8), %rdi
movl %r14d, %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x1130
addl %r12d, 0x4(%r13)
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
leaq 0x1(%r15), %rax
andq $-0x2, %rax
decq %r15
movq %r15, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
addq $0x8, %rbx
xorl %ecx, %ecx
movdqa 0x109b(%rip), %xmm2     # 0x6080
movdqa 0x10a3(%rip), %xmm3     # 0x6090
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movq %rcx, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
por %xmm2, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm1, %xmm6
pcmpeqd %xmm1, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x5036
movsd %xmm0, -0x8(%rbx,%rcx,8)
pxor %xmm4, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x5049
movsd %xmm0, (%rbx,%rcx,8)
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0x4ff5
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %rbx
testl %r14d, %r14d
je 0x5131
movq %rdx, %r15
movq %rdi, %r12
movl %r14d, %eax
movq 0x8(%rdi), %r13
movl 0x4(%rdi), %ebp
movq %rax, 0x10(%rsp)
leal (%rax,%rbp), %edi
cmpl (%r12), %edi
jbe 0x50eb
shll $0x2, %edi
movl %edi, (%r12)
shlq $0x3, %rdi
callq 0x1030
leaq (,%rbp,8), %rdx
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r13, %rsi
callq 0x10b0
testq %r13, %r13
je 0x50d9
movq %r13, %rdi
callq 0x10f0
movl 0x4(%r12), %ebp
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%r12)
movq %rbx, %rax
subq %rcx, %rax
jmp 0x50f1
movq %rbx, %rax
subq %r13, %rax
movl %r14d, %ecx
leaq (%rbx,%rcx,8), %rdi
movl %ebp, %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x1130
shlq $0x3, %r14
xorl %eax, %eax
movsd (%r15,%rax), %xmm0
movsd %xmm0, (%rbx,%rax)
addq $0x8, %rax
cmpq %rax, %r14
jne 0x5113
movq 0x10(%rsp), %rax
addl %eax, 0x4(%r12)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x254c
xorl %ebx, %ebx
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xbc1(%rip), %rsi       # 0x3063
leaq 0xbcd(%rip), %rdx       # 0x3076
leaq 0x8(%rsp), %rdi
callq 0x2a04
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x64, %ecx
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24de
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2100
movq %rbx, %rdi
callq 0x25b7
testb %al, %al
je 0x2535
movq 0x8(%rbx), %rdi
leaq -0x1bc(%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 0x2abd(%rip), %rdi      # 0x4fd0
leaq 0xb5d(%rip), %rsi       # 0x3077
movl $0x2f, %edx
callq 0x2110
movq 0x2ab5(%rip), %rdi      # 0x4fe0
leaq 0x7(%rsp), %rsi
callq 0x2140
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 0x2589
movq %rdx, %r15
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2578
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2100
jmp 0x2578
movq %rdx, %r15
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x2100
xorl %ebx, %ebx
jmp 0x258f
movq %rdx, %r15
movq %rax, %r14
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x25b2
callq 0x2060
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
callq 0x2180
testq %rbx, %rbx
jne 0x2535
jmp 0x253e
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ad41(%rip), %rsi     # 0x20fff
movl $0x9, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x34b0
testq %rax, %rax
je 0x62f1
leaq 0x1ad30(%rip), %rsi     # 0x21009
movl $0x9, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x34b0
testq %rax, %rax
jne 0x637b
movslq (%r14), %rax
addq %rax, %rbx
leaq 0x1acf8(%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 0x631f
movslq (%r14), %rax
jmp 0x6378
leaq 0x1acd4(%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 0x634b
movslq (%r14), %rax
leaq (%rbx,%rax,2), %rbx
jmp 0x637b
leaq 0x1acc1(%rip), %rsi     # 0x21013
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
je 0x6371
leaq 0x1acc3(%rip), %rsi     # 0x21028
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x637b
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_O3/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 0x975b(%rip), %r14      # 0xbfd0
leaq 0x67fb(%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 0x67b5(%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 0x67aa(%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_O3/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 0x6bac
btq %rsi, %rdx
jb 0x6bc0
movb %sil, -0xe0(%rbp,%r15)
leal (%rax,%r15), %esi
movl %esi, (%r14)
incq %r15
jmp 0x6b9b
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 0x6c12
movabsq $0x100100000200, %rdx   # imm = 0x100100000200
btq %rcx, %rdx
jae 0x6c12
incl %eax
movl %eax, (%r14)
testq %r15, %r15
jne 0x6c72
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x6d88
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq %r14, %rdx
callq 0x6b4c
leaq -0x78(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq (%r14), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x6c64
callq 0x2110
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x6c72
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 0x6c9f
callq 0x2110
jmp 0x6c9f
jmp 0x6c9c
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x6cad
callq 0x2110
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d5b
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 0x6d44
movl %esi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %esi, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2340(%rip), %rdx      # 0x92c5
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x8078
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 0x6fda
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x6fc1
movq %rcx, 0x8(%r15)
movl %r12d, (%r15)
cmpl $0x0, (%r14)
jle 0x700f
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 0x6fed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7020
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x7031
callq 0x2110
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x72aa
movl %eax, (%rbx)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x7104
leaq -0x8(%rcx), %r15
movq -0x8(%rcx), %r12
testq %r12, %r12
je 0x70fa
shlq $0x5, %r12
leaq (%r12,%rcx), %r13
addq $-0x10, %r13
negq %r12
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x70f0
callq 0x2110
addq $-0x20, %r13
addq $0x20, %r12
jne 0x70e2
movq %r15, %rdi
callq 0x2170
movl (%rbx), %eax
movslq %eax, %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r12, (%rax)
testl %r12d, %r12d
je 0x714e
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x7135
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 0x71cb
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 0x718f
leaq -0x258(%rbp), %rdi
callq 0x2050
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x71e9
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 0x7209
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x721e
callq 0x2110
leaq -0x258(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x736d
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 0x7331
leaq -0x250(%rbp), %rdi
callq 0x2050
leaq -0x250(%rbp), %rdi
callq 0x2060
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x7393
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 0x73bb
jmp 0x73ac
movq %rax, %rbx
leaq -0x250(%rbp), %rdi
callq 0x2060
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x73c9
callq 0x2110
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x740e
cmpl %edx, (%rsi)
jle 0x740e
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 0x6d88
jmp 0x74a1
movq 0x4bbb(%rip), %r14      # 0xbfd0
leaq 0x1e3d(%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 0x1e1b(%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_O3/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 0x6e28
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x6f54
leaq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x7636
leaq -0xb8(%rbp), %rdi
callq 0x7232
leaq -0x88(%rbp), %rdi
callq 0x7232
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x7558
leaq -0x8(%rax), %r15
movq -0x8(%rax), %r12
testq %r12, %r12
je 0x7550
shlq $0x5, %r12
leaq (%r12,%rax), %r13
addq $-0x10, %r13
negq %r12
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x7546
callq 0x2110
addq $-0x20, %r13
addq $0x20, %r12
jne 0x7538
movq %r15, %rdi
callq 0x2170
movl (%r14), %r15d
leal -0x1(%r15), %eax
movl %eax, (%r14)
movslq %eax, %r13
movq %r13, %r12
shlq $0x5, %r12
leaq 0x8(%r12), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovgq %rax, %rdi
callq 0x2030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0x75e1
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r12
jne 0x7594
movq %rcx, 0x8(%r14)
cmpl $0x2, %r15d
jl 0x75e5
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 0x75bd
jmp 0x75e5
movq %rcx, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f54
leaq -0x58(%rbp), %rdi
callq 0x7232
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 0x7232
jmp 0x7624
jmp 0x7621
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7232
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7701
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x76a7
leaq -0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq -0x8(%rax), %r13
testq %r13, %r13
je 0x769b
shlq $0x5, %r13
leaq (%rax,%r13), %r12
addq $-0x10, %r12
negq %r13
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x7691
callq 0x2110
addq $-0x20, %r12
addq $0x20, %r13
jne 0x7682
movq -0x30(%rbp), %rdi
callq 0x2170
movl (%r15), %r12d
movq %rbx, -0x30(%rbp)
movslq %r12d, %rbx
movq %rbx, %r13
shlq $0x5, %r13
leaq 0x8(%r13), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %rbx, (%rax)
testl %ebx, %ebx
je 0x76f3
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x76da
movq %rcx, 0x8(%r14)
movl %r12d, (%r14)
movl (%r15), %r12d
movq -0x30(%rbp), %rbx
testl %r12d, %r12d
jle 0x772e
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 0x770c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f54
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_O3/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 0x6e28
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x6f54
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %rbx, %rsi
callq 0x7636
leaq -0x88(%rbp), %rdi
callq 0x7232
leaq -0x58(%rbp), %rdi
callq 0x7232
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x77e1
leaq -0x8(%rax), %r15
movq -0x8(%rax), %r12
testq %r12, %r12
je 0x77d9
shlq $0x5, %r12
leaq (%r12,%rax), %r13
addq $-0x10, %r13
negq %r12
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x77cf
callq 0x2110
addq $-0x20, %r13
addq $0x20, %r12
jne 0x77c1
movq %r15, %rdi
callq 0x2170
movl (%r14), %r15d
leal -0x1(%r15), %eax
movl %eax, (%r14)
movslq %eax, %r13
movq %r13, %r12
shlq $0x5, %r12
leaq 0x8(%r12), %rax
testl %r15d, %r15d
movq $-0x1, %rdi
cmovgq %rax, %rdi
callq 0x2030
movq %r13, (%rax)
leaq 0x8(%rax), %rcx
testl %r13d, %r13d
je 0x786a
addq $0x18, %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r12
jne 0x781d
movq %rcx, 0x8(%r14)
cmpl $0x2, %r15d
jl 0x786e
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 0x7846
jmp 0x786e
movq %rcx, 0x8(%r14)
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 0x7232
jmp 0x7893
jmp 0x7890
movq %rax, %r14
movq %rbx, %rdi
callq 0x7232
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7b18
cmpl %esi, (%rbx)
jle 0x7b18
movl %esi, %eax
shlq $0x5, %rax
addq 0x8(%rbx), %rax
movq %rax, %rbx
jmp 0x7b9c
movq 0x44b1(%rip), %r14      # 0xbfd0
leaq 0x1733(%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 0x1711(%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_O3/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 0x6e28
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x6f54
leaq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rdx
movq %rbx, %rsi
callq 0x7636
leaq -0xc8(%rbp), %rdi
callq 0x7232
leaq -0x68(%rbp), %rdi
callq 0x7232
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x6d88
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rdx
movq %rbx, %rsi
callq 0x78a4
leaq -0x98(%rbp), %rdi
callq 0x7232
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x7c3e
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 0x7c73
callq 0x2110
jmp 0x7c73
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x7232
jmp 0x7c73
movq %rax, %r14
movq %rbx, %rdi
callq 0x7232
movq %r14, %rdi
callq 0x21c0
nop