LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/VoseTree.cc
// Function: VoseTree::toString[abi:cxx11]()
std::string VoseTree::toString() {

  std::stringstream ss;
  ss << "[" << total_weight << "]\n";
  std::for_each (nodes.cbegin(), nodes.cend(), [this,&ss] (vosetreenode v) {
    ss << "----> " << v.toString() << "\n";
  });
  ss << "\n";
  return ss.str();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x2a0(%rbp), %rdi
callq 0x2140
leaq -0x290(%rbp), %r14
leaq 0x7d1e(%rip), %rsi      # 0xb068
movl $0x1, %edx
movq %r14, %rdi
callq 0x2200
movq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x21d0
leaq 0x7d00(%rip), %rsi      # 0xb06a
movl $0x2, %edx
movq %rax, %rdi
callq 0x2200
movq %r15, -0x30(%rbp)
movq 0x38(%rbx), %r15
movq 0x40(%rbx), %rbx
cmpq %rbx, %r15
je 0x34bf
leaq -0xf8(%rbp), %r12
leaq -0xe0(%rbp), %r13
movb (%r15), %al
movb %al, -0x118(%rbp)
movq 0x8(%r15), %rax
movq %rax, -0x110(%rbp)
movq %r12, -0x108(%rbp)
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
addq %rsi, %rdx
leaq -0x108(%rbp), %rdi
callq 0x4420
movq 0x30(%r15), %rax
movq %rax, -0xe8(%rbp)
addq $0x38, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x3f36
movl $0x6, %edx
movq %r14, %rdi
leaq 0x7cd6(%rip), %rsi      # 0xb0cb
callq 0x2200
leaq -0x50(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x5bf0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r14, %rdi
callq 0x2200
movl $0x1, %edx
movq %rax, %rdi
leaq 0x8143(%rip), %rsi      # 0xb56c
callq 0x2200
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3440
callq 0x21c0
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x344e
callq 0x21c0
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x345c
callq 0x21c0
leaq -0xa0(%rbp), %rdi
callq 0x46c4
movq -0xb0(%rbp), %rax
testq %rax, %rax
je 0x3485
leaq -0xc0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0xd0(%rbp), %rax
testq %rax, %rax
je 0x349e
movq %r13, %rdi
movq %r13, %rsi
movl $0x3, %edx
callq *%rax
movq -0x108(%rbp), %rdi
cmpq %r12, %rdi
je 0x34af
callq 0x21c0
addq $0x90, %r15
cmpq %rbx, %r15
jne 0x339a
leaq 0x80a6(%rip), %rsi      # 0xb56c
movl $0x1, %edx
movq %r14, %rdi
callq 0x2200
movq -0x30(%rbp), %rbx
leaq -0x288(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
movq 0xcacb(%rip), %rsi      # 0xffb8
leaq -0x2a0(%rbp), %rdi
callq 0x2170
leaq -0x220(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3526
jmp 0x351e
movq %rax, %rdi
callq 0x4411
movq %rax, %rbx
jmp 0x3567
movq %rax, %rbx
movq -0x108(%rbp), %rdi
cmpq %r12, %rdi
je 0x3567
callq 0x21c0
jmp 0x3567
movq %rax, %rbx
jmp 0x355b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x355b
callq 0x21c0
leaq -0x118(%rbp), %rdi
callq 0x423c
movq 0xca4a(%rip), %rsi      # 0xffb8
leaq -0x2a0(%rbp), %rdi
callq 0x2170
leaq -0x220(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/VoseTree.cc
// Function: VoseTree::probabilities[abi:cxx11]()
std::map<std::string, double> VoseTree::probabilities() {

  auto h = distribution();
  std::map<std::string, double> prob;
  //map.resize(h.size());
  std::for_each(h.begin(), h.end(), [&] (std::pair<std::string, long> m) {
    //std::cerr << "p|" << m.first << "," << (double)m.second/total_weight << "\n";
    prob.insert(std::make_pair(m.first, (double)m.second/total_weight));
  });
  return prob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %rsi, -0x38(%rbp)
callq 0x358e
leaq 0x8(%rbx), %rax
movl $0x0, 0x8(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, -0x30(%rbp)
movq %rcx, 0x28(%rbx)
movq 0x18(%r15), %r15
leaq -0xb0(%rbp), %rax
cmpq %rax, %r15
je 0x3a35
leaq -0x50(%rbp), %rbx
leaq -0x88(%rbp), %r13
movq %rbx, %r12
movq %rbx, -0x60(%rbp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x4420
movq 0x40(%r15), %rbx
movq %rbx, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x58(%rax), %r14
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x4420
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x6254
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
movq %r12, %rbx
je 0x3a0c
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3a1a
callq 0x21c0
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
leaq -0xb0(%rbp), %rax
cmpq %rax, %r15
jne 0x3986
leaq -0xb8(%rbp), %rdi
callq 0x4e4c
movq -0x30(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3a87
movq %rax, %r14
jmp 0x3a79
movq %rax, %r14
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3a79
callq 0x21c0
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a87
callq 0x21c0
movq -0x30(%rbp), %rdi
callq 0x4ee0
leaq -0xb8(%rbp), %rdi
callq 0x4e4c
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/./Vose.h
// Function: marble::toString[abi:cxx11]()
std::string toString() {
    std::stringstream ss;
    ss << "<" << label;
    ss << ",";
    ss << weight << ">"; 
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x2140
leaq -0x190(%rbp), %r15
leaq 0x5480(%rip), %rsi      # 0xb0d2
movl $0x1, %edx
movq %r15, %rdi
callq 0x2200
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2200
leaq 0x545e(%rip), %rsi      # 0xb0d4
movl $0x1, %edx
movq %r15, %rdi
callq 0x2200
movq (%r14), %rsi
movq %r15, %rdi
callq 0x21d0
leaq 0x5764(%rip), %rsi      # 0xb3f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
movq 0xa300(%rip), %rsi      # 0xffb8
leaq -0x1a0(%rbp), %rdi
callq 0x2170
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xa2cd(%rip), %rsi      # 0xffb8
leaq -0x1a0(%rbp), %rdi
callq 0x2170
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/Vose.cc
// Function: Vose::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long)
double Vose::add(std::string label, long weight) {
  // Create a new marble
  struct marble m;
  m.weight = weight;
  m.label = label; // TODO update with a proper copy() method

  return Vose::add(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rdx, -0x18(%r14)
callq 0x20f0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
callq 0x4420
movq -0x28(%rbp), %rax
leaq -0x80(%rbp), %rsi
movq %rax, 0x28(%rsi)
movq (%rsi), %rax
addq %rax, 0x58(%rbx)
leaq 0x40(%rbx), %rdi
callq 0x733c
movq -0x80(%rbp), %r12
movq -0x78(%rbp), %rdi
movq 0x58(%rbx), %rbx
cmpq %r15, %rdi
je 0x68fd
callq 0x21c0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x690b
callq 0x21c0
cvtsi2sd %r12, %xmm0
cvtsi2sd %rbx, %xmm1
divsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x693c
callq 0x21c0
jmp 0x693c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x694a
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/Vose.cc
// Function: Vose::rand()
size_t Vose::rand() {
  // Warning! init() must have been called. 
  // TODO update this method to a more numerically stable version

  double u = random_scores_double();
  //std::cerr << "rand(): u = " << u << "\n";
  // Grab a random column from the main scores list
  size_t col = floor(u);
  //std::cerr << "rand(): col = " << col << "\n";

  // Make a toss to choose either alias side or the probability side 
  return (u - col)<=prob[col]? col : alias[col];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x6e2e
movq %rdi, %rbx
callq *0x18(%rdi)
movsd %xmm0, -0x10(%rbp)
callq 0x22a0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0x4469(%rip), %xmm0     # 0xb240
cvttsd2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
movq %rax, %xmm0
punpckldq 0x422d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4235(%rip), %xmm0     # 0xb030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
subsd %xmm1, %xmm2
movq 0x78(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
ucomisd %xmm2, %xmm0
jae 0x6e27
movq 0x60(%rbx), %rcx
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/Vose.cc
// Function: Vose::kl(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double Vose::kl(const std::vector<double> &a, const std::vector<double> &b) {

  std::vector<double> v;
  for(size_t i = 0; i != a.size(); ++i) {
    printf("a:%f, b:%f, log(a/b):%f\n", a[i], b[i], log(a[i]/b[i]));
    v.push_back(log(a[i]/b[i])*a[i]);
  }
  return std::accumulate(v.cbegin(), v.cend(), 0.0, std::plus<double>());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorpd %xmm0, %xmm0
movapd %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x6fab
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x4375(%rip), %r15      # 0xb248
leaq -0x60(%rbp), %r13
movsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movq (%rbx), %rax
movsd (%rax,%r12,8), %xmm1
movsd %xmm1, -0x58(%rbp)
divsd %xmm1, %xmm0
callq 0x2190
movapd %xmm0, %xmm2
movq %r15, %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movb $0x3, %al
callq 0x2040
movq (%r14), %rax
movsd (%rax,%r12,8), %xmm0
movq (%rbx), %rax
divsd (%rax,%r12,8), %xmm0
callq 0x2190
movq (%r14), %rax
mulsd (%rax,%r12,8), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x6f4e
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x6f5d
leaq -0x50(%rbp), %rdi
movq %r13, %rdx
callq 0x74b4
movq (%r14), %rax
incq %r12
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jne 0x6ed7
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
xorpd %xmm0, %xmm0
cmpq %rax, %rdi
je 0x6f95
movq %rdi, %rcx
addsd (%rcx), %xmm0
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x6f88
testq %rdi, %rdi
je 0x6faf
movsd %xmm0, -0x30(%rbp)
callq 0x21c0
movsd -0x30(%rbp), %xmm0
jmp 0x6faf
xorpd %xmm0, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x6fcf
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/Vose.cc
// Function: Vose::merge(Vose const&, Vose const&)
Vose Vose::merge(const Vose &v1, const Vose &v2) {

  Vose v;
  std::copy (v1.scores.begin(), v1.scores.end(), std::back_inserter(v.scores)); 
  std::copy (v2.scores.begin(), v2.scores.end(), std::back_inserter(v.scores)); 
  v.total_weight = v1.total_weight + v2.total_weight;

  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movl $0x90, %edx
xorl %esi, %esi
callq 0x2100
movq 0x40(%r14), %r13
movq %r14, -0x30(%rbp)
movq 0x48(%r14), %rax
leaq 0x40(%rbx), %r12
subq %r13, %rax
testq %rax, %rax
jle 0x7042
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x733c
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
ja 0x702a
movq 0x40(%r15), %r13
movq 0x48(%r15), %rax
subq %r13, %rax
testq %rax, %rax
jle 0x7081
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x733c
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
ja 0x7069
movq 0x58(%r15), %rax
movq -0x30(%rbp), %rcx
addq 0x58(%rcx), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70a5
movq %rax, %r14
movq %rbx, %rdi
callq 0x405e
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/Vose.cc
// Function: Vose::merge(Vose const&)
Vose Vose::merge(const Vose& vose) {

  Vose v;

  // concatenate the two scores arrays
  std::copy (scores.begin(),scores.end(),std::back_inserter(v.scores)); 
  std::copy (vose.scores.begin(),vose.scores.end(),std::back_inserter(v.scores)); 

  // update the total_weight
  v.total_weight = total_weight + vose.total_weight;

  return v; // The person using this shoud call 'init' as soon as possible
  
}

// 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 $0x90, %edx
xorl %esi, %esi
callq 0x2100
movq 0x40(%r14), %r13
movq %r14, -0x30(%rbp)
movq 0x48(%r14), %rax
leaq 0x40(%rbx), %r12
subq %r13, %rax
testq %rax, %rax
jle 0x7122
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x733c
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
ja 0x710a
movq 0x40(%r15), %r13
movq 0x48(%r15), %rax
subq %r13, %rax
testq %rax, %rax
jle 0x7161
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
movq %rdx, %r14
shrq $0x5, %r14
incq %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x733c
addq $0x30, %r13
decq %r14
cmpq $0x1, %r14
ja 0x7149
movq 0x58(%r15), %rax
movq -0x30(%rbp), %rcx
addq 0x58(%rcx), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7185
movq %rax, %r14
movq %rbx, %rdi
callq 0x405e
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/Vose.cc
// Function: Vose::toString[abi:cxx11]()
std::string Vose::toString() {
  std::stringstream ss;
  ss << "[" << total_weight << "|";
  std::for_each(scores.cbegin(), scores.cend(),[&ss] (marble m) {
    ss << m.toString();
  });
  ss << "]";
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x208(%rbp), %rdi
callq 0x2140
leaq -0x1f8(%rbp), %rdi
leaq 0x3e9c(%rip), %rsi      # 0xb068
movl $0x1, %edx
callq 0x2200
movq 0x58(%r15), %rsi
leaq -0x1f8(%rbp), %rdi
callq 0x21d0
leaq 0x4074(%rip), %rsi      # 0xb261
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq %rbx, -0x30(%rbp)
movq 0x40(%r15), %r14
movq 0x48(%r15), %r15
cmpq %r15, %r14
je 0x7286
leaq -0x68(%rbp), %rbx
leaq -0x50(%rbp), %r12
leaq -0x80(%rbp), %r13
movq (%r14), %rax
movq %rax, -0x80(%rbp)
movq %rbx, -0x78(%rbp)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x4420
movq 0x28(%r14), %rax
movq %rax, -0x58(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5c22
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x1f8(%rbp), %rdi
callq 0x2200
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x726f
callq 0x21c0
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x727d
callq 0x21c0
addq $0x30, %r14
cmpq %r15, %r14
jne 0x7217
leaq 0x3fd6(%rip), %rsi      # 0xb263
movl $0x1, %edx
leaq -0x1f8(%rbp), %rdi
callq 0x2200
movq -0x30(%rbp), %rbx
leaq -0x1f0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2250
movq 0x8d00(%rip), %rsi      # 0xffb8
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72e7
movq %rax, %r14
jmp 0x7314
movq %rax, %r14
jmp 0x7306
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x7306
callq 0x21c0
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x7314
callq 0x21c0
movq 0x8c9d(%rip), %rsi      # 0xffb8
leaq -0x208(%rbp), %rdi
callq 0x2170
leaq -0x188(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cegme[P]vose/test.cc
// Function: main
int main(int argc, char **argv) {
  
  test t;
  
  std::cout << "\nTest 1" << "----------------------------------------\n";
  t.test1();
  
  std::cout << "\nTest 2" << "----------------------------------------\n";
  t.test2();
  
  std::cout << "\nTest 3" << "----------------------------------------\n";
  t.test3();
  
  std::cout << "\nTest 4" << "----------------------------------------\n";
  t.test4();
  
  std::cout << "\nTest 5" << "----------------------------------------\n";
  t.test5();

  std::cout << "\nTest 6" << "----------------------------------------\n";
  t.test6();

  std::cout << "\nTest 7" << "----------------------------------------\n";
  t.test7();


 return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x618f(%rip), %rbx      # 0xffd0
leaq 0x16f4(%rip), %rsi      # 0xb53c
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
leaq 0x16e8(%rip), %r14      # 0xb544
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x7b6c
leaq 0x16f6(%rip), %rsi      # 0xb56e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x7e5c
leaq 0x16d5(%rip), %rsi      # 0xb576
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x85b2
leaq 0x16b4(%rip), %rsi      # 0xb57e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x8dbe
leaq 0x1693(%rip), %rsi      # 0xb586
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x9094
leaq 0x1672(%rip), %rsi      # 0xb58e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x9716
leaq 0x1651(%rip), %rsi      # 0xb596
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2200
movl $0x29, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
callq 0x9b7a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/App.cpp
// Function: App::execute()
int App::execute()
{
    while (running) {
        if (SDL_GetTicks() > dataOutputTimer + 1000) {
            dataOutputTimer = SDL_GetTicks();
        }

        if (SDL_GetTicks() > rockSpawnTimer + 15000) {
            game.spawnRock(BIG_ROCK, 1);
            rockSpawnTimer = SDL_GetTicks();
        }

        this->inputs();

        loops = 0;
        deltaTime = float(SDL_GetTicks() - prevFrameTime) / 1000.0f;

        while (SDL_GetTicks() > nextFrameTime && loops < maxFrameSkip) {
            game.updatePositions(deltaTime);

            nextFrameTime += singleFrameTimeInMS;
            prevFrameTime = SDL_GetTicks();
            loops++;
        }
        interpolation = float(SDL_GetTicks() + singleFrameTimeInMS - nextFrameTime) / float(singleFrameTimeInMS);
        game.collisions();
        if (true) {
            game.interpolate(deltaTime, interpolation);
            game.draw(rend);
        }
    }
    return 0;
}

// Assembly:
cmpb $0x1, 0xd8(%rdi)
jne 0x29b9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x118(%rdi), %r15
leaq 0x11c(%rdi), %r12
xorl %r13d, %r13d
callq 0x22d0
movl 0x138(%rbx), %ecx
movl $0x3e8, %edx            # imm = 0x3E8
addl %edx, %ecx
cmpl %ecx, %eax
jbe 0x2885
callq 0x22d0
movl %eax, 0x138(%rbx)
callq 0x22d0
movl 0x13c(%rbx), %ecx
movl $0x3a98, %edx           # imm = 0x3A98
addl %edx, %ecx
cmpl %ecx, %eax
jbe 0x28d4
movl $0x259, -0x38(%rbp)     # imm = 0x259
movl $0x1, -0x34(%rbp)
movl %r13d, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq %r14, %rdi
leaq -0x38(%rbp), %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x2e8e
callq 0x22d0
movl %eax, 0x13c(%rbx)
movq %rbx, %rdi
callq 0x29bc
movl $0x0, 0x12c(%rbx)
callq 0x22d0
subl 0x134(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss 0x272f(%rip), %xmm0     # 0x5030
movss %xmm0, 0x118(%rbx)
callq 0x22d0
cmpl 0x130(%rbx), %eax
jbe 0x294e
movl 0x12c(%rbx), %eax
cmpl 0x128(%rbx), %eax
jge 0x294e
movq %r14, %rdi
movq %r15, %rsi
callq 0x351c
movl 0x124(%rbx), %eax
addl %eax, 0x130(%rbx)
callq 0x22d0
movl %eax, 0x134(%rbx)
incl 0x12c(%rbx)
jmp 0x2909
callq 0x22d0
movl 0x124(%rbx), %ecx
addl %ecx, %eax
subl 0x130(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x11c(%rbx)
movq %r14, %rdi
callq 0x332c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x356e
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x35c6
cmpb $0x0, 0xd8(%rbx)
jne 0x2864
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::Bullet(SDL_Point, float const&, float const&, int const&, int const&)
Bullet::Bullet(SDL_Point p, const float& vX, const float& vY, const int& t, const int& n)
: num(n), type(t), dead(false)
{
    position = {p.x, p.y};
    prevPosition = {p.x, p.y};
    if (type == BULLET) {

    }

    velocity[0] = vX;
    velocity[1] = vY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
shrq $0x20, %rax
xorl %r10d, %r10d
movl %r10d, 0x18(%rdi)
movq $0x0, 0x24(%rdi)
leaq 0x5043(%rip), %r11      # 0x7cb0
movq %r11, (%rdi)
movl %r10d, 0x2c(%rdi)
movl (%r9), %r9d
movl %r9d, 0x30(%rdi)
movl %r10d, 0x34(%rdi)
movl (%r8), %r8d
movl %r8d, 0x38(%rdi)
movb $0x0, 0x3c(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
movss (%rdx), %xmm0
movss %xmm0, 0x1c(%rdi)
movss (%rcx), %xmm0
movss %xmm0, 0x20(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::updatePosition(float const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Bullet, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Bullet>>>&)
void Bullet::updatePosition(const float& dT, std::map<std::string, Bullet>& m)
{
    position.x = prevPosition.x - velocity[0] * dT;
    position.y = prevPosition.y - velocity[1] * dT;

    if (position.x > 800) {
        position.x -= 800;
    } else if (position.x < 0) {
        position.x += 800;
    }
    if (position.y > 600) {
        position.y -= 600;
    } else if (position.y < 0) {
        position.y += 600;
    }

    if (type == BULLET) {
        if (life > 25) {
            dead = true;
        } else {
            life++;
        }
    }

    prevPosition.x = position.x;
    prevPosition.y = position.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsi2ssl 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
movss 0x1c(%rdi), %xmm2
mulss %xmm1, %xmm2
subss %xmm2, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rdi)
movl $0xfffffce0, %edx       # imm = 0xFFFFFCE0
cmpl $0x320, %eax            # imm = 0x320
jg 0x2cfe
testl %eax, %eax
jns 0x2d03
movl $0x320, %edx            # imm = 0x320
addl %edx, %eax
movl %eax, 0x10(%rdi)
movl $0xfffffda8, %edx       # imm = 0xFFFFFDA8
cmpl $0x258, %ecx            # imm = 0x258
jg 0x2d19
testl %ecx, %ecx
jns 0x2d1e
movl $0x258, %edx            # imm = 0x258
addl %edx, %ecx
movl %ecx, 0x14(%rdi)
cmpl $0x25c, 0x38(%rdi)      # imm = 0x25C
jne 0x2d3a
movl 0x2c(%rdi), %edx
cmpl $0x1a, %edx
jl 0x2d35
movb $0x1, 0x3c(%rdi)
jmp 0x2d3a
incl %edx
movl %edx, 0x2c(%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::draw(SDL_Renderer*)
void Bullet::draw(SDL_Renderer* r)
{
    if (type == BULLET) {
        SDL_SetRenderDrawColor(r, 0, 255, 0, 1.0);
        SDL_RenderDrawPoint(r, position.x, position.y);
        SDL_SetRenderDrawColor(r, 0, 0, 0, 255);
    }
}

// Assembly:
cmpl $0x25c, 0x38(%rdi)      # imm = 0x25C
jne 0x2ddf
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
movl $0xff, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2320
movl 0x10(%r14), %esi
movl 0x14(%r14), %edx
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x2320
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::actionShip(int const&, bool)
void GameEngine::actionShip(const int& action, bool down)
{
    if (down) {
        if (player.isAlive()) {
            switch (action) {
            case GameEngine::UP:
                player.thrusting(true);
                break;
            case GameEngine::LEFT:
                player.rotate(Ship::LEFT);
                break;
            case GameEngine::RIGHT:
                player.rotate(Ship::RIGHT);
                break;
            case GameEngine::FIRE:
                if (player.isLoaded()) {
                    player.fire();
                    player.loaded(false);
                }
                break;
            }
        }
    } else {
        switch (action) {
        case GameEngine::UP:
            player.thrusting(false);
            break;
        case GameEngine::LEFT:
            player.rotate(Ship::NONE);
            break;
        case GameEngine::RIGHT:
            player.rotate(Ship::NONE);
            break;
        case GameEngine::FIRE:
            player.loaded(true);
            break;
        case GameEngine::ALIVE:
            player.setAlive(true);
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
je 0x32b5
cmpb $0x1, 0x88(%rbx)
jne 0x3324
movl (%rsi), %eax
cmpq $0x3, %rax
ja 0x3324
leaq 0x1e11(%rip), %rcx      # 0x50b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x89(%rbx)
jmp 0x3324
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x3324
leaq 0x1ddc(%rip), %rcx      # 0x50a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x80(%rbx)
jmp 0x3324
movb $0x1, 0x88(%rbx)
jmp 0x3324
movb $0x0, 0x89(%rbx)
jmp 0x3324
movb $0x1, 0x8a(%rbx)
jmp 0x3324
movl $0x2, 0x80(%rbx)
jmp 0x3324
cmpb $0x1, 0x8a(%rbx)
jne 0x3324
movq %rbx, %rdi
callq 0x468e
movb $0x0, 0x8a(%rbx)
jmp 0x3324
movl $0x1, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::updatePositions(float const&)
void GameEngine::updatePositions(const float& deltaTime)
{
    player.updatePosition(deltaTime);

    for (auto rock = rocks.begin(); rock != rocks.end(); rock++) {
        Rock& currentRock = rock->second;
        currentRock.updatePosition(deltaTime);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4394
movq 0xa8(%r14), %r15
addq $0x98, %r14
cmpq %r14, %r15
je 0x3562
leaq 0x40(%r15), %rdi
movq 0x40(%r15), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x3544
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::interpolate(float const&, float const&)
void GameEngine::interpolate(const float& deltaTime, const float& interpolation)
{
    player.interpolate(deltaTime, interpolation);

    for (auto rock = rocks.begin(); rock != rocks.end(); rock++) {
        Rock& currentRock = rock->second;
        currentRock.interpolate(deltaTime, interpolation);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4528
movq 0xa8(%r15), %r12
addq $0x98, %r15
cmpq %r15, %r12
je 0x35bd
leaq 0x40(%r12), %rdi
movq 0x40(%r12), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %r12, %rdi
callq 0x21c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x359a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::draw(Renderer*)
void GameEngine::draw(Renderer *rend)
{
    rend->clear();
    player.draw(rend->getRend());

    for (auto rock = rocks.begin(); rock != rocks.end(); rock++) {
        Rock& currentRock = rock->second;
        currentRock.draw(rend->getRend());
    }

    rend->present();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
callq 0x2320
movq (%rbx), %rdi
callq 0x2280
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x45dc
movq 0xa8(%r14), %r15
addq $0x98, %r14
cmpq %r14, %r15
je 0x362e
leaq 0x40(%r15), %rdi
movq (%rbx), %rsi
movq 0x40(%r15), %rax
callq *0x18(%rax)
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x3610
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::Rock(SDL_Point, float const&, float const&, int const&, int const&)
Rock::Rock(SDL_Point p, const float& vX, const float& vY, const int& t, const int& n)
: num(n), type(t)
{
    position = {p.x, p.y};
    prevPosition = {p.x, p.y};
    angle = (rand() % 314) / 100;
    if (num % 2 == 0) {
        angleVel = 0.01;
    } else {
        angleVel = -0.01;
    }

    velocity[0] = vX;
    velocity[1] = vY;

    color = {Uint8(rand() % 255), Uint8(rand() % 255), Uint8(rand() % 255)};

    generateDeviation();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x20, %rax
xorl %r12d, %r12d
movl %r12d, 0x18(%rdi)
movq $0x0, 0x24(%rdi)
leaq 0x427f(%rip), %rcx      # 0x7d20
movq %rcx, (%rdi)
movl %r12d, 0x2c(%rdi)
movl (%r9), %ecx
movl %ecx, 0x30(%rdi)
movl (%r8), %ecx
movl %ecx, 0x34(%rdi)
movl %r12d, 0x98(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
callq 0x2110
cltq
imulq $0x342da7f3, %rax, %rcx # imm = 0x342DA7F3
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x26, %rcx
addl %edx, %ecx
imull $0x13a, %ecx, %ecx      # imm = 0x13A
subl %ecx, %eax
cwtl
imull $0x147b, %eax, %eax     # imm = 0x147B
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x13, %eax
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x18(%rbx)
xorl %eax, %eax
testb $0x1, 0x30(%rbx)
sete %al
leaq 0x15bc(%rip), %rcx      # 0x50d0
movss (%rcx,%rax,4), %xmm0
movss %xmm0, 0x98(%rbx)
movss (%r15), %xmm0
movss %xmm0, 0x1c(%rbx)
movss (%r14), %xmm0
movss %xmm0, 0x20(%rbx)
callq 0x2110
cltq
imulq $-0x7f7f7f7f, %rax, %r14 # imm = 0x80808081
shrq $0x20, %r14
addl %eax, %r14d
movl %r14d, %ecx
shrl $0x1f, %ecx
shrl $0x7, %r14d
addl %ecx, %r14d
addl %eax, %r14d
callq 0x2110
cltq
imulq $-0x7f7f7f7f, %rax, %r15 # imm = 0x80808081
shrq $0x20, %r15
addl %eax, %r15d
movl %r15d, %ecx
shrl $0x1f, %ecx
shrl $0x7, %r15d
addl %ecx, %r15d
addl %eax, %r15d
callq 0x2110
cltq
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
shrl $0x7, %ecx
addl %edx, %ecx
addl %eax, %ecx
movb %r14b, 0x38(%rbx)
movb %r15b, 0x39(%rbx)
movb %cl, 0x3a(%rbx)
movb $0x0, 0x3b(%rbx)
callq 0x2110
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x14fb(%rip), %xmm0     # 0x50d8
mulsd 0x14fb(%rip), %xmm0     # 0x50e0
addsd 0x14fb(%rip), %xmm0     # 0x50e8
movsd %xmm0, 0x40(%rbx,%r12,8)
incq %r12
cmpq $0xa, %r12
jne 0x3bae
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x90(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::generate(int, double)
void Rock::generate(int radius, double rotAngle) {
    for (int part = 0; part <= ROCK_PARTS; part++) {
        double angle = part * 2 * M_PI / ROCK_PARTS + rotAngle;
        double deviation = this -> deviation[part];
        int px = int(cos(angle) * radius * deviation) + position.x;
        int py = int(sin(angle) * radius * deviation) + position.y;
        lines[part].x = px;
        lines[part].y = py;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x140a(%rip), %xmm0     # 0x50f0
divsd 0x140a(%rip), %xmm0     # 0x50f8
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x40(%rbx,%r14,4), %xmm1
movsd %xmm1, -0x28(%rbp)
callq 0x23d0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %r15d
addl 0x10(%rbx), %r15d
movsd -0x38(%rbp), %xmm0
callq 0x20e0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %eax
addl 0x14(%rbx), %eax
movl %r15d, 0x9c(%rbx,%r14,4)
movl %eax, 0xa0(%rbx,%r14,4)
addq $0x2, %r14
cmpq $0x16, %r14
jne 0x3cd6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::updatePosition(float const&)
void Rock::updatePosition(const float& dT)
{
    position.x = prevPosition.x - velocity[0] * dT;
    position.y = prevPosition.y - velocity[1] * dT;

    if (position.x > 800) {
        position.x -= 800;
    } else if (position.x < 0) {
        position.x += 800;
    }
    if (position.y > 600) {
        position.y -= 600;
    } else if (position.y < 0) {
        position.y += 600;
    } else if (position.x == 0 || position.y == 0) {
        position.x -= 20;
        position.y -= 20;
    }

    angle += angleVel;

    prevPosition.x = position.x;
    prevPosition.y = position.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsi2ssl 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
movss 0x1c(%rdi), %xmm2
mulss %xmm1, %xmm2
subss %xmm2, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rdi)
movl $0xfffffce0, %edx       # imm = 0xFFFFFCE0
cmpl $0x320, %eax            # imm = 0x320
jg 0x3daa
testl %eax, %eax
jns 0x3daf
movl $0x320, %edx            # imm = 0x320
addl %edx, %eax
movl %eax, 0x10(%rdi)
movl $0xfffffda8, %edx       # imm = 0xFFFFFDA8
cmpl $0x258, %ecx            # imm = 0x258
jg 0x3dd8
testl %ecx, %ecx
js 0x3dd3
je 0x3dc6
testl %eax, %eax
jne 0x3ddd
addl $-0x14, %eax
movl %eax, 0x10(%rdi)
movl $0xffffffec, %edx       # imm = 0xFFFFFFEC
jmp 0x3dd8
movl $0x258, %edx            # imm = 0x258
addl %edx, %ecx
movl %ecx, 0x14(%rdi)
movss 0x98(%rdi), %xmm0
addss 0x18(%rdi), %xmm0
movss %xmm0, 0x18(%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::Ship()
Ship::Ship()
{
    prevPosition = {400, 300};
    position = {400, 300};
    ship = new SDL_Point[5];
    thruster = new SDL_Point[3];
    colPoints = new SDL_Rect[3];
    coefArr = readConfig("config/Ship.txt");

    velocity[0] = 0.0;
    velocity[1] = 0.0;

    this->trace();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x18(%rdi)
movq %rax, 0x24(%rdi)
leaq 0x3eb0(%rip), %rcx      # 0x7d68
movq %rcx, (%rdi)
leaq 0x48(%rdi), %rcx
movl %eax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rcx, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movw $0x1, 0x88(%rdi)
movb $0x1, 0x8a(%rdi)
movl %eax, 0x8c(%rdi)
movaps 0x1226(%rip), %xmm0     # 0x5120
movups %xmm0, 0x8(%rdi)
movl $0x28, %edi
callq 0x2040
movq %rax, 0x70(%rbx)
movl $0x18, %edi
callq 0x2040
movq %rax, 0x78(%rbx)
movl $0x30, %edi
callq 0x2040
movq %rax, 0x38(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1219(%rip), %rsi      # 0x5150
leaq 0x1221(%rip), %rdx      # 0x515f
leaq -0x38(%rbp), %rdi
callq 0x2bae
leaq -0x38(%rbp), %rsi
callq 0x3fac
leaq 0x30(%rbx), %rcx
movq %rax, (%rcx)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3f65
callq 0x2290
movq $0x0, 0x1c(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3f98
callq 0x2290
jmp 0x3f98
jmp 0x3f95
movq %rax, %r14
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x49ce
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::readConfig(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int** Ship::readConfig(const std::string& filename)
{
    std::ifstream config (filename);
    if (config.is_open()) {
        int countM;
        int countN;
        config >> countM;
        config >> countN;
        int **arr = new int*[countM];
        for (int i = 0; i < countM; i++) {
            arr[i] = new int[countN];
            for (int j = 0; j < countN; j++) {
                config >> arr[i][j];
            }
        }
        config.close();
        return arr;
    } else {
        std::cout << "Error: Not found config file at " << filename << std::endl;
        return nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
leaq -0x240(%rbp), %rdi
movl $0x8, %edx
callq 0x2370
leaq -0x1c8(%rbp), %rdi
callq 0x20f0
testb %al, %al
je 0x40a8
leaq -0x240(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2190
leaq -0x240(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2190
movslq -0x30(%rbp), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2040
movq %rax, -0x38(%rbp)
testl %r13d, %r13d
jle 0x4096
movl -0x2c(%rbp), %ebx
xorl %r12d, %r12d
leaq -0x240(%rbp), %r14
movslq %ebx, %rax
leaq (,%rax,4), %rdi
testl %eax, %eax
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x2040
movq %rax, %r15
movq -0x38(%rbp), %rax
movq %r15, (%rax,%r12,8)
testl %ebx, %ebx
jle 0x408b
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
incq %r13
movslq -0x2c(%rbp), %rbx
addq $0x4, %r15
cmpq %rbx, %r13
jl 0x406c
movl -0x30(%rbp), %r13d
incq %r12
movslq %r13d, %rax
cmpq %rax, %r12
jl 0x403d
leaq -0x240(%rbp), %rdi
callq 0x20d0
movq -0x38(%rbp), %rbx
jmp 0x40ff
movq 0x3f29(%rip), %rdi      # 0x7fd8
leaq 0x10b1(%rip), %rsi      # 0x5167
movl $0x20, %edx
callq 0x2300
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3f0a(%rip), %rdi      # 0x7fd8
callq 0x2300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x22b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x21b0
xorl %ebx, %ebx
leaq -0x240(%rbp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4128
jmp 0x4128
jmp 0x4128
jmp 0x4128
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::~Ship()
Ship::~Ship()
{
    delete[] ship;
    delete[] thruster;
    delete[] colPoints;
    delete[] coefArr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3c18(%rip), %rax      # 0x7d68
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x4161
callq 0x2310
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x416f
callq 0x2310
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x417d
callq 0x2310
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x418b
callq 0x2310
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x49ce
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::trace()
void Ship::trace()
{
    cosA = cos(angle);
    sinA = sin(angle);

    int i = 0;
    for (; i < 5; i++) {
        ship[i] = baseFormula(coefArr[i][0], coefArr[i][1], coefArr[i][2], coefArr[i][3]);
    }
    i = 5;
    for (int j = 0; j < 3; j++) {
        thruster[j] = baseFormula(coefArr[i][0], coefArr[i][1], coefArr[i][2], coefArr[i][3]);
        i++;
    }
    for (int j = 0; j < 2; j++) {
        colPoints[j].x = ship[j].x;
        colPoints[j].y = ship[j].y;
        colPoints[j].w = 2;
        colPoints[j].h = 2;
    }
    colPoints[2].x = ship[3].x;
    colPoints[2].y = ship[3].y;
    colPoints[2].w = 2;
    colPoints[2].h = 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x18(%rdi), %xmm0
callq 0x2200
movss %xmm0, 0x24(%rbx)
movss 0x18(%rbx), %xmm0
callq 0x2230
movss %xmm0, 0x28(%rbx)
xorl %eax, %eax
movq 0x30(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
xorps %xmm0, %xmm0
cvtsi2ssl (%rcx), %xmm0
movss 0x24(%rbx), %xmm1
movss 0x28(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtsi2ssl 0x4(%rcx), %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
xorps %xmm4, %xmm4
cvtsi2ssl 0x10(%rbx), %xmm4
subss %xmm3, %xmm0
addss %xmm0, %xmm4
cvttss2si %xmm4, %edx
xorps %xmm0, %xmm0
cvtsi2ssl 0x8(%rcx), %xmm0
xorps %xmm3, %xmm3
cvtsi2ssl 0xc(%rcx), %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm0
addss %xmm3, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x14(%rbx), %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
shlq $0x20, %rcx
orq %rcx, %rdx
movq 0x70(%rbx), %rcx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq $0x5, %rax
jne 0x41c7
xorl %eax, %eax
movq 0x30(%rbx), %rcx
movq 0x28(%rcx,%rax,8), %rcx
xorps %xmm0, %xmm0
cvtsi2ssl (%rcx), %xmm0
movss 0x24(%rbx), %xmm1
movss 0x28(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtsi2ssl 0x4(%rcx), %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
xorps %xmm4, %xmm4
cvtsi2ssl 0x10(%rbx), %xmm4
subss %xmm3, %xmm0
addss %xmm0, %xmm4
cvttss2si %xmm4, %edx
xorps %xmm0, %xmm0
cvtsi2ssl 0x8(%rcx), %xmm0
xorps %xmm3, %xmm3
cvtsi2ssl 0xc(%rcx), %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm0
addss %xmm3, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x14(%rbx), %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
shlq $0x20, %rcx
orq %rcx, %rdx
movq 0x78(%rbx), %rcx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x424e
movq 0x38(%rbx), %rax
movq 0x70(%rbx), %rcx
movb $0x1, %sil
xorl %edi, %edi
movabsq $0x200000002, %rdx      # imm = 0x200000002
movl (%rcx,%rdi,8), %r8d
movq %rdi, %r9
shlq $0x4, %r9
movl %r8d, (%rax,%r9)
movl 0x4(%rcx,%rdi,8), %edi
movl %edi, 0x4(%rax,%r9)
movq %rdx, 0x8(%rax,%r9)
movl $0x1, %edi
testb $0x1, %sil
movl $0x0, %esi
jne 0x42eb
movl 0x18(%rcx), %esi
movl %esi, 0x20(%rax)
movl 0x1c(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq %rdx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::interpolate(float const&, float const&)
void Ship::interpolate(const float& dT, const float& i)
{
    position.x = prevPosition.x - (velocity[0] * dT) * i;
    position.y = prevPosition.y - (velocity[1] * dT) * i;
    if (alive) {
        this->trace();
    } else {
        this->deadAnimation();
    }

    for (auto j = bullets.begin(); j != bullets.end(); j++)
    {
        j->second.interpolate(dT, i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2ssl 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
movss (%rdx), %xmm2
movss 0x1c(%rdi), %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm3
subss %xmm3, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x14(%rdi)
cmpb $0x1, 0x88(%rdi)
jne 0x4590
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
jmp 0x4598
movq $0x0, 0x1c(%r15)
movq 0x58(%r15), %r12
addq $0x48, %r15
cmpq %r15, %r12
je 0x45c5
leaq 0x40(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2d42
movq %r12, %rdi
callq 0x21c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x45a5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::draw(SDL_Renderer*)
void Ship::draw(SDL_Renderer* r)
{
    SDL_SetRenderDrawColor(r, 255, 255, 255, 255);

    if (alive)
    {
        if (thrust) {
            SDL_RenderDrawLines(r, ship, 5);
            SDL_SetRenderDrawColor(r, 255, 255, 0, 0);
            SDL_RenderDrawLines(r, thruster, 3);
        } else {
            SDL_RenderDrawLines(r, ship, 5);
        }
        for (auto i = bullets.begin(); i != bullets.end(); i++) {
            i->second.draw(r);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
movl $0xff, %r8d
callq 0x2320
cmpb $0x1, 0x88(%r14)
jne 0x4682
movb 0x89(%r14), %r15b
movq 0x70(%r14), %rsi
movq %rbx, %rdi
movl $0x5, %edx
callq 0x21a0
cmpb $0x1, %r15b
jne 0x4659
movq %rbx, %rdi
movl $0xff, %esi
movl $0xff, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2320
movq 0x78(%r14), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x21a0
movq 0x58(%r14), %r15
addq $0x48, %r14
cmpq %r14, %r15
je 0x4682
leaq 0x40(%r15), %rdi
movq %rbx, %rsi
callq 0x2d8a
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x4666
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Splitter(int, int)
Splitter(int _w, int _d)
	{
		mem_acc = 0;
		counter_index_size = 20;
		w = _w;
		d = _d;
		
		for(int i = 0; i < d; i++)	
		{
			counter[i] = new double[w];
			memset(counter[i], 0, sizeof(double) * w);
		}

		MAX_CNT = (1 << COUNTER_SIZE) - 1;

		for(int i = 0; i < d; i++)
		{
			bobhash32[i] = new BOBHash32(i + 1000);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x7a13a8(%rdi)
movl $0x14, 0x19c(%rdi)
movl %esi, 0x190(%rdi)
movl %edx, 0x194(%rdi)
testl %edx, %edx
jle 0x1b42
movl %edx, %ebp
movslq %esi, %r14
shlq $0x3, %r14
testl %esi, %esi
movq $-0x1, %r15
cmovnsq %r14, %r15
movl %edx, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x1030
movq %rax, 0xf0(%rbx,%r13,8)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x10a0
incq %r13
cmpq %r13, %r12
jne 0x1aeb
movl $0xffff, 0x198(%rbx)    # imm = 0xFFFF
testl %ebp, %ebp
jle 0x1b4c
xorl %r14d, %r14d
movl $0x4, %edi
callq 0x1120
leal 0x3e8(%r14), %ecx
movl %ecx, (%rax)
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x1b21
jmp 0x1b4c
movl $0xffff, 0x198(%rbx)    # imm = 0xFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop