LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x10(%rbp)
movq -0xc0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movq (%rax), %rdi
callq 0x32280
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
jae 0x31bfe
movq -0xc0(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0xd8(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x322d0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0xe0(%rbp)
movq (%rax), %rdi
callq 0x322f0
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movq %rax, %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x32310
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x322a0
jmp 0x31bca
leaq -0x40(%rbp), %rdi
callq 0x32360
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x31b22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x32360
jmp 0x31d20
movq $0x0, -0x58(%rbp)
movq -0xc0(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0xf0(%rbp)
movq (%rax), %rdi
callq 0x322f0
movq %rax, %rcx
movq -0xf0(%rbp), %rax
cmpq %rcx, %rax
jae 0x31d17
movq -0xc0(%rbp), %rax
movq (%rax), %rdi
movq -0x58(%rbp), %rsi
callq 0x322d0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x108(%rbp)
movq (%rax), %rdi
callq 0x32280
movq -0x108(%rbp), %rsi
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x4730
movq -0xc0(%rbp), %rcx
movq -0x100(%rbp), %rdx
movq %rcx, %rax
addq $0x28, %rax
movq %rax, -0xf8(%rbp)
movq -0x58(%rbp), %rsi
addq $0x10, %rcx
leaq -0xb8(%rbp), %rdi
callq 0x323b0
jmp 0x31cab
movq -0xf8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x32380
jmp 0x31cc0
leaq -0xb8(%rbp), %rdi
callq 0x32410
leaq -0x70(%rbp), %rdi
callq 0x8dc0
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x31c06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x31d0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x32410
leaq -0x70(%rbp), %rdi
callq 0x8dc0
jmp 0x31d20
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x32f0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
callq 0x32440
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jne 0x31e1e
leaq -0x28(%rbp), %rdi
callq 0x8c90
movq -0x68(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x32470
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x324a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x324d0
testb $0x1, %al
jne 0x31dae
jmp 0x31e00
leaq -0x38(%rbp), %rdi
callq 0x32510
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x32070
movq %rax, -0x70(%rbp)
jmp 0x31dca
movq -0x70(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x8bc0
jmp 0x31dd9
jmp 0x31ddb
leaq -0x38(%rbp), %rdi
callq 0x32530
jmp 0x31d9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8dc0
jmp 0x31ea5
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32550
jmp 0x31e13
leaq -0x28(%rbp), %rdi
callq 0x8dc0
jmp 0x31e9c
jmp 0x31e20
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x325c0
movq %rax, %rdi
callq 0x317f0
testb $0x1, %al
jne 0x31e3f
jmp 0x31e52
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x31d30
jmp 0x31e20
jmp 0x31e54
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x28, %rdi
callq 0x32440
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x31e9c
movq -0x68(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x325c0
movq %rax, %rdi
callq 0x325e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x31e54
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x32f0
nop
// File: zvrba[P]nonogram/./Solver.h
// Function: nonogram::RowAgent::reset()
void reset()
  {
    if (_coloring < _enumeratedColorings.size())
      throw std::logic_error("RowAgent::next: agent not exhausted");
    _coloring = static_cast<size_t>(-1);
    _placedCells.clear();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x28(%rdi), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x30ca0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x32661
movl $0x10, %edi
callq 0x30e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x5ed7(%rip), %rsi      # 0x38503
callq 0x3260
jmp 0x32633
movq -0x30(%rbp), %rdi
movq 0x26992(%rip), %rsi     # 0x58fd0
movq 0x26973(%rip), %rdx     # 0x58fb8
callq 0x32e0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3160
jmp 0x3267c
movq -0x28(%rbp), %rdi
movq $-0x1, 0x28(%rdi)
addq $0x30, %rdi
callq 0x32050
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x32f0
nopw %cs:(%rax,%rax)
nop
// File: zvrba[P]nonogram/main.cpp
// Function: print_solution(std::vector<std::vector<std::tuple<unsigned long, unsigned long>, std::allocator<std::tuple<unsigned long, unsigned long>>>, std::allocator<std::vector<std::tuple<unsigned long, unsigned long>, std::allocator<std::tuple<unsigned long, unsigned long>>>>> const&)
static void print_solution(const Solver::Solution& solution)
{
  for (const LineColoring& line : solution) {
    size_t column = 0;
    for (const Block& block : line) {
      const auto blockBegin = std::get<0>(block);
      const auto blockEnd = std::get<1>(block);
      for (; column < blockBegin; ++column)
        cout << '.';
      for (; column < blockEnd; ++column)
        cout << '#';
    }
    cout << '\n';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x329b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x329e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x32c10
testb $0x1, %al
jne 0x36704
jmp 0x36801
leaq -0x18(%rbp), %rdi
callq 0x32c80
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2a100
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2a180
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x30950
testb $0x1, %al
jne 0x36751
jmp 0x367e2
leaq -0x40(%rbp), %rdi
callq 0x2a790
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2cdb0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2d770
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x367a7
movq 0x22831(%rip), %rdi     # 0x58fc0
movl $0x2e, %esi
callq 0x3200
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3677e
jmp 0x367a9
movq -0x30(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x367d2
movq 0x22806(%rip), %rdi     # 0x58fc0
movl $0x23, %esi
callq 0x3200
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x367a9
jmp 0x367d4
leaq -0x40(%rbp), %rdi
callq 0x2a850
jmp 0x3673b
movq 0x227d7(%rip), %rdi     # 0x58fc0
movl $0xa, %esi
callq 0x3200
leaq -0x18(%rbp), %rdi
callq 0x32ca0
jmp 0x366ee
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x5b7e
movq (%rsp), %rdi
movl (%rdi), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x6fc0
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
movq 0x8(%rax), %rcx
movl 0x4(%rax), %esi
imulq $0xc, %rsi, %rsi
addq %rsi, %rcx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movl 0x8(%rdx), %edx
movl %edx, 0x8(%rcx)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x5c28
movq (%rsp), %rdi
movl (%rdi), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x6fc0
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %rdi
callq 0x5bb0
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x4(%rax), %edx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq 0xc(%rsp), %rdx
movq %rdx, (%rcx)
movl 0x14(%rsp), %edx
movl %edx, 0x8(%rcx)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x38, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rcx), %rdx
subq %rdx, %rax
movl $0xc, %esi
cqto
idivq %rsi
movq %rax, %rdx
movq 0x10(%rsp), %rax
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movq %rax, 0x28(%rsp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x5ce2
movq 0x8(%rsp), %rdi
movl (%rdi), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x6fc0
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rdi
addq $0xc, %rdi
movq 0x28(%rsp), %rsi
movl 0x4(%rcx), %eax
movq %rax, (%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl $0xc, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
imulq $0xc, %rax, %rdx
callq 0x1120
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x1c(%rsp), %rdi
callq 0x5bb0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x1c(%rsp), %rdx
movq %rdx, (%rcx)
movl 0x24(%rsp), %edx
movl %edx, 0x8(%rcx)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
subq %rdx, %rax
sarq $0x2, %rax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x5e4b
movq (%rsp), %rdi
movl 0x8(%rsp), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x54d0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0x5e8e
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0x5e53
movq (%rsp), %rax
movl 0x8(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nop
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::vector(std::initializer_list<int>)
vector<T>::vector(std::initializer_list<T> lst) {
		rsrv_sz = lst.size() << 2;
		arr = new T[rsrv_sz];
		for (auto &item: lst)
			arr[vec_sz++] = item;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x4, (%rax)
movl $0x0, 0x4(%rax)
leaq 0x38(%rsp), %rdi
callq 0x70d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
shlq $0x2, %rcx
movl %ecx, (%rax)
movl (%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x70e0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x70f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x5fdf
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edx
movq 0x8(%rsi), %rax
movl 0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0x5f99
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::swap(lni::vector<int>&)
void vector<T>::swap(vector<T> &rhs) {
		size_t tvec_sz = vec_sz,
			   trsrv_sz = rsrv_sz;
		T *tarr = arr;

		vec_sz = rhs.vec_sz;
		rsrv_sz = rhs.rsrv_sz;
		arr = rhs.arr;

		rhs.vec_sz = tvec_sz;
		rhs.rsrv_sz = trsrv_sz;
		rhs.arr = tarr;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %ecx
movq %rcx, -0x18(%rsp)
movl (%rax), %ecx
movq %rcx, -0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rsp), %rax
movl %eax, %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x28(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::vector(unsigned int, double const&)
vector<T>::vector(typename vector<T>::size_type n, const T &value) {
		size_type i;
		rsrv_sz = n << 2;
		arr = new T[rsrv_sz];
		for (i = 0; i < n; ++i)
			arr[i] = value;
		vec_sz = n;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x4, (%rax)
movl $0x0, 0x4(%rax)
movl 0x1c(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, (%rax)
movl (%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x6108
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x60d7
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::vector(lni::vector<double> const&)
vector<T>::vector(const vector<T> &other) {
		size_type i;
		rsrv_sz = other.rsrv_sz;
		arr = new T[rsrv_sz];
		for (i = 0; i < other.vec_sz; ++i)
			arr[i] = other.arr[i];
		vec_sz = other.vec_sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x4, (%rax)
movl $0x0, 0x4(%rax)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movl (%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x6214
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl 0x14(%rsp), %edx
movsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x61d5
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x8(%rcx), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rcx), %rsi
subq %rsi, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
addq %rdx, %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x6373
movq (%rsp), %rdi
movl (%rdi), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x58c0
movq (%rsp), %rcx
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
callq 0x1120
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rcx)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, (%rsp)
movq 0x8(%rdx), %rax
movq 0x30(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x643c
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x64f8
movq (%rsp), %rcx
movl 0x4(%rcx), %eax
addl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x6460
movq (%rsp), %rdi
movl 0x4(%rdi), %eax
addl 0x14(%rsp), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x58c0
movq (%rsp), %rcx
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x30(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
callq 0x1120
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x64e0
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
jmp 0x64a4
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x30(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x6567
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x661f
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %eax
addl 0x2c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x658d
movq 0x8(%rsp), %rdi
movl 0x4(%rdi), %eax
addl 0x2c(%rsp), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x58c0
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x30(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
callq 0x1120
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x2c(%rsp)
cmpl $0x0, %eax
je 0x6615
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x65e1
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7130
movq (%rsp), %rdx
movl %eax, 0x3c(%rsp)
movq 0x8(%rdx), %rax
movq 0x40(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x6699
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x6787
movq (%rsp), %rcx
movl 0x4(%rcx), %eax
addl 0x3c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x66bd
movq (%rsp), %rdi
movl 0x4(%rdi), %eax
addl 0x3c(%rsp), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x58c0
movq (%rsp), %rcx
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x40(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
callq 0x1120
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7140
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7150
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x676f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x6729
movq (%rsp), %rax
movl 0x3c(%rsp), %ecx
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x6808
movb $0x0, -0x1(%rsp)
jmp 0x6863
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jae 0x685e
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x6848
jp 0x6848
jmp 0x684f
movb $0x0, -0x1(%rsp)
jmp 0x6863
jmp 0x6851
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x6810
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x6898
movb $0x1, -0x1(%rsp)
jmp 0x68f3
movl $0x0, -0x1c(%rsp)
movq -0x28(%rsp), %rcx
movl -0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jae 0x68ee
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x68d8
jp 0x68d8
jmp 0x68df
movb $0x1, -0x1(%rsp)
jmp 0x68f3
jmp 0x68e1
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x68a0
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x692f
movq -0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rsp)
jmp 0x693b
movq -0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rsp)
movl -0x34(%rsp), %eax
movl %eax, -0x24(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x24(%rsp), %eax
jae 0x69c1
movq -0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
ucomisd (%rax,%rcx,8), %xmm0
jne 0x697f
jp 0x697f
jmp 0x69b2
movq -0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x69da
jmp 0x69b4
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x694b
movq -0x30(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq 0x3bc5(%rip), %rdi      # 0x5fd0
leaq 0x1bf2(%rip), %rsi      # 0x4004
callq 0x2130
movq 0x3bb2(%rip), %rdi      # 0x5fd0
leaq 0x1bf8(%rip), %rsi      # 0x401d
callq 0x2130
xorl %edi, %edi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x253c
callq 0x2400
movl $0x10, %edi
callq 0x2140
movq %rax, -0x60(%rbp)
jmp 0x254c
movb $0x1, -0x4a(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2280
movq -0x68(%rbp), %rdx
leaq 0x1afb(%rip), %rsi      # 0x4063
leaq -0x48(%rbp), %rdi
callq 0x2bd0
jmp 0x2573
movq -0x60(%rbp), %rdi
xorl %esi, %esi
leaq -0x48(%rbp), %rdx
movl $0x64, %ecx
callq 0x20e0
jmp 0x2589
movq -0x60(%rbp), %rax
movb $0x0, -0x4a(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20b0
leaq -0x49(%rbp), %rdi
callq 0x2180
movq -0x18(%rbp), %rdi
callq 0x26d0
movb %al, -0x69(%rbp)
jmp 0x25b5
movb -0x69(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x266e
jmp 0x264b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x261d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x25fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20b0
leaq -0x49(%rbp), %rdi
callq 0x2180
testb $0x1, -0x4a(%rbp)
jne 0x260d
jmp 0x261b
movq -0x60(%rbp), %rdi
movl $0x10, %esi
callq 0x2150
jmp 0x261d
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x26be
movq -0x20(%rbp), %rdi
callq 0x2090
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x2250
jmp 0x264b
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x2663
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
leaq -0x239(%rip), %rsi      # 0x2440
xorl %eax, %eax
movl %eax, %edx
callq 0x2c80
jmp 0x2684
movq -0x18(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x2cb0
jmp 0x2695
movq 0x3934(%rip), %rdi      # 0x5fd0
leaq 0x19d4(%rip), %rsi      # 0x4077
callq 0x2130
jmp 0x26aa
movq 0x392f(%rip), %rdi      # 0x5fe0
leaq -0x4b(%rbp), %rsi
callq 0x2200
jmp 0x26bc
jmp 0x2649
movq -0x20(%rbp), %rdi
callq 0x2270
nopw (%rax,%rax)
// File: sisong[P]ApkDiffPatch/src/normalized/normalized.cpp
// Function: getAllFiles(UnZipper const*, std::vector<TFileValue, std::allocator<TFileValue>>&)
static void getAllFiles(const UnZipper* zip,std::vector<TFileValue>& out_files){
    int fileCount=UnZipper_fileCount(zip);
    out_files.resize(fileCount);
    for (int i=0; i<fileCount; ++i) {
        TFileValue& fi=out_files[i];
        fi.fileIndex=i;
        fi.fileName.assign(zipFile_name(zip,i));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x186a0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x6440
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x57ec
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5e30
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x5bb0
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3380
leaq -0x40(%rbp), %rdi
callq 0x3260
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5790
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa1d0
testb $0x1, %al
jne 0xa136
jmp 0xa1bc
movq -0x20(%rbp), %rax
movslq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x341f0(%rip), %rsi     # 0x3e340
callq 0xa230
testb $0x1, %al
jne 0xa15b
jmp 0xa16c
movq -0x20(%rbp), %rax
movslq (%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xa1ba
movq -0x10(%rbp), %rdi
leaq 0x341cd(%rip), %rsi     # 0x3e344
callq 0xa230
testb $0x1, %al
jne 0xa182
jmp 0xa196
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xa1b8
movq -0x10(%rbp), %rdi
callq 0xa290
testb $0x1, %al
jne 0xa1a5
jmp 0xa1b6
movq -0x20(%rbp), %rax
imull $0x3, (%rax), %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xa1b8
jmp 0xa1ba
jmp 0xa1bc
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::CPU()
CPU::CPU()
{
    setR1(0);
    setR2(0);
    setR3(0);
    setR4(0);
    setR5(0);
    setPC(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x1, 0x14(%rdi)
xorl %esi, %esi
callq 0x2930
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2950
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2970
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x2990
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x29b0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x29d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::CPU(int)
CPU::CPU(int option)
{
    setR1(0);
    setR2(0);
    setR3(0);
    setR4(0);
    setR5(0);
    setPC(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x1, 0x14(%rdi)
xorl %esi, %esi
callq 0x2930
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2950
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2970
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x2990
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x29b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x29d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x1, 0x14(%rdi)
movl -0xc(%rbp), %esi
callq 0x2930
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x2950
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2970
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x2990
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x29b0
movq -0x28(%rbp), %rdi
movl 0x10(%rbp), %esi
callq 0x29d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xd3a5(%rip), %rdi      # 0xffd0
leaq 0xa445(%rip), %rsi      # 0xd077
callq 0x20f0
movq %rax, %rdi
movq 0xd37f(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0xa41f(%rip), %rsi      # 0xd06f
callq 0x20f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xa41f(%rip), %rsi      # 0xd088
callq 0x20f0
movq -0x18(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x2b40
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x21c0
movq %rax, %rdi
movq 0xd330(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0xa3d0(%rip), %rsi      # 0xd06f
callq 0x20f0
movq %rax, %rdi
movl $0x1, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xa3cd(%rip), %rsi      # 0xd088
callq 0x20f0
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x2b50
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x21c0
movq %rax, %rdi
movq 0xd2de(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0xa37e(%rip), %rsi      # 0xd06f
callq 0x20f0
movq %rax, %rdi
movl $0x2, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xa37b(%rip), %rsi      # 0xd088
callq 0x20f0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x2b70
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x21c0
movq %rax, %rdi
movq 0xd28c(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0xa32c(%rip), %rsi      # 0xd06f
callq 0x20f0
movq %rax, %rdi
movl $0x3, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xa329(%rip), %rsi      # 0xd088
callq 0x20f0
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x2b90
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x21c0
movq %rax, %rdi
movq 0xd23a(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0xa2da(%rip), %rsi      # 0xd06f
callq 0x20f0
movq %rax, %rdi
movl $0x4, %esi
callq 0x21c0
movq %rax, %rdi
leaq 0xa2d7(%rip), %rsi      # 0xd088
callq 0x20f0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x2bb0
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x21c0
movq %rax, %rdi
movq 0xd1e8(%rip), %rsi      # 0xffc0
callq 0x2100
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
callq 0x21a0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x9e3a
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x9e14
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x9e2d
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x9e2d
movb $0x0, -0x11(%rbp)
jmp 0x9e2f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9de2
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x21a0
movq -0x30(%rbp), %rdi
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9ebb
movb $0x1, -0x21(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9edb
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x9ed9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9edb
jmp 0x9edd
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x9f16
movq -0x30(%rbp), %rdi
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x2200
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9edd
testb $0x1, -0x21(%rbp)
je 0x9f23
imull $-0x1, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::isMemory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CPU::isMemory(string ch)
{
    bool result = false;

    if(ch[0] == '#')
        result = true;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rax
movq -0x20(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2200
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x9f64
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: salihbektas[P]Simple-CPU-emulator/cpu.cpp
// Function: CPU::halted()
bool CPU::halted()
{
    bool result = false;

    if(getPC() == getMaxLine())
        result = true;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x2bd0
movq -0x18(%rbp), %rdi
movl %eax, -0x10(%rbp)
callq 0x2bf0
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jne 0x9fa6
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movq $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, -0x38(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x21e0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x305a(%rip), %rsi      # 0xd29b
callq 0x2180
jmp 0xa248
leaq -0x11(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x48(%rbp)
jmp 0xa28a
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x58(%rbp)
cmpq $0x0, %rax
je 0xa2df
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2190
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0xa2bd
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa365
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x28(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq 0x8(%rcx), %rdi
addq %rax, %rdi
callq 0x2040
jmp 0xa32a
jmp 0xa32c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa2fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x2110
jmp 0xa36b
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20a0
jmp 0xa36b
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)