LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x53e5
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 0x7402
movq (%rax), %r12
testq %r12, %r12
je 0x53d1
movq (%r12), %r13
testq %r13, %r13
je 0x53c4
movq -0x8(%r13), %r15
testq %r15, %r15
je 0x53a1
imulq $0x38, %r15, %rbx
leaq -0x38(%r13), %rbp
leaq (%rbx,%rbp), %rdi
callq 0x6422
addq $-0x38, %rbx
jne 0x5392
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 0x535d
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x5439
movq (%r14), %r12
testq %r12, %r12
je 0x542c
leaq -0x8(%r12), %r15
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x541c
imulq $0x38, %r13, %rbp
addq $-0x38, %r12
leaq (%r12,%rbp), %rdi
callq 0x6422
addq $-0x38, %rbp
jne 0x540d
imulq $0x38, %r13, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x2390
movl $0x18, %esi
movq %r14, %rdi
callq 0x2240
leaq 0x48(%rbx), %rdi
callq 0x704e
movq %rbx, %rdi
callq 0x70b2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x5ff3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3cbf(%rip), %rsi      # 0x933d
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x3c77(%rip), %rsi      # 0x9309
movl $0x5, %edx
movq %r14, %rdi
callq 0x2280
movl 0xc(%r15), %esi
movq %r14, %rdi
callq 0x2340
leaq 0x3c7f(%rip), %rsi      # 0x9331
movl $0x2, %edx
movq %rax, %rdi
callq 0x2280
leaq 0x3c49(%rip), %rsi      # 0x930f
movl $0xa, %edx
movq %r14, %rdi
callq 0x2280
movl (%r15), %eax
leaq 0x28(%rsp), %rsi
movl %eax, (%rsi)
movl 0x4(%r15), %eax
movl %eax, 0x4(%rsi)
movq %r14, %rdi
callq 0x2598
leaq 0x3941(%rip), %rsi      # 0x9034
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
movl 0x8(%r15), %esi
movq %r14, %rdi
callq 0x2340
leaq 0x3c1d(%rip), %rsi      # 0x9330
movl $0x3, %edx
movq %rax, %rdi
callq 0x2280
leaq 0x3bf3(%rip), %rsi      # 0x931a
movl $0x7, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x3bdd(%rip), %rsi      # 0x9318
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 0x7372
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2280
leaq 0x3b98(%rip), %rsi      # 0x9318
movl $0x1, %edx
movq %rax, %rdi
callq 0x2280
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x57a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2240
leaq 0x3893(%rip), %rsi      # 0x903e
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2300
movq 0x77e4(%rip), %rsi      # 0xcfb0
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 0x5813
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5816
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2240
jmp 0x5816
movq %rax, %rbx
movq 0x7793(%rip), %rsi      # 0xcfb0
leaq 0x30(%rsp), %rdi
callq 0x21b0
leaq 0xb0(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37d8(%rip), %rsi      # 0x9043
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
cmpl $0x0, 0x14(%r15)
jle 0x5916
xorl %ebp, %ebp
leaq 0x3a8c(%rip), %r12      # 0x9318
xorl %r13d, %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2280
movq (%r15), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x4bd1
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3763(%rip), %rsi      # 0x9022
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
decl %eax
cmpq %rax, %r13
je 0x5902
movl $0x2, %edx
movq %r14, %rdi
leaq 0x3a34(%rip), %rsi      # 0x9331
callq 0x2280
incq %r13
movslq 0x14(%r15), %rax
addq $0x38, %rbp
cmpq %rax, %r13
jl 0x588f
leaq 0x394e(%rip), %rsi      # 0x926b
movl $0x1, %edx
movq %r14, %rdi
callq 0x2280
leaq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x2300
movq 0x7670(%rip), %rsi      # 0xcfb0
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 0x5970
movq %rax, %rbx
movq 0x7636(%rip), %rsi      # 0xcfb0
leaq 0x10(%rsp), %rdi
callq 0x21b0
leaq 0x90(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6323
movq $0x0, (%r14)
movl $0x0, 0x14(%r14)
movl %ebx, 0x10(%r14)
jmp 0x63f8
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), %rdx
movq %r15, (%rax)
incl %r13d
je 0x639d
leaq 0x10(%rax), %rcx
imulq $0x38, %r15, %rsi
xorl %edi, %edi
movl $0x0, (%rcx)
movq %rdi, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rdi, 0x20(%rcx)
movl $0x1, 0x28(%rcx)
addq $0x38, %rcx
addq $-0x38, %rsi
jne 0x6376
movq %rdx, (%r14)
cmpl %r12d, %ebx
jl 0x63f8
movq %r12, %rcx
negq %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rdx
incl %ebx
movl $0x20, %ecx
subl %r12d, %ecx
addq $0x38, %rax
testq %r12, %r12
je 0x63d7
cmpq $0x0, -0x8(%rax)
jne 0x6402
movl $0x1, %esi
shll %cl, %esi
movl %esi, (%rax)
jmp 0x63e5
cmpq $0x0, 0x28(%rdx)
jne 0x6402
movl $0x1, 0x30(%rdx)
incq %r12
addq $0x38, %rax
leal (%rbx,%rcx), %esi
decl %esi
decl %ecx
cmpl $0x20, %esi
jne 0x63c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2db6(%rip), %rdi      # 0x91bf
leaq 0x2c70(%rip), %rsi      # 0x9080
leaq 0x2db2(%rip), %rcx      # 0x91c9
movl $0x96, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fe8
movl $0x18, %edi
callq 0x2230
movq %rax, %r14
movq $0x0, 0x8(%rax)
movq %rax, %rdi
movl $0x20, %esi
callq 0x62f4
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_O1/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)
movslq %esi, %rax
movq (%rdi), %rdi
movq 0x8(%rbx), %r8
xorl %r10d, %r10d
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x71a6
movq (%rax), %r9
movq %rax, %r10
cmpl %esi, 0x8(%r9)
je 0x71a6
movq %rdx, %rcx
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x71a3
movslq 0x8(%r9), %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rcx, %rdx
jne 0x71a6
movq %r11, %r10
cmpl %esi, %edi
jne 0x7178
jmp 0x71a6
xorl %r10d, %r10d
testq %r10, %r10
je 0x71b1
cmpq $0x0, (%r10)
jne 0x71f2
movl $0x18, %edi
callq 0x2230
movq %rax, %r15
movq $0x0, 0x8(%rax)
movq %rax, %rdi
movl $0x20, %esi
callq 0x62f4
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7402
movq %r15, (%rax)
leaq 0x48(%rbx), %rdi
movq %r12, %rsi
callq 0x7262
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x7402
movq (%rax), %rdi
movl (%r14), %eax
leaq 0x18(%rsp), %rsi
movl %eax, (%rsi)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rsi)
movl %ebp, %edx
callq 0x4fb8
movq 0x38(%rbx), %rdi
movl (%r14), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl 0x4(%r14), %eax
movl %eax, 0x4(%rsi)
movl $0x20, %edx
callq 0x4fb8
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x256e
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)
movq %r15, 0x10(%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)
movb %r15b, 0xa0(%rbx)
leaq -0x120(%rbp), %rax
movq %rax, -0x10(%rax)
movq %r15, -0x8(%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 0x26c8
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x26c8
leaq -0x1d8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0x2764
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2529
callq 0x2110
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x2537
callq 0x2110
leaq -0x1d8(%rbp), %rdi
callq 0x262c
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2555
callq 0x2110
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x256a
callq 0x2110
xorl %eax, %eax
jmp 0x25b5
movq 0x5a7b(%rip), %rbx      # 0x7ff0
leaq 0x2a88(%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 0x25d9
callq 0x2110
jmp 0x25d9
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x25ec
callq 0x2110
jmp 0x25ec
movq %rax, %rbx
leaq -0x1d8(%rbp), %rdi
callq 0x262c
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x260f
callq 0x2110
jmp 0x260f
movq %rax, %rbx
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2624
callq 0x2110
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/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 0x41ba
testl %eax, %eax
js 0x3484
leaq 0x80(%r14), %rdi
movq 0x98(%r14), %rsi
shlq $0x5, %rsi
leaq -0x12(%rbp), %rdx
movb $0x0, (%rdx)
callq 0x37b0
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 0x34d4
movq 0x4b7a(%rip), %rbx      # 0x7ff0
leaq 0x1fb8(%rip), %rsi      # 0x5435
movl $0x1a, %edx
jmp 0x3497
movq 0x4b65(%rip), %rbx      # 0x7ff0
leaq 0x1f78(%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 0x34cb
movq 0x4af4(%rip), %rbx      # 0x7ff0
leaq 0x1f4d(%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 0x34cb
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
cmpl $0x2, %ecx
je 0x3570
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x1, %ecx
jne 0x35c1
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
jmp 0x35b7
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rsi
subq %rax, %rsi
leaq -0x80(%rbp), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x4523
leaq -0x19(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x60(%rbp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x4523
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movl $0x60, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4523
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f93
movq 0x407c(%rip), %rbx      # 0x7ff0
leaq 0x15c2(%rip), %rsi      # 0x553d
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2160
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x406e
xorl %r14d, %r14d
cmpb %bl, -0x11(%rbp)
je 0x4095
movq 0x404a(%rip), %r14      # 0x7ff0
leaq 0x15b7(%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 0x1573(%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 0x1094(%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_O1/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 0x4117
movq 0x3f1b(%rip), %rbx      # 0x7ff0
leaq 0x1461(%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 0x4121
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_O1/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 0x4189
leaq -0x1a(%rbp), %r15
movl %r14d, %eax
andb $0x7f, %al
movb %al, -0x19(%rbp)
movl %r14d, %eax
orb $-0x80, %al
movb %al, -0x1a(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4169
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x4174
movq %rbx, %rdi
movq %r15, %rdx
callq 0x47ac
movq %r14, %rax
shrq $0x7, %rax
cmpq $0x3fff, %r14           # imm = 0x3FFF
movq %rax, %r14
ja 0x4147
jmp 0x418c
movq %r14, %rax
movb %al, -0x19(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x41a1
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x41ad
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x3e4c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x21(%rbp), %r15
movl $0x1, %edx
movq %r15, %rsi
callq 0x2180
movl $0x1, %ebx
cmpb $0x0, (%r15)
js 0x43f2
cmpl $0xb, %ebx
jb 0x4478
movq 0x3c16(%rip), %rdi      # 0x7ff0
leaq 0x1223(%rip), %rsi      # 0x5604
movl $0x1d, %edx
callq 0x2160
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x444a
movl $0x1, %r12d
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x442d
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
leal 0x1(%r12), %ebx
cmpb $0x0, -0x21(%rbp)
jns 0x43ca
cmpl $0xa, %r12d
movl %ebx, %r12d
jb 0x43f8
jmp 0x43ca
movq 0x3bbc(%rip), %rdi      # 0x7ff0
leaq 0x11a2(%rip), %rsi      # 0x55dd
movl $0x26, %edx
callq 0x2160
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x3b9f(%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
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44d1
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %esi
movl $0x1, %edx
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
je 0x451c
movq 0x3b37(%rip), %rdi      # 0x7ff0
leaq 0x117e(%rip), %rsi      # 0x563e
movl $0x25, %edx
callq 0x2160
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x44ee
movq 0x3b18(%rip), %rdi      # 0x7ff0
leaq 0x1143(%rip), %rsi      # 0x5622
movl $0x1b, %edx
callq 0x2160
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movq 0x3afb(%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
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49f8
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 0x49a5
leaq 0x8(%rsp), %rdi
callq 0x3330
movq 0x45b7(%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 0x4a45
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b9a
movq 0x278(%rbx), %rsi
cmpq %rsi, 0x280(%rbx)
je 0x4b09
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 0x4add
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 0x4b30
jmp 0x4b30
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movb (%rax,%r13), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x401c
movsbl (%rax,%r13), %eax
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 0x46f8
testl %r13d, %r13d
jg 0x3fa9
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x45e6
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 0x11fc(%rip), %rsi      # 0x5226
leaq 0x1202(%rip), %rdx      # 0x5233
movq %rbx, %rdi
callq 0x3c56
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 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/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 0x486b
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x2170
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x4855
leaq 0x821(%rip), %rsi       # 0x5093
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x48ea
movq 0x2753(%rip), %r14      # 0x6fd8
leaq 0x9c8(%rip), %rsi       # 0x5254
movl $0xf, %edx
movq %r14, %rdi
callq 0x2150
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2150
movq %rax, %rbx
leaq 0x9b2(%rip), %rsi       # 0x5264
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 0x4902
movl $0x8, %edi
callq 0x2130
leaq 0x245d(%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_O1/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
movq %rdi, %rbx
movb $0x1, 0x2c(%rdi)
leaq 0x18(%rsp), %rbp
leaq 0x58(%rsp), %r13
leaq 0xb0(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x48(%rsp), %r12
movq (%rbx), %rdx
movq %r14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x5580
testq %rax, %rax
je 0x97b1
movq %rbp, 0x8(%rsp)
movq %r14, %rdi
callq 0x5140
leaq 0xb0(%rsp,%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xb0e0
movq %r15, %rdi
callq 0x2f956
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x9798
movq 0x8(%rsp), %rsi
cmpb $0x23, (%rsi)
je 0x9798
movq %r13, 0x48(%rsp)
addq %rsi, %rdx
movq %r12, %rdi
callq 0xa866
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x92fc
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x971c
callq 0x52e0
cmpq $0x0, 0x8(%rbx)
je 0x9767
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xbcc0
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 0x9767
callq 0x52e0
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x9781
callq 0x52e0
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x9798
callq 0x52e0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x97a7
callq 0x52e0
cmpb $0x0, 0x2c(%rbx)
jne 0x9690
movb 0x2c(%rbx), %al
addq $0x4a8, %rsp            # imm = 0x4A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x9630
jmp 0x97ee
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x97ee
callq 0x52e0
jmp 0x97ee
jmp 0x97eb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x97fd
callq 0x52e0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/gtpbase.h
// Function: Morat::GTPBase::gtp_list_commands(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, bool)
GTPResponse gtp_list_commands(vecstr args, bool showdesc){
		std::string ret = "\n";
		for(unsigned int i = 0; i < callbacks.size(); i++){
			ret += callbacks[i].name;
			if(showdesc && callbacks[i].desc.length() > 0){
				ret += std::string(longest_cmd + 2 - callbacks[i].name.length(), ' ');
				ret += callbacks[i].desc;
			}
			ret += "\n";
		}
		return GTPResponse(true, ret);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x273d6(%rip), %rsi     # 0x31906
leaq 0x273d0(%rip), %rdx     # 0x31907
leaq 0x20(%rsp), %rdi
callq 0xb0e0
movq 0x10(%r14), %rax
cmpq %rax, 0x18(%r14)
je 0xa622
movl $0x1, %r12d
xorl %ecx, %ecx
leaq 0x20(%rsp), %r15
leaq 0x273a3(%rip), %r13     # 0x31906
leaq (%rcx,%rcx,2), %rbx
shlq $0x5, %rbx
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
movq %r15, %rdi
callq 0x50c0
testb %bpl, %bpl
je 0xa5eb
movq 0x10(%r14), %rax
cmpq $0x0, 0x28(%rax,%rbx)
je 0xa5eb
addq %rbx, %rax
movl 0x28(%r14), %esi
addl $0x2, %esi
subq 0x8(%rax), %rsi
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rsp, %rdi
movl $0x20, %edx
callq 0x53b0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x50c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xa5d5
callq 0x52e0
movq 0x10(%r14), %rax
movq 0x20(%rax,%rbx), %rsi
movq 0x28(%rax,%rbx), %rdx
movq %r15, %rdi
callq 0x50c0
movq %r15, %rdi
movq %r13, %rsi
callq 0x56e0
movl %r12d, %ecx
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
incl %r12d
cmpq %rcx, %rdx
ja 0xa563
leaq 0x58(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xa866
leaq 0x48(%rsp), %rdx
movq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
callq 0xa7f0
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0xa668
callq 0x52e0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xa67c
callq 0x52e0
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
jne 0xa6b0
jmp 0xa6bc
jmp 0xa6b9
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xa6bc
callq 0x52e0
jmp 0xa6bc
jmp 0xa6b9
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xa6d0
callq 0x52e0
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_ = from_str<int>(s);
		sizem1_ = size_ - 1;
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size();
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xaed9
movl %eax, %ebp
addl $-0x3, %ebp
cmpl $0x16, %ebp
ja 0xaeca
movq %r14, %rdi
callq 0xaed9
movb %al, (%rbx)
decb %al
movb %al, 0x1(%rbx)
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2025e
vmovaps (%r14), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vmovaps %xmm1, (%r14)
movq 0x40(%rbx), %rdi
vmovups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0xaea0
callq 0xb170
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaeaf
callq 0xb170
movsbl (%rbx), %esi
imull %esi, %esi
movw %si, 0x2(%rbx)
leaq 0x10(%rbx), %rdi
callq 0xaf5a
movq %rbx, %rdi
callq 0xaf8e
cmpl $0x17, %ebp
setb %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/string.h
// Function: int Morat::from_str<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T from_str(const std::string & str){
	std::istringstream sin(str);
	T ret;
	sin >> ret;
	return ret;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x5600
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x51b0
movl 0xc(%rsp), %ebx
movq 0x3f0b2(%rip), %rsi     # 0x49fc0
leaq 0x10(%rsp), %rdi
callq 0x5490
leaq 0x88(%rsp), %rdi
callq 0x50d0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x3f086(%rip), %rsi     # 0x49fc0
leaq 0x10(%rsp), %rdi
callq 0x5490
leaq 0x88(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/board.h
// Function: Morat::Hex::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, pos.xy, 1, edges(x, y), init_pattern(pos));
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x78fd0000, 0x4(%rdi)  # imm = 0x78FD0000
leaq 0x2b403(%rip), %rax     # 0x363aa
movb (%rax), %al
movb %al, 0x8(%rdi)
leaq 0x2b3fb(%rip), %rax     # 0x363ae
movb (%rax), %al
movb %al, 0x9(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x28(%rdi)
cmpb $0x0, (%rdi)
jle 0xb0d1
movq %rdi, %r14
xorl %ebx, %ebx
movsbl (%r14), %r12d
testl %r12d, %r12d
jle 0xb0c3
movsbl %bl, %eax
movl %eax, 0x4(%rsp)
xorl %ebp, %ebp
movl %r12d, %eax
imull 0x4(%rsp), %eax
movsbl %bpl, %r13d
addl %eax, %r13d
leaq 0x2b3ae(%rip), %rax     # 0x363a9
movb (%rax), %r15b
leaq 0x2b3a3(%rip), %rax     # 0x363a8
movb (%rax), %al
movb %al, 0x3(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x20230
movl %ebx, %ecx
imull %r12d, %ecx
addl %ebp, %ecx
movswq %cx, %rcx
leaq (%rcx,%rcx,8), %rsi
movswq %r13w, %rcx
shlq $0x3, %rsi
addq 0x38(%r14), %rsi
movl $0x3, %r11d
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpl $0xffff0000, (%rsi,%r8) # imm = 0xFFFF0000
movl $0x0, %r9d
cmovaeq %r11, %r9
orq %r9, %r10
shlq $0x2, %r11
addq $0x4, %r8
cmpq $0x48, %r8
jne 0xb03f
cmpl %r12d, %ebx
movzbl %r15b, %esi
movzbl 0x3(%rsp), %r8d
cmovll %esi, %r8d
movq %r10, %rsi
movl $0x3f03f03f, %r9d       # imm = 0x3F03F03F
andq %r9, %rsi
shlq $0x6, %rsi
shrq $0x6, %r10
andq %r9, %r10
orq %rsi, %r10
movq 0x10(%r14), %rsi
shlq $0x4, %rcx
movb %r8b, (%rsi,%rcx)
movw $0x1, 0x2(%rsi,%rcx)
movw %r13w, 0x4(%rsi,%rcx)
movb %al, 0x6(%rsi,%rcx)
movb $0x0, 0x7(%rsi,%rcx)
movq %r10, 0x8(%rsi,%rcx)
incl %ebp
movsbl (%r14), %r12d
cmpl %r12d, %ebp
jl 0xafe5
incl %ebx
movsbl (%r14), %eax
cmpl %eax, %ebx
jl 0xafcf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/../lib/gtpbase.h
// Function: Morat::GTPBase::find_callback(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int find_callback(const std::string & name){
		for(unsigned int i = 0; i < callbacks.size(); i++)
			if(callbacks[i].name == name)
				return i;
		return -1;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %rax
subq %r15, %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0xbaf6
sarq $0x5, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
movq (%rsi), %r14
movq 0x8(%rsi), %rbp
xorl %r13d, %r13d
leaq (%r13,%r13,2), %rax
shlq $0x5, %rax
movq 0x8(%r15,%rax), %rdx
cmpq %rbp, %rdx
jne 0xbae9
testq %rdx, %rdx
je 0xbaf3
addq %r15, %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x5330
testl %eax, %eax
je 0xbaf3
incl %r13d
cmpq %r13, %r12
ja 0xbabf
jmp 0xbaf6
movl %r13d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::AgentMCTS(Morat::Hex::Board const&)
AgentMCTS::AgentMCTS(const Board & b) : Agent(b), pool(this) {
	nodes = 0;
	runs = 0;
	gclimit = 5;

	profile     = false;
	ponder      = false;
//#ifdef SINGLE_THREAD ... make sure only 1 thread
	numthreads  = 1;
	pool.set_num_threads(numthreads);
	maxmem      = 1000*1024*1024;

	msrave      = -2;
	msexplore   = 0;

	explore     = 0;
	parentexplore = false;
	ravefactor  = 500;
	decrrave    = 0;
	knowledge   = true;
	userave     = 1;
	useexplore  = 1;
	fpurgency   = 1;
	rollouts    = 5;
	dynwiden    = 0;
	logdynwiden = (dynwiden ? std::log(dynwiden) : 0);

	shortrave   = false;
	keeptree    = true;
	minimax     = 2;
	visitexpand = 1;
	gcsolved    = 100000;
	longestloss = false;

	localreply  = 5;
	locality    = 5;
	connect     = 20;
	size        = 0;
	bridge      = 100;
	dists       = 0;

	weightedrandom = false;
	rolloutpattern = true;
	lastgoodreply  = false;
	instantwin     = 0;

	for(int i = 0; i < 4096; i++)
		gammas[i] = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x11f0c
leaq 0x3a97d(%rip), %rax     # 0x49850
movq %rax, (%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x40e0(%rbx)
movw $0x0, 0x4100(%rbx)
leaq 0x274bc(%rip), %rax     # 0x363ae
movb (%rax), %al
movb %al, 0x4102(%rbx)
movl $0xfc78fd00, 0x4103(%rbx) # imm = 0xFC78FD00
movb $0x78, 0x4107(%rbx)
movq $0x0, 0x4108(%rbx)
leaq 0x4130(%rbx), %r14
movq %r14, %rdi
vzeroupper
callq 0x11f78
leaq 0x54f0(%rbx), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1200a
xorl %r15d, %r15d
movq %r15, 0x4110(%rbx)
movq %r15, 0x4120(%rbx)
movl $0x5, 0x4118(%rbx)
movb %r15b, 0x68(%rbx)
movb %r15b, 0x58(%rbx)
movl $0x1, 0x5c(%rbx)
movq %r12, %rdi
movl $0x1, %esi
callq 0x12096
movq $0x3e800000, 0x60(%rbx) # imm = 0x3E800000
vmovss 0x2327b(%rip), %xmm0    # 0x321fc
vmovlps %xmm0, 0x6c(%rbx)
movb %r15b, 0x74(%rbx)
vmovsd 0x232fe(%rip), %xmm0    # 0x32290
vmovsd %xmm0, 0x78(%rbx)
movl %r15d, 0x80(%rbx)
movb $0x1, %al
movb %al, 0x84(%rbx)
vbroadcastss 0x23251(%rip), %xmm0 # 0x32200
vmovlps %xmm0, 0x88(%rbx)
movabsq $0x53f800000, %rcx      # imm = 0x53F800000
movq %rcx, 0x90(%rbx)
movq %r15, 0x98(%rbx)
movw $0x100, 0xa0(%rbx)      # imm = 0x100
movabsq $0x100000002, %rcx      # imm = 0x100000002
movq %rcx, 0xa4(%rbx)
movl $0x186a0, 0xac(%rbx)    # imm = 0x186A0
movb %r15b, 0xb0(%rbx)
vmovaps 0x2329e(%rip), %xmm0    # 0x322a0
vmovups %xmm0, 0xb4(%rbx)
movq $0x64, 0xc4(%rbx)
movl %r15d, 0xcc(%rbx)
movb %al, 0xd0(%rbx)
movq %r15, 0xd4(%rbx)
vbroadcastss 0x231cd(%rip), %zmm0 # 0x32200
vmovups %zmm0, 0xdc(%rbx,%r15,4)
addq $0x10, %r15
cmpq $0x1000, %r15           # imm = 0x1000
jne 0xf033
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
vzeroupper
retq
movq %rax, %r15
movq %r12, %rdi
callq 0x1222e
jmp 0xf06a
movq %rax, %r15
movq %r14, %rdi
callq 0x12270
jmp 0xf077
movq %rax, %r15
leaq 0x40e0(%rbx), %rdi
callq 0x122ba
movq %rbx, %rdi
callq 0x1350c
movq %r15, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/hex/agentmcts.cpp
// Function: Morat::Hex::AgentMCTS::~AgentMCTS()
AgentMCTS::~AgentMCTS(){
	pool.pause();
	pool.set_num_threads(0);

	root.dealloc(ctmem);
	ctmem.compact();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3a7aa(%rip), %rax     # 0x49850
movq %rax, (%rdi)
leaq 0x54f0(%rdi), %r14
movq %r14, %rdi
callq 0x1141a
movq %r14, %rdi
xorl %esi, %esi
callq 0x12096
leaq 0x40e0(%rbx), %r15
leaq 0x4130(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x12312
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
movq %r12, %rdi
callq 0x123b8
movq %r14, %rdi
callq 0x1222e
movq %r12, %rdi
callq 0x12270
movq %r15, %rdi
callq 0x122ba
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1350c
movq %rax, %rdi
callq 0xa7e4