LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %r14
movl 0x10(%rdi), %eax
cmpl %edx, %eax
cmovll %eax, %edx
movl %edx, 0x4(%rsp)
movq %rsi, %r15
movq 0x8(%rdi), %rax
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %r15, %rdi
callq 0x5766
testb %al, %al
je 0x3df8
movslq 0x4(%r15), %r12
imulq $0x38, %r12, %rbx
leaq 0x14(%rsp), %r13
cmpl 0x4(%rsp), %r12d
jg 0x3e64
movslq 0xc(%r14), %rax
imulq $-0x38, %rax, %rbp
addq (%r14), %rbp
addq %rbx, %rbp
movl (%r15), %eax
movl %eax, 0xc(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x523c
movq %rbp, %rdi
leaq 0xc(%rsp), %rsi
movq %r13, %rdx
callq 0x5786
incl %r12d
addq $0x38, %rbx
jmp 0x3db1
leaq 0x8(%r14), %r12
movq (%r15), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, %rdi
callq 0x5766
testb %al, %al
je 0x3e64
movslq 0xc(%r14), %r15
imulq $0x38, %r15, %rbx
leaq 0x10(%rsp), %r13
cmpl 0x4(%rsp), %r15d
jg 0x3e64
movslq 0xc(%r14), %rax
imulq $-0x38, %rax, %rbp
addq (%r14), %rbp
addq %rbx, %rbp
movl 0x8(%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x523c
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x5786
incl %r15d
addq $0x38, %rbx
jmp 0x3e20
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
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), %r15
andl $0x0, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movq %r15, 0x60(%rdi)
movq %r15, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
pushq $0x18
popq %rdi
callq 0x2240
movq %rax, %r14
movq 0x38(%r12), %rsi
movq %rax, %rdi
callq 0x3c86
movq %r14, 0x38(%rbx)
leaq 0x48(%r12), %rsi
movq %r13, %rdi
callq 0x58e0
movq %r13, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x5bea
movq 0x60(%rbx), %rbp
leaq 0x10(%rsp), %r12
leaq 0x4(%rsp), %r13
cmpq %r15, %rbp
je 0x3f58
movl 0x20(%rbp), %eax
movl %eax, 0x4(%rsp)
pushq $0x18
popq %rdi
callq 0x2240
movq %rax, %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x611c
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3c86
movq %rbx, %rdi
movq %r13, %rsi
callq 0x611c
movq %r14, (%rax)
movq %rbp, %rdi
callq 0x2290
movq %rax, %rbp
jmp 0x3f10
leaq 0x10(%rsp), %rdi
callq 0x5eea
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x3fa8
movq %rax, %r15
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x2250
jmp 0x3fad
movq %rax, %r15
jmp 0x3fad
movq %rax, %r15
jmp 0x3f9e
movq %rax, %r15
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x2250
leaq 0x10(%rsp), %rdi
callq 0x5eea
movq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x5e7e
movq %rbx, %rdi
callq 0x5eea
movq %r15, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r12
leaq 0x50(%rdi), %rbp
leaq 0x4(%rsp), %r14
pushq $0x18
popq %r15
cmpq %rbp, %r12
je 0x4026
movl 0x20(%r12), %eax
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x611c
movq (%rax), %r13
testq %r13, %r13
je 0x400e
movq %r13, %rdi
callq 0x3bf6
movq %r13, %rdi
movq %r15, %rsi
callq 0x2250
movq %r12, %rdi
callq 0x2290
movq %rax, %r12
jmp 0x3fe5
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x4037
movq %r14, %rdi
callq 0x3bf6
leaq 0x48(%rbx), %r15
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x2250
movq %r15, %rdi
callq 0x5e7e
movq %rbx, %rdi
callq 0x5eea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x4b17
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21a0
leaq 0x40(%rsp), %r14
leaq 0x2ff9(%rip), %rsi      # 0x7321
movq %r14, %rdi
callq 0x2230
leaq 0x2fb6(%rip), %rsi      # 0x72ed
movq %r14, %rdi
callq 0x2230
movl 0xc(%r15), %esi
movq %rax, %rdi
callq 0x2340
leaq 0x2fc3(%rip), %rsi      # 0x7315
movq %rax, %rdi
callq 0x2230
leaq 0x2f92(%rip), %rsi      # 0x72f3
movq %r14, %rdi
callq 0x2230
movq %rax, %r12
movq (%r15), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, %rdi
callq 0x2527
leaq 0x2c92(%rip), %rsi      # 0x7018
movq %r12, %rdi
callq 0x2230
movl 0x8(%r15), %esi
movq %rax, %rdi
callq 0x2340
leaq 0x2f73(%rip), %rsi      # 0x7314
movq %rax, %rdi
callq 0x2230
leaq 0x2f4e(%rip), %rsi      # 0x72fe
movq %r14, %rdi
callq 0x2230
leaq 0x2f3d(%rip), %rsi      # 0x72fc
movq %rax, %rdi
callq 0x2230
movq %rax, %r12
addq $0x10, %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x22c0
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x2210
leaq 0x2f0d(%rip), %rsi      # 0x72fc
movq %rax, %rdi
callq 0x2230
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x2c1a(%rip), %rsi      # 0x7022
movq %r14, %rdi
callq 0x2230
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2300
leaq 0x30(%rsp), %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x444a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x444d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x21a0
leaq 0x20(%rsp), %r15
leaq 0x2b98(%rip), %rsi      # 0x7027
movq %r15, %rdi
callq 0x2230
xorl %ebx, %ebx
leaq 0x2e5c(%rip), %r12      # 0x72fc
leaq 0x2b5f(%rip), %r13      # 0x7006
xorl %ebp, %ebp
movslq 0x14(%r14), %rax
cmpq %rax, %rbp
jge 0x4512
movq %r15, %rdi
movq %r12, %rsi
callq 0x2230
movq (%r14), %rsi
addq %rbx, %rsi
movq %rax, %rdi
callq 0x3983
movq %rax, %rdi
movq %r13, %rsi
callq 0x2230
movl 0xc(%r14), %esi
addl %ebp, %esi
movq %rax, %rdi
callq 0x2340
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movl 0x14(%r14), %eax
decl %eax
cmpq %rax, %rbp
je 0x4509
movq %r15, %rdi
leaq 0x2e11(%rip), %rsi      # 0x7315
callq 0x2230
incq %rbp
addq $0x38, %rbx
jmp 0x44a9
leaq 0x2d36(%rip), %rsi      # 0x724f
movq %r15, %rdi
callq 0x2230
leaq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x2300
leaq 0x10(%rsp), %rdi
callq 0x21c0
movq 0x8(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4553
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: UnknownToInvalidDowngrade::toJSON[abi:cxx11]()
string toJSON(){
    stringstream ss;

    ss<<"{";
    ss<<"\"CHANGE\":\"+U2I\", ";
    ss<<"\"ROA\":"<<getROA()->toJSON()<<", ";      
    ss<<"\"EFFECT\":"<<getUnknownToKnown()->toJSON()<<", "; 
    ss<<"\"EXCEPT\":{";
      for(unordered_map<int,PrefixRange*>::iterator i = getExceptions()->begin(); i != getExceptions()->end(); ++i){
        int as = i->first;
        PrefixRange* exception = i->second;
        if ( i != getExceptions()->begin() ) ss<<",";

        ss<<"\""<<as<<"\":"<<exception->toJSON();
      }
    ss<<"}"; // Closes EXCEPT
    
    ss<<"}"<<endl; // Closes hash
    
    return ss.str();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r12
movq %rdi, %r14
leaq 0x30(%rsp), %rdi
callq 0x21a0
leaq 0x40(%rsp), %r13
leaq 0x2d32(%rip), %rsi      # 0x7321
movq %r13, %rdi
callq 0x2230
leaq 0x2d08(%rip), %rsi      # 0x7306
movq %r13, %rdi
callq 0x2230
leaq 0x2ab0(%rip), %rsi      # 0x70bd
movq %r13, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x42fe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
leaq 0x2cdc(%rip), %rsi      # 0x7315
movq %rax, %rdi
callq 0x2230
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x2a72(%rip), %rsi      # 0x70c4
movq %r13, %rdi
callq 0x2230
movq %rax, %rbx
leaq 0x30(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4460
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2210
leaq 0x2c95(%rip), %rsi      # 0x7315
movq %rax, %rdi
callq 0x2230
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x2c7f(%rip), %rsi      # 0x7318
movq %r13, %rdi
callq 0x2230
movq %r14, 0x28(%rsp)
addq $0x58, %r12
leaq 0x8(%rsp), %rbp
movq %r12, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4723
movl 0x8(%r15), %r14d
movq 0x10(%r15), %rbx
cmpq (%r12), %r15
je 0x46d7
movq %r13, %rdi
leaq 0x295c(%rip), %rsi      # 0x702e
callq 0x2230
movq %r13, %rdi
leaq 0x2c1b(%rip), %rsi      # 0x72fc
callq 0x2230
movq %rax, %rdi
movl %r14d, %esi
callq 0x2340
movq %rax, %rdi
leaq 0x29c6(%rip), %rsi      # 0x70c1
callq 0x2230
movq %rax, %r14
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x4460
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2210
movq %rbp, %rdi
callq 0x20e0
jmp 0x46b2
leaq 0x28f8(%rip), %rsi      # 0x7022
movq %r13, %rdi
callq 0x2230
movq 0x28(%rsp), %rbx
leaq 0x28e4(%rip), %rsi      # 0x7022
movq %r13, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2100
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2300
leaq 0x30(%rsp), %rdi
callq 0x21c0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4795
jmp 0x4795
jmp 0x4786
jmp 0x4786
jmp 0x4795
jmp 0x4795
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x4798
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0xc(%rdi), %r12d
movl %esi, %r13d
subl %r12d, %r13d
jge 0x4f4a
andq $0x0, (%rbx)
andl $0x0, 0x14(%rbx)
movl %ebp, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leal 0x1(%r13), %eax
movslq %eax, %r14
pushq $0x38
popq %rcx
movq %r14, %rax
mulq %rcx
movslq %r12d, %r15
seto %cl
addq $0x8, %rax
pushq $-0x1
popq %rdi
cmovbq %rdi, %rax
movl %ebp, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
testb %cl, %cl
cmoveq %rax, %rdi
callq 0x2030
leaq 0x8(%rax), %rcx
movq %r14, (%rax)
incl %r13d
je 0x4fb7
addq $0x10, %rax
imulq $0x38, %r14, %rdx
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movl $0x1, 0x28(%rax)
addq $0x38, %rax
addq $-0x38, %rdx
jne 0x4f91
movq %rcx, (%rbx)
imulq $0x38, %r15, %r13
pushq $0x20
popq %r14
subl %r12d, %r14d
pushq $0x1
popq %r15
cmpl %ebp, %r12d
jg 0x4f3b
movq (%rbx), %rdi
movslq 0xc(%rbx), %rax
cmpl $0x20, %r14d
jne 0x4fee
negq %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movl %r15d, %esi
jmp 0x5000
imulq $-0x38, %rax, %rax
addq %r13, %rdi
addq %rax, %rdi
movl %r15d, %esi
movl %r14d, %ecx
shll %cl, %esi
callq 0x5014
incl %r12d
movl 0x10(%rbx), %ebp
addq $0x38, %r13
decl %r14d
jmp 0x4fc9
// File: /workspace/github_cpp_makefile_star2_O2/BUSEC[P]RPKI_Downgrade_Detector/./exp.cpp
// Function: IPPrefix::endAddress(int) const
inline IPAddr endAddress (int level) const {
    if (level<length) return 0;
    
    //Can't bit shift by 32
    assert( length >= 0 ); 
    if (length == 0){
      if (level == 0) return prefix;
      // at this point we know numBits-level<32, so the shift is safe
      else return (IPAddr::maxAddr - (1<<(IPAddr::numBits-level)) ) +1; //~erh refactor
    }
    
    // at this point we know numBits - length and numBits - level < 32, so the shifts are safe
    // we know we are adding a nonnegative quantity because length<=level
    // we know this addtion won't overflow because prefix has all zero bits after
    // the first length bits
    return prefix+((1<<(IPAddr::numBits-length))-(1<<(IPAddr::numBits-level)));
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rsi), %ecx
cmpl %edx, %ecx
jle 0x524c
andl $0x0, (%rbx)
jmp 0x5283
testl %ecx, %ecx
js 0x5288
je 0x5270
negb %cl
pushq $0x1
popq %rdi
shll %cl, %edi
negb %dl
pushq $-0x1
popq %rax
movl %edx, %ecx
shll %cl, %eax
addl %edi, %eax
movq %rbx, %rdi
movl %eax, %edx
callq 0x52a6
jmp 0x5283
testl %edx, %edx
je 0x527f
negb %dl
pushq $-0x1
popq %rax
movl %edx, %ecx
shll %cl, %eax
jmp 0x5281
movl (%rsi), %eax
movl %eax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x202b(%rip), %rdi      # 0x72ba
leaq 0x1dce(%rip), %rsi      # 0x7064
leaq 0x2029(%rip), %rcx      # 0x72c6
pushq $0x4f
popq %rdx
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d1c
pushq $0x18
popq %rdi
callq 0x2240
movq %rax, %r14
movq %rax, %rdi
callq 0x3b0e
movq %r14, 0x38(%rbx)
andq $0x0, 0x40(%rbx)
movb $0x1, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xc(%rsp)
callq 0x3b1c
testb %al, %al
jne 0x5fbd
pushq $0x18
popq %rdi
callq 0x2240
movq %rax, %r15
movq %rax, %rdi
callq 0x3b0e
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x611c
movq %r15, (%rax)
leaq 0x48(%rbx), %rdi
movq %r12, %rsi
callq 0x601e
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x611c
movq (%rax), %rdi
movq (%r14), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movl %ebp, %edx
callq 0x3d6c
movq 0x38(%rbx), %rdi
movq (%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x20
popq %rdx
callq 0x3d6c
movb $0x1, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2532
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 0x20d0
movq %r14, 0x8(%rbx)
movb %r15b, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
andq $0x0, 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)
andq $0x0, 0x78(%rax)
movups %xmm0, 0x68(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x21c0
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x21c0
leaq -0x1d8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
pushq $0x1
popq %rcx
callq 0x2620
leaq -0x38(%rbp), %rdi
callq 0x2090
leaq -0x58(%rbp), %rdi
callq 0x2090
leaq -0x1d8(%rbp), %rdi
callq 0x25ac
leaq -0x78(%rbp), %rdi
callq 0x2090
leaq -0x98(%rbp), %rdi
callq 0x2090
xorl %eax, %eax
jmp 0x2550
movq 0x5ab7(%rip), %rdi      # 0x7ff0
leaq 0x2ac4(%rip), %rsi      # 0x5004
callq 0x2120
movq %rax, %rdi
callq 0x20a0
pushq $0x1
popq %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2090
jmp 0x256f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2090
jmp 0x257d
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x25ac
leaq -0x78(%rbp), %rdi
callq 0x2090
jmp 0x2597
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ad4
testl %eax, %eax
js 0x2f6b
leaq 0x80(%r14), %rdi
movq 0x98(%r14), %rsi
shlq $0x5, %rsi
leaq -0x12(%rbp), %rdx
movb $0x0, (%rdx)
callq 0x31dc
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
je 0x2f92
movq 0x508e(%rip), %rdi      # 0x7ff0
leaq 0x2481(%rip), %rsi      # 0x53ea
jmp 0x2f79
movq 0x507e(%rip), %rdi      # 0x7ff0
leaq 0x2446(%rip), %rsi      # 0x53bf
callq 0x2120
movq %rax, %rdi
callq 0x20a0
pushq $-0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x11(%rbp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rcx
xorl %eax, %eax
testb $0x2, 0x20(%rbx,%rcx)
jne 0x2f89
movq 0x5038(%rip), %rdi      # 0x7ff0
leaq 0x2446(%rip), %rsi      # 0x5405
callq 0x2120
movq %rax, %rdi
callq 0x20a0
pushq $-0x4
jmp 0x2f88
// File: /workspace/github_cpp_makefile_star2_O2/adamjanovsky[P]PA193_test_parser_monero/src/block.cpp
// Function: Block::get_miner_tx_hash(std::array<unsigned char, 32ul>&) const
int Block::get_miner_tx_hash(hash::hash_t & miner_tx_hash) const {
    switch (this->miner_tx_version) {
        case 1:
            tools::hash(miner_tx_data.data(), miner_tx_data.size(), &miner_tx_hash[0]);
            return OK;
        case 2: {
            unsigned char to_hash[3 * hash::HASH_SIZE];
            
            // to_hash[0]
            tools::hash(miner_tx_data.data(), miner_tx_data.size(), to_hash);
            
            // to_hash[1]
            unsigned char zero_byte[1] = {0x00};
            tools::hash(zero_byte, 1, to_hash + hash::HASH_SIZE);
            
            // to_hash[2]
            memset(to_hash + 2 * hash::HASH_SIZE, 0, hash::HASH_SIZE);
            
            tools::hash(to_hash, 3 * hash::HASH_SIZE, &miner_tx_hash[0]);
            return OK;
        }
        default:
            return ERR_BL_HASH_TRANS_WRONG_VERSION;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movl 0x78(%rdi), %eax
cmpl $0x2, %eax
je 0x2ffd
cmpl $0x1, %eax
jne 0x304c
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
jmp 0x3040
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rsi
subq %rax, %rsi
leaq -0x80(%rbp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x3cf9
leaq -0x19(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x60(%rbp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdx
callq 0x3cf9
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
pushq $0x60
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3cf9
xorl %eax, %eax
jmp 0x304f
pushq $-0x2
popq %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdx
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x3955
movq 0x46ae(%rip), %rdi      # 0x7ff0
leaq 0x1ba9(%rip), %rsi      # 0x54f2
callq 0x2120
pushq $-0x2
jmp 0x3a06
xorl %r14d, %r14d
cmpb %bl, -0x11(%rbp)
je 0x3a10
movq 0x4688(%rip), %r14      # 0x7ff0
leaq 0x1baa(%rip), %rsi      # 0x5519
movq %r14, %rdi
callq 0x2120
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movsbl -0x11(%rbp), %esi
movq %rax, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r14,%rax)
leaq 0x1b77(%rip), %rsi      # 0x552d
movq %r14, %rdi
callq 0x2120
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x18(%r14,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r14,%rax)
movsbl %bl, %esi
movq %r14, %rdi
callq 0x2170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x16c9(%rip), %rsi      # 0x50c5
movq %rax, %rdi
callq 0x2120
pushq $-0x1
popq %r14
movq %rax, %rdi
callq 0x20a0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rdx
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x3a67
movq 0x45a2(%rip), %rdi      # 0x7ff0
leaq 0x1a9d(%rip), %rsi      # 0x54f2
callq 0x2120
movq %rax, %rdi
callq 0x20a0
pushq $-0x2
popq %rax
jmp 0x3a71
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_O2/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
leaq -0x19(%rbp), %r15
cmpq $0x80, %r14
jb 0x3ab8
movl %r14d, %eax
andb $0x7f, %al
movb %al, -0x1a(%rbp)
movl %r14d, %eax
orb $-0x80, %al
movb %al, -0x19(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f0e
shrq $0x7, %r14
jmp 0x3a8e
leaq -0x1a(%rbp), %rsi
movb %r14b, (%rsi)
movq %rbx, %rdi
callq 0x3ece
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::read_varint(std::istream&, unsigned long&)
int tools::read_varint(std::istream & in, unsigned long & val) {
    
    // We will load the varint into a vector and then deserialize it
    std::vector<unsigned char> ser_vect;
    unsigned char c;
    
    // 10 bytes is maximum for the varint to fit in 64 bit int
    // and the last serialized val must be 0x01 so that the int does not overflow
    // because each byte contains 7 bits and 9 * 7 + 1 = 63 + 1 = 64
    for (int i = 0; i < 10; i++) {
        in.read((char *)&c, 1);
        
        // Check for overflow
        if (i == 9 and c != 0x01) {
            std::cerr << "Read varint: Varint overflow." << std::endl;
            return ERR_READV_OVERFLOW;
        }
        
        // Check for EOF
        if (!in.good()) {
            std::cerr << "Read varint: Unexpected end of stream." << std::endl;
            return ERR_READV_UNEXPECTED_EOF;
        }
        
        // Strip the first bit and save it into the vector
        ser_vect.push_back(c & 0x7f);
        
        if ((c & 0x80) == 0x00) {
            // we have read the last byte
            break;
        }

    }
    
    val = 0;
    int last_index = static_cast<int>(ser_vect.size()) - 1;
    
    for (int i = last_index; i >= 0; i--) {
        val <<= 7;
        val |= ser_vect.at(i);
    }
    
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
pushq $0xa
popq %r13
movl %r13d, %r12d
subl $0x1, %r12d
jb 0x3b56
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x2190
cmpl $0x1, %r13d
sete %cl
movb -0x29(%rbp), %al
cmpb $0x1, %al
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
je 0x3b8f
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%r14,%rcx)
jne 0x3bae
andb $0x7f, %al
movb %al, -0x2a(%rbp)
movq %r15, %rdi
leaq -0x2a(%rbp), %rsi
callq 0x3f0e
cmpb $0x0, -0x29(%rbp)
movl %r12d, %r13d
js 0x3b02
andq $0x0, (%rbx)
leaq -0x50(%rbp), %r15
movl 0x8(%r15), %r12d
subl (%r15), %r12d
xorl %r14d, %r14d
xorl %eax, %eax
testl %r12d, %r12d
jle 0x3bcd
decq %r12
shlq $0x7, %rax
movq %rax, (%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ef0
movzbl (%rax), %eax
orq (%rbx), %rax
movq %rax, (%rbx)
jmp 0x3b6a
movq 0x445a(%rip), %rdi      # 0x7ff0
leaq 0x19b0(%rip), %rsi      # 0x554d
callq 0x2120
movq %rax, %rdi
callq 0x20a0
pushq $-0x1
jmp 0x3bcb
movq 0x443b(%rip), %rdi      # 0x7ff0
leaq 0x19af(%rip), %rsi      # 0x556b
callq 0x2120
movq %rax, %rdi
callq 0x20a0
pushq $-0x2
popq %r14
leaq -0x50(%rbp), %rdi
callq 0x260a
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bee
jmp 0x3bee
jmp 0x3bee
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x260a
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x29(%rbp), %r12
pushq $0x1
popq %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x2190
pushq $0x1
popq %r15
leaq 0x1961(%rip), %rbx      # 0x5592
cmpb $0x0, -0x29(%rbp)
jns 0x3c5f
cmpl $0xa, %r15d
ja 0x3c5f
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x3c72
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2190
incl %r15d
jmp 0x3c31
cmpl $0xb, %r15d
jb 0x3c8d
pushq $-0x2
popq %r15
leaq 0x1949(%rip), %rbx      # 0x55b9
jmp 0x3c76
pushq $-0x1
popq %r15
movq 0x4373(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
callq 0x2120
movq %rax, %rdi
callq 0x20a0
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamjanovsky[P]PA193_test_parser_monero/src/tools.cpp
// Function: tools::skip_bytes(std::istream&, unsigned int)
int tools::skip_bytes(std::istream & in, unsigned int length) {
    if (length == 0) {
        std::cerr << "Skip bytes: Invalid length." << std::endl;
        return ERR_SKIPB_INVALID_LENGTH;
    }
    
    in.seekg(length, std::ios_base::cur);
    if (!in.good()) {
        std::cerr << "Skip bytes: Unexpected end of stream." << std::endl;
        return ERR_SKIPB_UNEXPECTED_EOF;
    }
    return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
je 0x3cd4
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %esi
pushq $0x1
popq %rdx
callq 0x21b0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x3cf2
pushq $-0x1
popq %rbx
leaq 0x1921(%rip), %rsi      # 0x55f3
jmp 0x3cde
pushq $-0x2
popq %rbx
leaq 0x18f9(%rip), %rsi      # 0x55d7
movq 0x430b(%rip), %rdi      # 0x7ff0
callq 0x2120
movq %rax, %rdi
callq 0x20a0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: load64
static UINT64 load64(const UINT8 *x)
{
    int i;
    UINT64 u=0;
    
    for(i=7; i>=0; --i) {
        u <<= 8;
        u |= x[i];
    }
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x7, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x4510
shlq $0x8, %rax
movl %ecx, %edx
movzbl (%rdi,%rdx), %edx
orq %rdx, %rax
decl %ecx
jmp 0x44fb
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: xor64
static void xor64(UINT8 *x, UINT64 u)
{
    unsigned int i;
    
    for(i=0; i<8; ++i) {
        x[i] ^= u;
        u >>= 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpq $0x8, %rax
je 0x452b
xorb %sil, (%rdi,%rax)
shrq $0x8, %rsi
incq %rax
jmp 0x4518
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/adamjanovsky[P]PA193_test_parser_monero/src/keccak/Keccak-readable-and-compact.c
// Function: store64
static void store64(UINT8 *x, UINT64 u)
{
    unsigned int i;
    
    for(i=0; i<8; ++i) {
        x[i] = u;
        u >>= 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpq $0x8, %rax
je 0x4546
movb %sil, (%rdi,%rax)
shrq $0x8, %rsi
incq %rax
jmp 0x4533
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/analyzeBasic.cc
// Function: AnalyzeBasic::generateHash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void AnalyzeBasic::generateHash(string refName, unsigned int seedLength) {
	refDB.loadRefFile(refName);

	this->seedLength = seedLength;

	string seed = string(seedLength, 'N');
	
	freqTable.resize( (1 << (2 * seedLength) ), 0);

	for (unsigned int chromoCount = 0; chromoCount < refDB.getNumOfChromo(); chromoCount++) {
		refDB.loadChromo(chromoCount);
		for (unsigned int refPos = 0; refPos < refDB.getChromoLength() - seedLength; refPos++) {
			seed = refDB.getRefSeq(refPos, seedLength);
			if (seed.find('N') == string::npos && seed.find('M') == string::npos && seed.find('R') == string::npos) {
				unsigned int hash = hashGen.calculateHash(seed, seed.length() );
				freqTable[hash]++;
			}
		}
	}	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x22e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x38f4
leaq 0x38(%rsp), %rdi
callq 0x2100
movl %ebx, 0x270(%r14)
movl %ebx, %esi
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x18(%rsp), %rdi
pushq $0x4e
popq %rdx
callq 0x2260
leaq 0x278(%r14), %rdi
leal (%rbx,%rbx), %ecx
pushq $0x1
popq %rsi
shll %cl, %esi
leaq 0x58(%rsp), %rdx
andl $0x0, (%rdx)
movq %rdi, 0x8(%rsp)
callq 0x3588
leaq 0x268(%r14), %rax
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
leaq 0x58(%rsp), %rbp
leaq 0x18(%rsp), %r15
pushq $0x4e
popq %r12
movq %r14, %rdi
callq 0x3d02
movq (%rsp), %rsi
cmpl %eax, %esi
jae 0x336e
movq %r14, %rdi
callq 0x3b68
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x3cfa
subl %ebx, %eax
cmpl %eax, %r13d
jae 0x335f
movq %rbp, %rdi
movq %r14, %rsi
movl %r13d, %edx
movl %ebx, %ecx
callq 0x3d2c
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2280
movq %rbp, %rdi
callq 0x2100
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x22b0
cmpq $-0x1, %rax
jne 0x3357
movq %r15, %rdi
pushq $0x4d
popq %rsi
xorl %edx, %edx
callq 0x22b0
cmpq $-0x1, %rax
jne 0x3357
movq %r15, %rdi
pushq $0x52
popq %rsi
xorl %edx, %edx
callq 0x22b0
cmpq $-0x1, %rax
jne 0x3357
movl 0x20(%rsp), %edx
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4156
movl %eax, %eax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
incl (%rcx,%rax,4)
incl %r13d
jmp 0x32ca
movq (%rsp), %rax
incl %eax
movq %rax, (%rsp)
jmp 0x32ab
leaq 0x18(%rsp), %rdi
callq 0x2100
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x339e
movq %rax, %rbx
jmp 0x33ab
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x33a6
jmp 0x339e
jmp 0x339e
jmp 0x339e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x23a0
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2030
movl 0x270(%rbx), %esi
movq %rsp, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x2110
xorl %r15d, %r15d
movq %rsp, %r14
movq 0x278(%rbx), %rax
movq 0x280(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x342e
movl (%rax,%r15,4), %esi
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x2110
incq %r15
jmp 0x33fb
movq %rsp, %rdi
callq 0x22f0
movq %rsp, %rdi
callq 0x2310
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
jmp 0x344d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2310
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2250
movq (%r14), %rsi
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x2150
leaq 0x270(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x23d0
leaq 0x278(%rbx), %rdi
movb 0x270(%rbx), %cl
addb %cl, %cl
pushq $0x1
popq %rsi
shll %cl, %esi
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
callq 0x3588
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
xorl %r12d, %r12d
movq 0x278(%rbx), %rsi
movq 0x280(%rbx), %rax
subq %rsi, %rax
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x34fa
addq %r15, %rsi
movq %r14, %rdi
callq 0x23d0
incq %r12
addq $0x4, %r15
jmp 0x34cc
leaq 0x10(%rsp), %rdi
callq 0x2080
leaq 0x10(%rsp), %rdi
callq 0x20b0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3521
jmp 0x3521
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x23e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
movl 0x8(%rdx), %r13d
decq %r13
leaq -0x2c(%rbp), %r12
testl %r13d, %r13d
js 0x35b8
movl %r13d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq (%r14), %rcx
movzbl (%rcx,%rax), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x35dc
addl $-0x30, %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a04
decq %r13
jmp 0x3586
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3a2a
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
callq 0x3630
leaq -0x68(%rbp), %rdi
callq 0x3b58
jmp 0x35ef
leaq 0xc87(%rip), %rsi       # 0x426a
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
callq 0x31ac
leaq -0x50(%rbp), %rdi
callq 0x3b58
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x361c
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3b58
jmp 0x361f
jmp 0x361c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3b58
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 (%rdi), %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x3d48
movsbl (%r14,%r12), %edi
callq 0x2180
movb %al, (%r14,%r12)
incq %r12
jmp 0x3d30
leaq 0x344(%rip), %rsi       # 0x4093
movq %rbx, %rdi
callq 0x3dd7
testb %al, %al
je 0x3d73
pushq $0x8
popq %rdi
callq 0x2140
leaq 0x2ff6(%rip), %rcx      # 0x6d60
addq $0x10, %rcx
movq %rcx, (%rax)
jmp 0x3daa
movq 0x325e(%rip), %rdi      # 0x6fd8
leaq 0x517(%rip), %rsi       # 0x4298
callq 0x2130
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
leaq 0x510(%rip), %rsi       # 0x42a8
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tewalds[P]morat/hex/../lib/gtpbase.h
// Function: Morat::GTPBase::cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
GTPResponse cmd(std::string line){
		vecstr parts = explode(line, " ");
		std::string id;

		if(parts.size() > 1 && atoi(parts[0].c_str())){
			id = parts[0];
			parts.erase(parts.begin());
		}

		std::string name = parts[0];
		parts.erase(parts.begin());

		int cb = find_callback(name);
		GTPResponse response;

		if(cb < 0){
			response = GTPResponse(false, "Unknown command");
		}else{
			response = callbacks[cb].func(parts);
		}

		response.id = id;

		return response;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ec88(%rip), %rsi     # 0x26943
leaq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5110
leaq 0x10(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x21006
leaq 0xa0(%rsp), %rdi
callq 0x5150
leaq 0x38(%rsp), %rax
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rcx
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
subq %r15, %rcx
cmpq $0x21, %rcx
jb 0x7d40
movq (%r15), %rdi
callq 0x5550
testl %eax, %eax
je 0x7d40
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x5190
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
callq 0xa08e
movq 0x10(%rsp), %r15
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x5490
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
callq 0xa08e
leaq 0x80(%rsp), %rsi
movq %r14, %rdi
callq 0xa094
movl %eax, %ebp
leaq 0x18(%rbx), %rax
leaq 0x38(%rbx), %rcx
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
movb %al, 0x18(%rbx)
movq %rcx, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
movb %al, 0x38(%rbx)
testl %ebp, %ebp
js 0x7dec
movq 0x10(%r14), %r14
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xa134
movl %ebp, %eax
imulq $0x60, %rax, %rax
leaq 0x40(%r14,%rax), %rsi
leaq 0xa0(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xa11c
leaq 0xa0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa0e6
movq %r14, %rdi
callq 0x7ef6
leaq 0x48(%rsp), %rdi
callq 0x8e84
jmp 0x7e3b
leaq 0x1aad8(%rip), %rsi     # 0x228cb
leaq 0x60(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x5110
leaq 0xa0(%rsp), %rdi
leaq 0x60(%rsp), %rdx
xorl %esi, %esi
callq 0x8d00
leaq 0xa0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa0e6
movq %r14, %rdi
callq 0x7ef6
leaq 0x60(%rsp), %rdi
callq 0x5150
leaq 0x8(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5190
leaq 0x80(%rsp), %rdi
callq 0x5150
leaq 0x28(%rsp), %rdi
callq 0x5150
leaq 0x10(%rsp), %rdi
callq 0x8e84
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7ec0
jmp 0x7ec0
leaq 0x60(%rsp), %rdi
movq %rax, %r14
callq 0x5150
jmp 0x7ea4
jmp 0x7ea1
leaq 0x48(%rsp), %rdi
movq %rax, %r14
callq 0x8e84
jmp 0x7ea4
jmp 0x7ea1
movq %rax, %r14
movq %rbx, %rdi
callq 0x7ef6
jmp 0x7eb1
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x5150
jmp 0x7ec3
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5150
leaq 0x10(%rsp), %rdi
callq 0x8e84
movq %r14, %rdi
callq 0x5650
leaq 0xa0(%rsp), %rdi
movq %rax, %r14
callq 0x5150
jmp 0x7ed7
movq %rax, %r14
jmp 0x7ed7