LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ValidToInvalid(ROAGroup*, PrefixRange*, int)
void ValidToInvalid( ROAGroup* newPrefixes, PrefixRange* rOld, int as){
  bool argDense = false;  // most likely, known has many entries and the intersections have few entries

  PrefixRange noLongerValid =  PrefixRange(); 

  if( newPrefixes->hasAS( as ) ) { 

    // ( R.valid -  new.AS.Valid)
    PrefixRange* newASValid = newPrefixes->getByAS(as);
    PrefixRange newASUnknownOrInvalid = newASValid->complement();
    rOld->denseIntersectWith( newASUnknownOrInvalid, argDense); // LEOCOM: would it be more efficent to do a subtraction, ETHANCOM: unfortunately substraction only applies to IPPrefixes which don't have MaxLen

  } // if new.AS.valid doesn't exist then ( R.valid -  new.AS.valid) = (R.valid) and we can skip ahead

  // subtracting new.unknown is the same as intersecting with new.known
  rOld->denseIntersectWith( *(newPrefixes->getKnown()), argDense);
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movq $0x0, 0x8(%rdi)
movl $0x20, %esi
callq 0x6062
leaq 0x8(%rsp), %rsi
movl %ebp, (%rsi)
movq %r14, %rdi
callq 0x619e
testq %rax, %rax
je 0x2c84
movl %ebp, 0x4(%rsp)
leaq 0x8(%rsp), %rsi
movl %ebp, (%rsi)
movq %r14, %rdi
callq 0x619e
testq %rax, %rax
je 0x2cdf
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x710e
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4ace
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4a4a
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0x2c84
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x2c74
imulq $0x38, %r13, %rbp
addq $-0x38, %r12
leaq (%r12,%rbp), %rdi
callq 0x618a
addq $-0x38, %rbp
jne 0x2c65
imulq $0x38, %r13, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x2390
movq 0x38(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4a4a
movq 0x20(%rsp), %r14
testq %r14, %r14
je 0x2cd0
leaq -0x8(%r14), %rbx
movq -0x8(%r14), %r15
testq %r15, %r15
je 0x2cc0
imulq $0x38, %r15, %r12
addq $-0x38, %r14
leaq (%r14,%r12), %rdi
callq 0x618a
addq $-0x38, %r12
jne 0x2cb1
imulq $0x38, %r15, %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x2390
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x54ab(%rip), %rdi      # 0x8191
leaq 0x5393(%rip), %rsi      # 0x8080
leaq 0x54a7(%rip), %rcx      # 0x819b
movl $0x2d9, %edx            # imm = 0x2D9
callq 0x2150
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4bf8
jmp 0x2d14
jmp 0x2d11
jmp 0x2d11
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4bf8
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: UnknownToKnown(PrefixRange const*, ROA, PrefixRange*)
void UnknownToKnown(const PrefixRange* oldUnknown, ROA rNew, PrefixRange* unknownToKnown){
  bool argDense = true;
  assert(unknownToKnown->empty());

  unknownToKnown->addROA( rNew.getPrefix(), IPAddr::numBits);

  // unknownToKnown =  R.known INTERSECTS old
  unknownToKnown->denseIntersectWith( *oldUnknown, argDense);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movslq 0x14(%rdx), %rax
testq %rax, %rax
jle 0x2fdb
movq (%rbx), %rcx
cmpq $0x0, 0x28(%rcx)
jne 0x3009
addq $0x60, %rcx
movl $0x1, %edi
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x2fd6
leaq 0x1(%rdx), %rdi
cmpq $0x0, (%rcx)
leaq 0x38(%rcx), %rcx
je 0x2fc0
cmpq %rax, %rdx
jb 0x3009
movq (%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
movl $0x20, %edx
callq 0x4d5e
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x4a4a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5058(%rip), %rdi      # 0x8068
leaq 0x5069(%rip), %rsi      # 0x8080
leaq 0x506c(%rip), %rcx      # 0x808a
movl $0x380, %edx            # imm = 0x380
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: std::ostream& operator<<<IPAddr>(std::ostream&, IntervalList<IPAddr> const&)
ostream& operator<< (ostream& os, const IntervalList<T> & l)
{
  typename map<T, T>::const_iterator it = l.m.begin();
  if (it==l.m.end()) {
    os << "empty ";
  }
  while (it!=l.m.end()) {
    os << "["<<it->first<<"-" << it->second<<"] ";
    ++it;
  }
  return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x4a23
leaq 0x3688(%rip), %rbp      # 0x8034
movq %rsp, %r12
leaq 0x39ba(%rip), %r13      # 0x8370
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x367e(%rip), %rsi      # 0x8043
callq 0x2280
movl 0x20(%r15), %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x250c
movl $0x1, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2280
movl 0x24(%r15), %eax
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x250c
movl $0x2, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2280
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
cmpq %r14, %rax
jne 0x49b6
jmp 0x4a37
leaq 0x393f(%rip), %rsi      # 0x8369
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2280
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::complement()
PrefixRange complement() {
    PrefixRange ret(bound, endLength);

    for (int i = bound.getLength(); i<=endLength; i++) { 
      lists[i-bound.getLength()].subtractFromInterval(bound.getPrefix(), bound.endAddress(i), ret.lists[i-bound.getLength()]);
    }
    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rsi), %esi
movq 0x8(%r14), %rax
movq %rax, 0x8(%rdi)
callq 0x6062
movl 0xc(%r14), %ecx
cmpl 0x10(%r14), %ecx
jle 0x4b0b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ecx, %rax
imulq $0x38, %rax, %r13
movl $0x20, %ebp
subl %ecx, %ebp
movq %rsp, %r12
movl %ecx, %r15d
movslq %ecx, %r8
imulq $-0x38, %r8, %rax
movq (%r14), %rdi
addq %rax, %rdi
movl 0x8(%r14), %edx
movl %edx, 0x4(%rsp)
xorl %esi, %esi
cmpl %r15d, %r8d
jg 0x4b6e
testl %ecx, %ecx
js 0x4ba6
je 0x4b5e
negb %cl
movl $0x1, %r8d
shll %cl, %r8d
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %esi
addl %r8d, %esi
addl %edx, %esi
jae 0x4b6e
jmp 0x4bc5
movl %edx, %esi
testl %r15d, %r15d
je 0x4b6e
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %esi
addq %r13, %rdi
movl %esi, (%rsp)
addq (%rbx), %rax
addq %r13, %rax
leaq 0x4(%rsp), %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x61fa
cmpl 0x10(%r14), %r15d
jge 0x4af9
incl %r15d
movl 0xc(%r14), %ecx
addq $0x38, %r13
decl %ebp
jmp 0x4b1f
leaq 0x3729(%rip), %rdi      # 0x82d6
leaq 0x34cc(%rip), %rsi      # 0x8080
leaq 0x3727(%rip), %rcx      # 0x82e2
movl $0x4f, %edx
callq 0x2150
leaq 0x36a1(%rip), %rdi      # 0x826d
leaq 0x34ad(%rip), %rsi      # 0x8080
leaq 0x369c(%rip), %rcx      # 0x8276
movl $0x1c, %edx
callq 0x2150
movq %rax, %r14
movq %rbx, %rdi
callq 0x4bf8
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::PrefixRange(PrefixRange const&)
PrefixRange( const PrefixRange& original ) : bound(original.bound), endLength(original.endLength), len(original.len) {
    
    //copy everything in lists
    lists = new IntervalList<IPAddr>[len]; 
     for (int i = 0; i<len; i++){
       IntervalList<IPAddr> list = IntervalList<IPAddr>( original.lists[i] );
       lists[i] = list;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movslq 0x14(%rsi), %r15
movl $0x38, %ecx
movq %r15, %rax
mulq %rcx
movq %rdi, %r14
seto %cl
addq $0x8, %rax
movq $-0x1, %rdi
cmovbq %rdi, %rax
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%r14)
testb %cl, %cl
cmoveq %rax, %rdi
callq 0x2030
movq %r15, (%rax)
leaq 0x8(%rax), %rcx
testl %r15d, %r15d
je 0x4d39
addq $0x10, %rax
imulq $0x38, %r15, %rdx
xorl %esi, %esi
movl $0x0, (%rax)
movq %rsi, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rsi, 0x20(%rax)
movl $0x1, 0x28(%rax)
addq $0x38, %rax
addq $-0x38, %rdx
jne 0x4cb7
movq %rcx, (%r14)
testl %r15d, %r15d
jle 0x4d3c
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
movq (%rbx), %rbp
leaq (%r12,%rbp), %rsi
movq %r15, %rdi
callq 0x63aa
movl 0x30(%rbp,%r12), %eax
movl %eax, 0x30(%rsp)
movq (%r14), %rbp
leaq (%r12,%rbp), %rdi
movq %r15, %rsi
callq 0x654a
movl 0x30(%rsp), %eax
movl %eax, 0x30(%rbp,%r12)
movq %r15, %rdi
callq 0x618a
incq %r13
movslq 0x14(%r14), %rax
addq $0x38, %r12
cmpq %rax, %r13
jl 0x4cef
jmp 0x4d3c
movq %rcx, (%r14)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x618a
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::addROA(IPPrefix, int)
void addROA(IPPrefix prefix, int maxLength) {
    int endIndex = min(maxLength, endLength);
    if (prefix.isSubPrefixOf(bound)){
      for (int i=prefix.getLength(); i<=endIndex; i++)
        lists[i-bound.getLength()].add(prefix.getPrefix(), prefix.endAddress(i));
    } else if (bound.isSubPrefixOf(prefix)) {
      for (int i=bound.getLength(); i<=endIndex; i++)
        lists[i-bound.getLength()].add(bound.getPrefix(), bound.endAddress(i));
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x10(%rdi), %eax
cmpl %edx, %eax
cmovll %eax, %ebx
movl 0x8(%rdi), %eax
movl 0xc(%rdi), %r13d
movl 0x4(%rsi), %r12d
cmpl %r12d, %r13d
jg 0x4e3e
movl (%r15), %edx
movl %r13d, %ecx
negb %cl
shrl %cl, %edx
shll %cl, %edx
testl %r13d, %r13d
cmovel %r13d, %edx
cmpl %eax, %edx
jne 0x4e3e
cmpl %ebx, %r12d
jg 0x4ee5
incl %ebx
movl $0x20, %ebp
subl %r12d, %ebp
leaq 0x10(%rsp), %r13
movl %r12d, %eax
subl 0xc(%r14), %eax
cltq
imulq $0x38, %rax, %rdi
addq (%r14), %rdi
movl (%r15), %eax
movl %eax, 0x14(%rsp)
movl 0x4(%r15), %ecx
xorl %edx, %edx
cmpl %r12d, %ecx
jg 0x4e1e
testl %ecx, %ecx
js 0x4ef4
je 0x4e0e
negb %cl
movl $0x1, %esi
shll %cl, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %edx
addl %eax, %edx
addl %esi, %edx
cmpl %eax, %edx
jae 0x4e1e
jmp 0x4f13
movl %eax, %edx
testl %r12d, %r12d
je 0x4e1e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %edx
movl %edx, 0x10(%rsp)
leaq 0x14(%rsp), %rsi
movq %r13, %rdx
callq 0x67d6
incl %r12d
decl %ebp
cmpl %r12d, %ebx
jne 0x4dc3
jmp 0x4ee5
cmpl %r13d, %r12d
jg 0x4ee5
movl %r12d, %ecx
negb %cl
shrl %cl, %eax
shll %cl, %eax
testl %r12d, %r12d
cmovel %r12d, %eax
cmpl (%r15), %eax
setne %al
cmpl %ebx, %r13d
setg %cl
orb %al, %cl
jne 0x4ee5
incl %ebx
movl $0x20, %ebp
subl %r13d, %ebp
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movl 0xc(%r14), %ecx
movl %r13d, %eax
subl %ecx, %eax
cltq
imulq $0x38, %rax, %rdi
addq (%r14), %rdi
movl 0x8(%r14), %eax
xorl %edx, %edx
movl %eax, 0xc(%rsp)
cmpl %ecx, %r13d
jl 0x4ecc
testl %ecx, %ecx
js 0x4ef4
je 0x4ebc
negb %cl
movl $0x1, %esi
shll %cl, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %edx
addl %esi, %edx
addl %eax, %edx
jae 0x4ecc
jmp 0x4f13
movl %eax, %edx
testl %r13d, %r13d
je 0x4ecc
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %ebp, %ecx
shll %cl, %edx
movl %edx, 0x8(%rsp)
movq %r15, %rsi
movq %r12, %rdx
callq 0x67d6
incl %r13d
decl %ebp
cmpl %r13d, %ebx
jne 0x4e7b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33db(%rip), %rdi      # 0x82d6
leaq 0x317e(%rip), %rsi      # 0x8080
leaq 0x33d9(%rip), %rcx      # 0x82e2
movl $0x4f, %edx
callq 0x2150
leaq 0x3353(%rip), %rdi      # 0x826d
leaq 0x315f(%rip), %rsi      # 0x8080
leaq 0x334e(%rip), %rcx      # 0x8276
movl $0x1c, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::ROAGroup(ROAGroup const&)
ROAGroup(const ROAGroup& original){
      
      known = new PrefixRange( *original.known );
      ases = original.ases;

      unordered_map<int, PrefixRange*> origMap =  original.AStoROA;

      for( set<int>::iterator j = ases.begin(); j!= ases.end(); ++j){
        int as = *j;

        AStoROA[as] = new PrefixRange( *origMap[as] );
      }

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
leaq 0x48(%rdi), %r13
leaq 0x50(%rdi), %r14
movl $0x0, 0x50(%rdi)
xorl %eax, %eax
movq %rax, 0x58(%rdi)
movq %r14, 0x60(%rdi)
movq %r14, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movl $0x18, %edi
movq %r13, 0x8(%rsp)
callq 0x2230
movq %rax, %r12
movq 0x38(%r15), %rsi
movq %rax, %rdi
callq 0x4c54
movq %r12, 0x38(%rbx)
leaq 0x48(%r15), %rsi
movq %r13, %rdi
callq 0x6940
xorl %eax, %eax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%rdi)
movups 0x20(%r15), %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq %rsp, %rdx
movq %rdi, (%rdx)
movq %r15, %rsi
callq 0x6c02
movq 0x60(%rbx), %r15
cmpq %r14, %r15
je 0x5048
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movl 0x20(%r15), %eax
movl %eax, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x710e
movq (%rax), %rsi
movq %rbp, %rdi
callq 0x4c54
movq %rbx, %rdi
movq %r13, %rsi
callq 0x710e
movq %rbp, (%rax)
movq %r15, %rdi
callq 0x2290
movq %rax, %r15
cmpq %r14, %rax
jne 0x5000
leaq 0x10(%rsp), %rdi
callq 0x6e14
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5075
movq %rax, %r15
movl $0x18, %esi
movq %r12, %rdi
callq 0x2240
jmp 0x5099
movq %rax, %r15
jmp 0x5099
movq %rax, %r15
movl $0x18, %esi
movq %rbp, %rdi
callq 0x2240
jmp 0x508f
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x6e14
movq 0x8(%rsp), %rdi
callq 0x6db0
movq %rbx, %rdi
callq 0x6e14
movq %r15, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::~ROAGroup()
inline ~ROAGroup() {
      for( set<int>::iterator j = ases.begin(); j!= ases.end(); ++j){
        int as = *j;
        delete AStoROA[as];
      }
      delete known;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
leaq 0x50(%rdi), %r15
cmpq %r15, %r14
je 0x516d
leaq 0x4(%rsp), %rbp
movq %rbx, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movl 0x20(%r14), %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x710e
movq (%rax), %r12
testq %r12, %r12
je 0x514c
movq (%r12), %r13
testq %r13, %r13
je 0x514c
movq -0x8(%r13), %r15
testq %r15, %r15
je 0x5129
imulq $0x38, %r15, %rbx
leaq -0x38(%r13), %rbp
leaq (%rbx,%rbp), %rdi
callq 0x618a
addq $-0x38, %rbx
jne 0x511a
addq $-0x8, %r13
imulq $0x38, %r15, %rsi
addq $0x8, %rsi
movq %r13, %rdi
callq 0x2390
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rbp
movl $0x18, %esi
movq %r12, %rdi
callq 0x2240
movq %r14, %rdi
callq 0x2290
movq %rax, %r14
cmpq %r15, %rax
jne 0x50e5
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x51b4
movq (%r14), %r12
testq %r12, %r12
je 0x51b4
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x51a4
imulq $0x38, %r13, %rbp
addq $-0x38, %r12
leaq (%r12,%rbp), %rdi
callq 0x618a
addq $-0x38, %rbp
jne 0x5195
imulq $0x38, %r13, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x2390
leaq 0x48(%rbx), %r15
movl $0x18, %esi
movq %r14, %rdi
callq 0x2240
movq %r15, %rdi
callq 0x6db0
movq %rbx, %rdi
callq 0x6e14
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x5d5d
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROA::toJSON[abi:cxx11]()
string toJSON(){
      stringstream ss;
      ss<<"{";
      ss<<"\"AS\":"<<getAS()<<", ";
      ss<<"\"PREFIX\":\""<<getPrefix()<<"-"<<getMaxlen()<<"\", ";
      ss<<"\"PATH\":"<<"\""<<getPath()<<"\""; 
      ss<<"}";

      return ss.str();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2190
leaq 0x40(%rsp), %r14
leaq 0x2f3b(%rip), %rsi      # 0x833d
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x2ef3(%rip), %rsi      # 0x8309
movl $0x5, %edx
movq %r14, %rdi
callq 0x2280
movl 0xc(%r15), %esi
movq %r14, %rdi
callq 0x2340
leaq 0x2efb(%rip), %rsi      # 0x8331
movl $0x2, %edx
movq %rax, %rdi
callq 0x2280
leaq 0x2ec5(%rip), %rsi      # 0x830f
movl $0xa, %edx
movq %r14, %rdi
callq 0x2280
movq (%r15), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x2598
leaq 0x2bc3(%rip), %rsi      # 0x8034
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
movl 0x8(%r15), %esi
movq %r14, %rdi
callq 0x2340
leaq 0x2e9f(%rip), %rsi      # 0x8330
movl $0x3, %edx
movq %rax, %rdi
callq 0x2280
leaq 0x2e75(%rip), %rsi      # 0x831a
movl $0x7, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x2e5f(%rip), %rsi      # 0x8318
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7078
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2280
leaq 0x2e1a(%rip), %rsi      # 0x8318
movl $0x1, %edx
movq %rax, %rdi
callq 0x2280
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5522
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2240
leaq 0x2b15(%rip), %rsi      # 0x803e
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2300
movq 0x6a66(%rip), %rsi      # 0xbfb0
leaq 0x30(%rsp), %rdi
callq 0x21b0
leaq 0xb0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5591
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5594
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2240
jmp 0x5594
movq %rax, %rbx
movq 0x6a15(%rip), %rsi      # 0xbfb0
leaq 0x30(%rsp), %rdi
callq 0x21b0
leaq 0xb0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::toJSON[abi:cxx11]()
string toJSON(){
    stringstream ss;
    ss<<"[";
    for (int i = 0; i<len; i++){
      ss << "\"" << lists[i] << "/"<<bound.getLength()+i << "\"";
      if (i!=len-1) ss<<", ";
    }
    ss<<"]";
    return ss.str();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2190
leaq 0x20(%rsp), %r14
leaq 0x2a5a(%rip), %rsi      # 0x8043
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
cmpl $0x0, 0x14(%r15)
jle 0x5697
xorl %ebp, %ebp
leaq 0x2d0e(%rip), %r12      # 0x8318
xorl %r13d, %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2280
movq (%r15), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x4987
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x29e5(%rip), %rsi      # 0x8022
callq 0x2280
movl 0xc(%r15), %esi
addl %r13d, %esi
movq %rbx, %rdi
callq 0x2340
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2280
movl 0x14(%r15), %eax
leal -0x1(%rax), %ecx
cmpq %rcx, %r13
je 0x5685
movl $0x2, %edx
movq %r14, %rdi
leaq 0x2cb5(%rip), %rsi      # 0x8331
callq 0x2280
movl 0x14(%r15), %eax
incq %r13
cltq
addq $0x38, %rbp
cmpq %rax, %r13
jl 0x560d
leaq 0x2bcd(%rip), %rsi      # 0x826b
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x2300
movq 0x68ef(%rip), %rsi      # 0xbfb0
leaq 0x10(%rsp), %rdi
callq 0x21b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
movq 0x8(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56f1
movq %rax, %rbx
movq 0x68b5(%rip), %rsi      # 0xbfb0
leaq 0x10(%rsp), %rdi
callq 0x21b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: PrefixRange::Setup(int)
void Setup( int boundingMaxLength ) {
    if (boundingMaxLength<bound.getLength()) {
      lists = NULL;
      len = 0;
      endLength = boundingMaxLength;
      return;
    }
    endLength = boundingMaxLength;
    len = endLength-bound.getLength()+1;
    lists = new IntervalList<IPAddr>[len];
    for (int i = bound.getLength(); i<=endLength; i++) {
      // lists[i-bound.getLengt()] is responsible for storing intervals
      // at level i of the prefix tree, i.e., prefixes that end in /i
      // At this level, to consecutive prefixes differ by 2^(IPAdder::numBits-i)
      // For example, if i==24, then we store /24 prefixes in lists[i-bound.getLength()]
      // Two /24 prefixes are contiguous if they differ by 2^(32-24)=2^8=256
      if ( i == 0 ) lists[i-bound.getLength()].setIncrement(1); // avoiding issues from left shifting by 32
      else lists[i-bound.getLength()].setIncrement(1<<((IPAddr::numBits)-i)); //~erh refactor
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq 0xc(%rdi), %r12
cmpl %r12d, %esi
jge 0x6091
movq $0x0, (%r14)
movl $0x0, 0x14(%r14)
movl %ebx, 0x10(%r14)
jmp 0x6161
movl %ebx, %r13d
subl %r12d, %r13d
leal 0x1(%r13), %eax
movslq %eax, %r15
movl $0x38, %ecx
movq %r15, %rax
mulq %rcx
seto %cl
addq $0x8, %rax
movq $-0x1, %rdi
cmovbq %rdi, %rax
movl %ebx, 0x10(%r14)
movl %r15d, 0x14(%r14)
testb %cl, %cl
cmoveq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
incl %r13d
je 0x610b
leaq 0x10(%rax), %rdx
imulq $0x38, %r15, %rsi
xorl %edi, %edi
movl $0x0, (%rdx)
movq %rdi, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
movq %rdi, 0x20(%rdx)
movl $0x1, 0x28(%rdx)
addq $0x38, %rdx
addq $-0x38, %rsi
jne 0x60e4
movq %rcx, (%r14)
movq %r12, %rdx
negq %rdx
imulq $0x38, %rdx, %rdx
addq %rcx, %rdx
incl %ebx
movl $0x20, %ecx
subl %r12d, %ecx
addq $0x38, %rax
testq %r12, %r12
je 0x6140
cmpq $0x0, -0x8(%rax)
jne 0x616b
movl $0x1, %esi
shll %cl, %esi
movl %esi, (%rax)
jmp 0x614e
cmpq $0x0, 0x28(%rdx)
jne 0x616b
movl $0x1, 0x30(%rdx)
incq %r12
addq $0x38, %rax
leal (%rbx,%rcx), %esi
decl %esi
decl %ecx
cmpl $0x20, %esi
jne 0x6129
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x204d(%rip), %rdi      # 0x81bf
leaq 0x1f07(%rip), %rsi      # 0x8080
leaq 0x2049(%rip), %rcx      # 0x81c9
movl $0x96, %edx
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::Setup()
void Setup() {
      AStoROA.clear();    
      known = new PrefixRange(); 
      unknown = (PrefixRange*)NULL;

      changed = true;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6d4a
movl $0x18, %edi
callq 0x2230
movq %rax, %r14
movq $0x0, 0x8(%rax)
movq %rax, %rdi
movl $0x20, %esi
callq 0x6062
movq %r14, 0x38(%rbx)
movq $0x0, 0x40(%rbx)
movb $0x1, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O3/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: ROAGroup::addROA(int, IPPrefix, int)
void addROA(int as, IPPrefix prefix, int maxLength){
      // If we don't have a prefixRange setup for this AS then set one up
      if ( ! hasAS(as) ) { 
         AStoROA[as] = new PrefixRange();
         ases.insert(as);
      } 

      AStoROA[as]->addROA(prefix, maxLength);

      // known prefixes includes the invalid shadows of the valid prefixes
      known->addROA(prefix, IPAddr::numBits);

      changed = true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, 0x8(%rsp)
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x619e
testq %rax, %rax
jne 0x6f05
movl $0x18, %edi
callq 0x2230
movq %rax, %r15
movq $0x0, 0x8(%rax)
movq %rax, %rdi
movl $0x20, %esi
callq 0x6062
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x710e
movq %r15, (%rax)
leaq 0x48(%rbx), %rdi
movq %r12, %rsi
callq 0x6f6a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x710e
movq (%rax), %rdi
movq (%r14), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movl %ebp, %edx
callq 0x4d5e
movq 0x38(%rbx), %rdi
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movl $0x20, %edx
callq 0x4d5e
movb $0x1, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamjanovsky[P]PA193_test_parser_monero/main.cpp
// Function: main
int main(int argc, const char * argv[]) {
    
    if (argc != 3) {
        std::cerr << "Usage: parser <block_to_validate> <valid_block>" << std::endl;
        return 1;
    }
   
    string f_lower(argv[1]);
    string f_higher(argv[2]);

    Parser p = Parser();
    
    p.validate_block(f_lower, f_higher, true);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
cmpl $0x3, %edi
jne 0x255f
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq -0x98(%rbp), %rdi
leaq -0x1d8(%rbp), %rdx
callq 0x2080
movq 0x10(%rbx), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x1d8(%rbp), %rdx
callq 0x2080
leaq -0x1c0(%rbp), %r14
leaq -0x1d8(%rbp), %rbx
xorl %r15d, %r15d
movl $0x140, %edx            # imm = 0x140
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20c0
movq %r14, 0x8(%rbx)
movb %r15b, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
movq %r15, 0x78(%r14)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
leaq -0x120(%rbp), %rax
movq %rax, -0x10(%rax)
movb %r15b, (%rax)
movups %xmm0, 0x68(%rax)
movq %r15, 0x78(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x26ba
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x26ba
leaq -0x1d8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0x2758
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x251a
callq 0x2110
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x2528
callq 0x2110
leaq -0x1d8(%rbp), %rdi
callq 0x261e
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2546
callq 0x2110
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x255b
callq 0x2110
xorl %eax, %eax
jmp 0x25a6
movq 0x5a8a(%rip), %rbx      # 0x7ff0
leaq 0x2a97(%rip), %rsi      # 0x5004
movl $0x2f, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0x1, %eax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x25ca
callq 0x2110
jmp 0x25ca
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x25dd
callq 0x2110
jmp 0x25dd
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x261e
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2600
callq 0x2110
jmp 0x2600
movq %rax, %rbx
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2615
callq 0x2110
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamjanovsky[P]PA193_test_parser_monero/src/block.cpp
// Function: Block::load_tx_hashes(std::basic_ifstream<char, std::char_traits<char>>&)
int Block::load_tx_hashes(ifstream & in) {
    // Read count of tx hashes
    if (tools::read_varint(in, tx_hashes_count) < 0) {
        std::cerr << "Tx hashes: could not read count of hashes." << std::endl;
        return ERR_TXH_PARSER_ERROR;
    }

    // Alloc memory
    tx_hashes.resize(tx_hashes_count * hash::HASH_SIZE, 0x00);

    // Read the hashes
    in.read(reinterpret_cast<char *>(&tx_hashes[0]), tx_hashes.size());
    if(!in.good()) {
        std::cerr << "Tx hashes: invalid stream." << std::endl;
        return ERR_TXH_PARSER_ERROR;
    }

    // Try to read one more byte and test EOF
    char c;
    in.read(&c, 1);
    if(!in.eof()) {
        // still some bytes to read, weird
        std::cerr << "Tx hashes: Blocked parsed but some bytes are remaining." << std::endl;
        return ERR_TXH_NO_EOF;
    }

    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x98(%rdi), %rsi
movq %rbx, %rdi
callq 0x41d2
testl %eax, %eax
js 0x3496
leaq 0x80(%r14), %rdi
movq 0x98(%r14), %rsi
shlq $0x5, %rsi
leaq -0x12(%rbp), %rdx
movb $0x0, (%rdx)
callq 0x37be
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0x34e6
movq 0x4b68(%rip), %rbx      # 0x7ff0
leaq 0x1fa6(%rip), %rsi      # 0x5435
movl $0x1a, %edx
jmp 0x34a9
movq 0x4b53(%rip), %rbx      # 0x7ff0
leaq 0x1f66(%rip), %rsi      # 0x540a
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
movq -0x18(%rax), %rcx
xorl %eax, %eax
testb $0x2, 0x20(%rbx,%rcx)
jne 0x34dd
movq 0x4ae2(%rip), %rbx      # 0x7ff0
leaq 0x1f3b(%rip), %rsi      # 0x5450
movl $0x37, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
jmp 0x34dd
// File: /workspace/github_cpp_makefile_star2_O3/adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::expect_byte(std::istream&, unsigned char)
int tools::expect_byte(std::istream & in, unsigned char expected_byte) {
    unsigned char c;
    in.read(reinterpret_cast<char *>(&c), 1);
    
    // Check for EOF
    if (!in.good()) {
        std::cerr << "Expect byte: Unexpected end of stream." << std::endl;
        return ERR_EXPBT_UNEXPECTED_EOF;
    }
    
    // Check the value
    if (c != expected_byte) {
        std::cerr << "Expect byte: Input " << std::hex << c;
        std::cerr << std::dec << " does not match expected input ";
        std::cerr << std::hex << expected_byte << std::dec << "." << std::endl;
        return ERR_EXPBT_DOES_NOT_MATCH;
    }
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x3fb3
movq 0x405c(%rip), %rbx      # 0x7ff0
leaq 0x15a2(%rip), %rsi      # 0x553d
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2160
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x408e
xorl %r14d, %r14d
cmpb %bl, -0x11(%rbp)
je 0x40b5
movq 0x402a(%rip), %r14      # 0x7ff0
leaq 0x1597(%rip), %rsi      # 0x5564
movl $0x13, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movb -0x11(%rbp), %al
leaq -0x12(%rbp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
leaq 0x1553(%rip), %rsi      # 0x5578
movl $0x1f, %edx
movq %r14, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
leaq -0x13(%rbp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x2160
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rax
movl 0x18(%rbx,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%rbx,%rax)
leaq 0x1074(%rip), %rsi      # 0x50ef
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2160
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::expect_byte_2(std::istream&, unsigned char)
int tools::expect_byte_2(std::istream & in, unsigned char expected_byte) {
    unsigned char c;
    in.read(reinterpret_cast<char *>(&c), 1);
    
    // Check for EOF
    if (!in.good()) {
        std::cerr << "Expect byte: Unexpected end of stream." << std::endl;
        return ERR_EXPBT_UNEXPECTED_EOF;
    }
    
    // Check the value
    if (c != expected_byte) {
        return ERR_EXPBT_DOES_NOT_MATCH;
    }
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x4137
movq 0x3efb(%rip), %rbx      # 0x7ff0
leaq 0x1441(%rip), %rsi      # 0x553d
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x4141
xorl %eax, %eax
cmpb %bl, -0x11(%rbp)
setne %al
negl %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::write_varint(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)
int tools::write_varint(std::vector<unsigned char> & out_vect, unsigned long val) {
    
    unsigned char c;
    
    while (val >= 0x80) {
        // get lowest 7 bits
        c = val & 0x7f;
        // save to the vector with the first bit set to 1
        out_vect.push_back(c | 0x80);
        // shift the value
        val >>= 7;
    }
    
    // write the last byte (with the first bit set to 0)
    c = val & 0x7f;
    out_vect.push_back(c);
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x80, %rsi
jb 0x41a1
leaq -0x19(%rbp), %r15
movl %r14d, %eax
orb $-0x80, %al
movb %al, -0x19(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4181
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x418c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x47ac
movq %r14, %rax
shrq $0x7, %rax
cmpq $0x3fff, %r14           # imm = 0x3FFF
movq %rax, %r14
ja 0x4167
jmp 0x41a4
movq %r14, %rax
movb %al, -0x1a(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x41b9
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x41c5
leaq -0x1a(%rbp), %rdx
movq %rbx, %rdi
callq 0x3e6c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::skip_varint(std::istream&)
int tools::skip_varint(std::istream & in) {
    unsigned char c;
    in.read((char *)&c, 1);
    int bytes_skipped = 1;

    // read from the stream until there was a byte that started with a zero bit
    while (c & 0x80 && bytes_skipped <= 10) {
        if (in.eof()) {
            std::cerr << "Skip Varint: Unexpected end of stream." << std::endl;
            return ERR_SKIPV_UNEXPECTED_EOF;
        }
        in.read((char *)&c, 1);
        bytes_skipped++;
    }
    
    if (bytes_skipped > 10) {
        std::cerr << "Skip Varint: String too long." << std::endl;
        return ERR_SKIPV_VARINT_TOO_LONG;
    }
    
    return bytes_skipped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x19(%rbp), %r15
movl $0x1, %edx
movq %r15, %rsi
callq 0x2180
movl $0x1, %ebx
cmpb $0x0, (%r15)
jns 0x447a
xorl %ebx, %ebx
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x442b
incl %ebx
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
cmpb $0x0, -0x19(%rbp)
jns 0x4407
cmpl $0xa, %ebx
jb 0x43db
cmpl $0xa, %ebx
jb 0x4478
movq 0x3bdd(%rip), %rdi      # 0x7ff0
leaq 0x11ea(%rip), %rsi      # 0x5604
movl $0x1d, %edx
callq 0x2160
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x4448
movq 0x3bbe(%rip), %rdi      # 0x7ff0
leaq 0x11a4(%rip), %rsi      # 0x55dd
movl $0x26, %edx
callq 0x2160
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x3ba1(%rip), %r14      # 0x7ff0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
jmp 0x447a
incl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/analyzeBasic.cc
// Function: AnalyzeBasic::storeHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void AnalyzeBasic::storeHash(string tableName) {
	ofstream storeFile;
	storeFile.open(tableName.c_str() );

	storeFile << seedLength << endl;

	for (int i = 0; i < freqTable.size(); i++)
		storeFile << freqTable[i] << endl;

	storeFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x33d0
movq (%r14), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x3040
movl 0x270(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x3190
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq 0x278(%rbx), %rax
cmpq %rax, 0x280(%rbx)
je 0x4a14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x3190
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
incq %r12
movq 0x278(%rbx), %rax
movq 0x280(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
ja 0x49c1
leaq 0x8(%rsp), %rdi
callq 0x3330
movq 0x459b(%rip), %rax      # 0x8fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x31f0
leaq 0x100(%rsp), %rdi
callq 0x30e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4a61
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/CMU-SAFARI[P]optimal-seed-solver/analyzeBasic.cc
// Function: AnalyzeBasic::loadHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void AnalyzeBasic::loadHash(string tableName) {
	ifstream storeFile;
	storeFile.open(tableName.c_str() );

	storeFile >> seedLength;

	freqTable.resize( (1 << (2 * seedLength) ), 0);
	
	for (int i = 0; i < freqTable.size(); i++)
		storeFile >> freqTable[i];

	storeFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x32a0
movq (%r14), %rsi
movq %r15, %rdi
movl $0x8, %edx
callq 0x3160
leaq 0x270(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3400
movb 0x270(%rbx), %cl
addb %cl, %cl
movl $0x1, %esi
shll %cl, %esi
leaq 0x278(%rbx), %rdi
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
callq 0x4bb6
movq 0x278(%rbx), %rsi
cmpq %rsi, 0x280(%rbx)
je 0x4b25
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
xorl %r12d, %r12d
addq %r15, %rsi
movq %r14, %rdi
callq 0x3400
incq %r12
movq 0x278(%rbx), %rsi
movq 0x280(%rbx), %rax
subq %rsi, %rax
sarq $0x2, %rax
addq $0x4, %r15
cmpq %r12, %rax
ja 0x4af9
leaq 0x10(%rsp), %rdi
callq 0x3080
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4b4c
jmp 0x4b4c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O3/danishansari[P]NumberToText/src/NumToEnglish.cpp
// Function: NumToEnglish::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string NumToEnglish::convert(string numStr)
{
    vector<int> digitsVec;

    // parsing each digits, to convert to int
    for (int i = numStr.length()-1; i >=0 ; i--)
    {
        if ((int)numStr[i] > 47 && (int)numStr[i] < 58)
        {
            // conversion to int
            int tmpNum = (int)numStr[i] - 48;

            // push into the vector 
            digitsVec.push_back(tmpNum);
        }
        else
            return "invalid input";
    }

    // helper function to convert vector of int to text.
    return getText(digitsVec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movl 0x8(%rdx), %r13d
movl %r13d, %eax
decl %eax
js 0x3fec
movq %rdx, %r14
leaq -0x50(%rbp), %r15
leaq -0x2c(%rbp), %r12
decl %r13d
movq (%r14), %rax
movzbl (%rax,%r13), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x401c
addl $-0x30, %eax
movl %eax, -0x2c(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x3fdc
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x48(%rbp)
jmp 0x3fe7
movq %r15, %rdi
movq %r12, %rdx
callq 0x4714
testl %r13d, %r13d
jg 0x3fad
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4602
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
callq 0x409e
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x4039
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x4039
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x11f6(%rip), %rsi      # 0x5220
leaq 0x11fc(%rip), %rdx      # 0x522d
movq %rbx, %rdi
callq 0x3c50
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x404e
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x407e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x4081
movq -0x58(%rbp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x4081
jmp 0x407e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x4096
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/danishansari[P]NumberToText/src/NumToText.cpp
// Function: NumToText::getConvertor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
NumToText* NumToText::getConvertor(string lang)
{
    // transform input string to lover case
    transform(lang.begin(), lang.end(), lang.begin(), ::tolower);

    // english language
    if (lang == "english")
    {
        // return english lang derived class pointer
        return new NumToEnglish();
    }
    else // other language
        cout << "Err: Language '" << lang << "' not supported." << endl;

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x4887
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x2160
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x4871
leaq 0x805(%rip), %rsi       # 0x5093
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x4906
movq 0x2737(%rip), %r14      # 0x6fd8
leaq 0x9a6(%rip), %rsi       # 0x524e
movl $0xf, %edx
movq %r14, %rdi
callq 0x2150
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2150
movq %rax, %rbx
leaq 0x990(%rip), %rsi       # 0x525e
movl $0x10, %edx
movq %rax, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20b0
xorl %eax, %eax
jmp 0x491e
movl $0x8, %edi
callq 0x2130
leaq 0x2441(%rip), %rcx      # 0x6d58
addq $0x10, %rcx
movq %rcx, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/hex/../lib/gtpbase.h
// Function: Morat::GTPBase::run()
bool run(){
		running = true;
		char buf[1001];

		while(running && fgets(buf, 1000, in)){
			std::string line(buf);

			trim(line);

			if(line.length() == 0 || line[0] == '#')
				continue;

			GTPResponse response = cmd(line);

			if(out){
				std::string output = response.to_s();

				fwrite(output.c_str(), 1, output.length(), out);
				fflush(out);
			}
		}
		return running;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp            # imm = 0x4A8
leaq 0x18(%rsp), %rbp
leaq 0x58(%rsp), %r13
leaq 0xb0(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x48(%rsp), %r12
movq %rdi, %rbx
movb $0x1, 0x2c(%rdi)
movq (%rbx), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdi
callq 0x5580
testq %rax, %rax
je 0x985d
movq %r14, %rdi
movq %rbp, 0x8(%rsp)
callq 0x5140
leaq 0xb0(%rsp,%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb1dc
movq %r15, %rdi
callq 0x2f822
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x9843
cmpb $0x23, (%rsi)
je 0x9843
addq %rsi, %rdx
movq %r13, 0x48(%rsp)
movq %r12, %rdi
callq 0xa930
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x93a2
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x97c2
callq 0x52e0
cmpq $0x0, 0x8(%rbx)
je 0x980d
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xbdb8
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x8(%rbx), %rcx
movl $0x1, %esi
callq 0x5710
movq 0x8(%rbx), %rdi
callq 0x53d0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x980d
callq 0x52e0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x9827
callq 0x52e0
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x983e
callq 0x52e0
movq 0x8(%rsp), %rsi
cmpq %rbp, %rsi
je 0x9850
movq %rsi, %rdi
callq 0x52e0
movb 0x2c(%rbx), %al
testb %al, %al
jne 0x9736
jmp 0x9860
movb 0x2c(%rbx), %al
andb $0x1, %al
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68(%rsp), %rdi
movq %rax, %rbx
callq 0x96d6
jmp 0x989c
movq 0x48(%rsp), %rdi
movq %rax, %rbx
cmpq %r13, %rdi
je 0x989c
callq 0x52e0
jmp 0x989c
jmp 0x9899
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x98ab
callq 0x52e0
movq %rbx, %rdi
callq 0x5670