LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/AllTokens.cpp
// Function: All_Tokens::getToken(int)
Token All_Tokens::getToken(int id){
    if (id >= 1 && id <= 7)
        return allTokens.at(id-1).at(getSize(id)-1); 
    else // if the id is invalid, then always return last token
        cout << "getToken: Invalid type of token!" << endl;
    return allTokens.at(6).at(getSize(6)-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leal -0x1(%rdx), %eax
cmpl $0x6, %eax
ja 0x553e
movl %eax, %esi
movq (%r14), %r15
movq 0x8(%r14), %rcx
subq %r15, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rsi, %rax
jbe 0x5611
leaq (%rsi,%rsi,2), %r12
movq %r14, %rdi
movl %edx, %esi
callq 0x5462
decl %eax
movslq %eax, %rsi
movq (%r15,%r12,8), %rax
movq 0x8(%r15,%r12,8), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x5608
leaq (%rsi,%rsi,4), %rcx
leaq (%rax,%rcx,8), %r14
jmp 0x55d9
movq 0x10a8b(%rip), %r15     # 0x15fd0
leaq 0xacc3(%rip), %rsi      # 0x1020f
movl $0x20, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq $0x6, %rdx
jbe 0x561d
movslq 0x2c(%r14), %rsi
decq %rsi
movq 0x90(%rax), %rcx
movq 0x98(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x5608
leaq (%rsi,%rsi,4), %rax
leaq (%rcx,%rax,8), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f2e
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xad49(%rip), %rdi      # 0x10358
jmp 0x5629
leaq 0xad40(%rip), %rdi      # 0x10358
movq %rax, %rdx
jmp 0x5629
leaq 0xad34(%rip), %rdi      # 0x10358
movl $0x6, %esi
xorl %eax, %eax
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::All_Bonus()
int All_Bonus::getSize(int id)
{
  if(id >=3 && id <=5){
    return size[id-3];
  }
  cout<<"getSize: Invalid type of Bonus!"<<endl;
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $0x600000006, %rax      # imm = 0x600000006
movq %rax, 0x18(%rdi)
movq %rdi, 0x8(%rsp)
movl $0x6, 0x20(%rdi)
leaq 0x50(%rsp), %rdi
callq 0x405c
leaq 0x30(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x20(%rsp), %r12
xorl %r15d, %r15d
leaq 0x10(%rsp), %r13
leaq 0x50(%rsp), %rbp
movabsq $-0x5555555555555555, %rbx # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x1(%r15), %rax
movq %rax, 0x48(%rsp)
movl %eax, 0x4(%rsp)
leaq 0xf3dc(%rip), %rdi      # 0x16238
leaq 0x4(%rsp), %rsi
callq 0x5ff0
movq %r12, 0x10(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x3f2e
movq %rbp, %rdi
movq %r13, %rsi
callq 0x40d4
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x6e9f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0xf3ca(%rip), %rdx      # 0x16270
movq 0xf3bb(%rip), %rax      # 0x16268
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %r15, %rdx
jbe 0x6f8b
leaq (%r15,%r15,2), %r13
xorl %r12d, %r12d
movq (%rax,%r13,8), %rcx
movq 0x8(%rax,%r13,8), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rax, %r12
jae 0x6f17
movl (%rcx,%r12,4), %esi
movq %rbp, %rdi
callq 0x424c
movq %r14, %rdi
movq %rbp, %rsi
callq 0x6056
incq %r12
movq 0xf372(%rip), %rdx      # 0x16270
movq 0xf363(%rip), %rax      # 0x16268
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %r15, %rdx
ja 0x6ec8
jmp 0x6f8b
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x60aa
movq 0x30(%rsp), %r12
movq 0x38(%rsp), %r13
cmpq %r12, %r13
je 0x6f4c
movq %r12, %r15
movq %r15, %rdi
callq 0x40b8
addq $0x28, %r15
cmpq %r13, %r15
jne 0x6f36
movq %r12, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, %r15
cmpq $0x3, %rax
leaq 0x20(%rsp), %r12
leaq 0x10(%rsp), %r13
jne 0x6e48
leaq 0x30(%rsp), %rdi
callq 0x60d6
leaq 0x50(%rsp), %rdi
callq 0x40b8
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93c6(%rip), %rdi      # 0x10358
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
movq %rax, %r14
jmp 0x6fda
jmp 0x6fc3
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fc6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x6fc6
jmp 0x6fc3
jmp 0x6fc3
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x60d6
leaq 0x50(%rsp), %rdi
callq 0x40b8
movq 0x8(%rsp), %rdi
callq 0x611e
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::shuffle()
void All_Bonus::shuffle()
{
  unsigned seed;
  if (TEST == 0)
      seed = std::chrono::system_clock::now().time_since_epoch().count();
  else 
      seed = 839223;

  for(int i = 0; i < 3; i++){
    std::shuffle(allBonus.at(i).begin(), allBonus.at(i).end(), std::default_random_engine(seed));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x8, %r12d
xorl %ebx, %ebx
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq 0x8(%rsp), %r15
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %rbx, %rdx
jbe 0x72ed
movq -0x8(%rax,%r12), %rdi
movq (%rax,%r12), %rsi
movq $0xcce37, 0x8(%rsp)     # imm = 0xCCE37
movq %r15, %rdx
callq 0x7ba8
incq %rbx
addq $0x18, %r12
cmpq $0x3, %rbx
jne 0x72a1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x9064(%rip), %rdi      # 0x10358
movq %rbx, %rsi
xorl %eax, %eax
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/AllBonus.cpp
// Function: All_Bonus::getBonus(int)
Token All_Bonus::getBonus(int id)
{
  if( id >= 3 && id <=5)
    return allBonus.at(id-3).at(getSize(id)-1);
  else{ 
    cout<<" getBonus: Invalid type of bonus! Get the 3Bonus instead!" << endl;
  }
  return allBonus.at(0).at(getSize(3)-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leal -0x3(%rdx), %eax
cmpl $0x2, %eax
ja 0x7467
movl %eax, %esi
movq (%r14), %r15
movq 0x8(%r14), %rcx
subq %r15, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rsi, %rax
jbe 0x751a
leaq (%rsi,%rsi,2), %r12
movq %r14, %rdi
movl %edx, %esi
callq 0x73b2
decl %eax
movslq %eax, %rsi
movq (%r15,%r12,8), %rax
movq 0x8(%r15,%r12,8), %rcx
jmp 0x74c0
movq 0xeb62(%rip), %r15      # 0x15fd0
leaq 0x8fff(%rip), %rsi      # 0x10474
movl $0x39, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rcx
cmpq %rcx, 0x8(%r14)
je 0x7526
movslq 0x18(%r14), %rsi
decq %rsi
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x7511
leaq (%rsi,%rsi,4), %rcx
leaq (%rax,%rcx,8), %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f2e
movl 0x20(%r14), %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8e40(%rip), %rdi      # 0x10358
jmp 0x7531
leaq 0x8e37(%rip), %rdi      # 0x10358
movq %rax, %rdx
jmp 0x7531
leaq 0x8e2b(%rip), %rdi      # 0x10358
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Deck.cpp
// Function: Deck::drawCard()
Card Deck::drawCard(){
  Card temp;
  vector<Card>::iterator dit = deck.end()-1;
  temp = *dit;
  deck.erase(dit);
  return temp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x91f8
movq 0x8(%r14), %r15
addq $-0x20, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x918e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9292
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::Market()
Market::Market(){
    Card tmpC;
    tmpC.setCard("CAMEL");
    for (int i = 0; i < 5; ++i)
        goods.push_back(tmpC); 
    size = 5;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x91f8
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6e45(%rip), %rsi      # 0x1017e
leaq 0x6e43(%rip), %rdx      # 0x10183
leaq 0x8(%rsp), %rdi
callq 0x3fc4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x92d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9370
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x5, %ebp
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c16
decl %ebp
jne 0x937a
movl $0x5, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x9292
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x93cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x93cb
jmp 0x93c8
movq %rax, %r14
jmp 0x93d5
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x9292
movq %rbx, %rdi
callq 0x8c54
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::Market(Deck&)
Market::Market(Deck &deck){
    Card tmpC;
    tmpC.setCard("CAMEL");
    for (int i = 0; i < 3; ++i)
        goods.push_back(tmpC); 
    for (int i = 0; i < 2; ++i){
        tmpC = deck.drawCard();
        goods.push_back(tmpC); 
    }
    size = 5;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x91f8
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6d5e(%rip), %rsi      # 0x1017e
leaq 0x6d5c(%rip), %rdx      # 0x10183
movq %rsp, %rdi
callq 0x3fc4
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x92d0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9452
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x3, %ebp
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c16
decl %ebp
jne 0x945c
movb $0x1, %bpl
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x8bcc
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movq %r15, %rdi
callq 0x9292
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8c16
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x9478
movl $0x5, 0x18(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x9292
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x9502
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x9502
jmp 0x94ff
movq %rax, %r14
jmp 0x950c
jmp 0x94ff
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x9292
jmp 0x9502
jmp 0x94ff
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x9292
movq %rbx, %rdi
callq 0x8c54
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::newMarket(Deck&)
void Market::newMarket(Deck &deck){
    goods.clear();
    size = 0;
    Card tmpC;
    tmpC.setCard("CAMEL");
    for (int i = 0; i < 3; ++i)
        goods.push_back(tmpC); 
    for (int i = 0; i < 2; ++i){
        tmpC = deck.drawCard();
        goods.push_back(tmpC); 
    }
    size = 5;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %r13
cmpq %r12, %r13
je 0x9554
movq %r12, %r15
movq %r15, %rdi
callq 0x9292
addq $0x20, %r15
cmpq %r13, %r15
jne 0x953f
movq %r12, 0x8(%rbx)
movl $0x0, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x91f8
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6c09(%rip), %rsi      # 0x1017e
leaq 0x6c07(%rip), %rdx      # 0x10183
leaq 0x8(%rsp), %rdi
callq 0x3fc4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x92d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x95ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movl $0x3, %ebp
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8c16
decl %ebp
jne 0x95b6
movb $0x1, %bpl
leaq 0x48(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x8bcc
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movq %r15, %rdi
callq 0x9292
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8c16
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x95d2
movl $0x5, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x9292
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x965a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x965a
jmp 0x9657
jmp 0x9657
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x9292
jmp 0x965a
jmp 0x9657
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9292
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::getGoods(int)
Card Market::getGoods(int id){
    Card tmpC;
    if (id > 0 && id < size+1){
        tmpC = goods.at(id-1);
        return tmpC;
    }
    // if the card id is outside the market, always return the first card
    else{ 
        cout << "Invalid choice! You get the first Card instead!" << endl; 
        tmpC = goods.at(0);
    }
    return tmpC; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x91f8
testl %r15d, %r15d
jle 0x96ef
cmpl %r15d, 0x18(%r14)
jl 0x96ef
decl %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x9754
shlq $0x5, %r15
addq %r15, %rsi
jmp 0x973e
movq 0xc8da(%rip), %r15      # 0x15fd0
leaq 0x6ec8(%rip), %rsi      # 0x105c5
movl $0x2f, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq 0xc8a8(%rip), %rdi      # 0x15fd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x974f
movq %rbx, %rdi
callq 0x20e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
xorl %edx, %edx
leaq 0x6bfd(%rip), %rdi      # 0x10358
movq %r15, %rsi
xorl %eax, %eax
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x9292
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Market.cpp
// Function: Market::setGoods(Deck&)
void Market::setGoods(Deck &deck){
    int n = 5 - size;
    if (deck.getsize() != 0){
        for (int i = 0; i < n; ++i){
            if(deck.getsize() == 0)
                break;
            goods.push_back(deck.drawCard()); 
            size++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movabsq $0x1fffffffe0, %r12     # imm = 0x1FFFFFFFE0
movl 0x18(%rdi), %eax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
testq %r12, %rcx
setne %cl
cmpl $0x5, %eax
setl %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x9818
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %ecx
subl %eax, %ecx
cmpl $0x2, %ecx
movl $0x1, %ebp
cmovgel %ecx, %ebp
movq %rsp, %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
testq %r12, %rax
je 0x9818
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8bcc
movq %r14, %rdi
movq %r15, %rsi
callq 0x9c80
movq %r15, %rdi
callq 0x9292
incl 0x18(%r14)
decl %ebp
jne 0x97e6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9292
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::Player()
Player::Player(){
    Card tmpC;
    tmpC.setCard("DIAMD");
    vector<Card> cards;
    vector<Card> herds;

    for (int i = 0; i < 3; ++i)
        cards.push_back(tmpC);
    size[0] = 3;

    tmpC.setCard("CAMEL");
    for (int i = 0; i < 2; ++i)
        herds.push_back(tmpC);
    size[1] = 2;

    hand.push_back(cards);
    hand.push_back(herds);

    name = "LLL";

    for (int i = 0; i < 4; ++i)
        point[i] = 0;

    GTokenNum = BTokenNum = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
leaq 0xbef5(%rip), %rax      # 0x15d48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x30(%rsp), %rdi
callq 0x91f8
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x62c2(%rip), %rsi      # 0x10160
leaq 0x62c0(%rip), %rdx      # 0x10165
leaq 0x70(%rsp), %rdi
callq 0x3fc4
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x92d0
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x9ed8
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x21a0
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %r12
movaps %xmm0, (%r12)
xorl %eax, %eax
movq %rax, 0x10(%r12)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x3, %ebp
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8c16
decl %ebp
jne 0x9f03
movl $0x3, 0x40(%r15)
leaq 0x60(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6253(%rip), %rsi      # 0x1017e
leaq 0x6251(%rip), %rdx      # 0x10183
leaq 0x50(%rsp), %rdi
callq 0x3fc4
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x92d0
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x9f62
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8c16
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8c16
movl $0x2, 0x44(%r15)
leaq 0x90(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb58
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb58
movq 0x28(%r15), %rdx
leaq 0x6728(%rip), %rcx      # 0x106d8
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2210
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
movq $0x0, 0x58(%r15)
leaq 0x10(%rsp), %rdi
callq 0x8c54
leaq 0x90(%rsp), %rdi
callq 0x8c54
leaq 0x30(%rsp), %rdi
callq 0x9292
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0xa051
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0xa051
jmp 0xa04e
movq %rax, %r15
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0xa068
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0xa068
movq %rax, %r15
jmp 0xa068
movq %rax, %r15
jmp 0xa072
jmp 0xa04e
jmp 0xa04e
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x8c54
leaq 0x90(%rsp), %rdi
callq 0x8c54
leaq 0x30(%rsp), %rdi
callq 0x9292
movq (%r14), %rdi
cmpq 0x8(%rsp), %rdi
je 0xa08c
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0xbb84
movq %r15, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::Player(Deck&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player::Player(Deck &deck, string playerName){
    Card tmpC;
    int i;
    size[0] = size[1] = 0;

    vector<Card> cards;
    vector<Card> herds;

    // draw five cards from deck, if card == CAMEL put it in herds 
    for (i = 0; i < 5; ++i){
        tmpC = deck.drawCard();
        if (tmpC.getCard() == "CAMEL"){
            herds.push_back(tmpC);
            size[1]++;
        }
        else{
            cards.push_back(tmpC);
            size[0]++;
        }
    }

    hand.push_back(cards);
    hand.push_back(herds);

    name = playerName;

    // initialize all points to zero
    for (i = 0; i < 4; ++i)
        point[i] = 0;

    GTokenNum = BTokenNum = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %r15
leaq 0xbc89(%rip), %rax      # 0x15d48
movq %rax, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x30(%rdi), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x78(%rsp), %rdi
callq 0x91f8
xorl %eax, %eax
movq %rax, 0x40(%r15)
leaq 0x40(%rsp), %rcx
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
leaq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movaps %xmm0, (%rcx)
movl $0x5, %r14d
leaq 0x58(%rsp), %r12
leaq 0x78(%rsp), %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x8bcc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20e0
movq %r12, %rdi
callq 0x9292
movq %r12, %rdi
movq %rbx, %rsi
callq 0x92ae
movq %r12, %rdi
leaq 0x601b(%rip), %rsi      # 0x1017e
callq 0x2080
movl %eax, %ebp
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xa186
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21a0
testl %ebp, %ebp
je 0xa19d
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x8c16
incl 0x40(%r15)
jmp 0xa1ae
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x8c16
incl 0x44(%r15)
decl %r14d
jne 0xa130
leaq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r12
callq 0xbb58
leaq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0xbb58
movq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x20e0
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r15)
movq $0x0, 0x58(%r15)
leaq 0x20(%rsp), %rdi
callq 0x8c54
leaq 0x40(%rsp), %rdi
callq 0x8c54
leaq 0x78(%rsp), %rdi
callq 0x9292
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %r14
movq 0x8(%rsp), %r12
jmp 0xa27b
movq %rax, %rbx
movq (%rsp), %r14
jmp 0xa25d
jmp 0xa251
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x9292
jmp 0xa254
jmp 0xa251
movq %rax, %rbx
movq (%rsp), %r14
movq 0x8(%rsp), %r12
leaq 0x20(%rsp), %rdi
callq 0x8c54
leaq 0x40(%rsp), %rdi
callq 0x8c54
leaq 0x78(%rsp), %rdi
callq 0x9292
movq (%r12), %rdi
cmpq %r14, %rdi
je 0xa28f
movq (%r14), %rsi
incq %rsi
callq 0x21a0
movq 0x10(%rsp), %rdi
callq 0xbb84
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::setHand(Card)
void Player::setHand(Card c){
    if (c.getCard() == "CAMEL"){
        hand.at(1).push_back(c);
        size[1]++;
    }
    else{
        hand.at(0).push_back(c);
        size[0]++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x92ae
leaq 0x5b5a(%rip), %rsi      # 0x1017e
movq %r15, %rdi
callq 0x2080
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa648
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rax
testl %ebp, %ebp
je 0xa666
cmpq %rdi, %rax
je 0xa69b
movq %r14, %rsi
callq 0x8c16
incl 0x40(%rbx)
jmp 0xa690
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq $0x1, %rdx
jbe 0xa6a8
addq $0x18, %rdi
movq %r14, %rsi
callq 0x8c16
incl 0x44(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5cb6(%rip), %rdi      # 0x10358
xorl %esi, %esi
xorl %edx, %edx
jmp 0xa6b4
leaq 0x5ca9(%rip), %rdi      # 0x10358
movl $0x1, %esi
xorl %eax, %eax
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::getHand(int, int) const
Card Player::getHand(int type, int location) const{ // location from 0
    if (type >= 0 && type <= 1){
        if (location >= 0 && location < size[type])
            return hand.at(type).at(location); 
        else{ // if location out of range, return the first card
            cout << "getHand: location is out of range! get the first card instead!" << endl;
            return hand.at(type).at(0);
        }
    }
    else{ // if type not found, return the card
        cout << "getHand: card type not found! will return a card(not camel) instead!" << endl;
    }
    return hand.at(0).at(0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x1, %edx
ja 0xa733
movl %edx, %r15d
testl %ecx, %ecx
js 0xa7b8
cmpl %ecx, 0x40(%r14,%r15,4)
jle 0xa7b8
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %r15, %rdx
jbe 0xa83d
leaq (%r15,%r15,2), %rdx
movl %ecx, %esi
movq (%rdi,%rdx,8), %rax
movq 0x8(%rdi,%rdx,8), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rsi, %rdx
jbe 0xa849
shlq $0x5, %rsi
addq %rsi, %rax
jmp 0xa790
movq 0xb896(%rip), %r15      # 0x15fd0
leaq 0x5fda(%rip), %rsi      # 0x1071b
movl $0x44, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x8(%r14), %rcx
cmpq %rcx, 0x10(%r14)
je 0xa830
movq (%rcx), %rax
cmpq %rax, 0x8(%rcx)
je 0xa830
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3f2e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xb811(%rip), %r12      # 0x15fd0
leaq 0x5f16(%rip), %rsi      # 0x106dc
movl $0x3e, %edx
movq %r12, %rdi
callq 0x21d0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %r15, %rdx
jbe 0xa83d
leaq (%r15,%r15,2), %rdx
movq (%rcx,%rdx,8), %rax
cmpq %rax, 0x8(%rcx,%rdx,8)
jne 0xa790
leaq 0x5b21(%rip), %rdi      # 0x10358
xorl %esi, %esi
xorl %edx, %edx
jmp 0xa850
leaq 0x5b14(%rip), %rdi      # 0x10358
movq %r15, %rsi
jmp 0xa850
leaq 0x5b08(%rip), %rdi      # 0x10358
xorl %eax, %eax
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::getPoints(int) const
int Player::getPoints(int type) const{
    if (type >= 0 && type <=3)
        return point[type];
    else
        cout << "getPoints: point type not found! Will return total points!" << endl;
    return point[2];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %esi
ja 0xa8d4
movl %esi, %eax
leaq (%rbx,%rax,4), %rbx
addq $0x48, %rbx
jmp 0xa91a
movq 0xb6f5(%rip), %r14      # 0x15fd0
leaq 0x5e7e(%rip), %rsi      # 0x10760
movl $0x3a, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x50, %rbx
movl (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::Take(int, Market&, Deck&)
void Player::Take(int location, Market &M, Deck &D){
    //check the current size of hand cards: not exceed 7 
    if (size[0] < 7){
        //take the card,update card size
        setHand(M.getGoods(location));
        M.delGoods(location);
        //draw a card from deck to market
        M.setGoods(D);
    }
    else
        cout << "Take: Cannot take card: already 7 cards!" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x6, 0x40(%rdi)
jg 0xac7e
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rdx, %rsi
movl %ebp, %edx
callq 0x96b2
movq %r15, %rdi
movq %r12, %rsi
callq 0xa600
movq %rsp, %rdi
callq 0x9292
movq %r14, %rdi
movl %ebp, %esi
callq 0x9778
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9798
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xb34b(%rip), %rbx      # 0x15fd0
leaq 0x5b0f(%rip), %rsi      # 0x1079b
movl $0x28, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9292
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Player.cpp
// Function: Player::TakeCamel(Market&, Deck&)
void Player::TakeCamel(Market &M, Deck &D){
    int i;
    int n = M.getSize();
    vector<int> L;
    // take all CAMEL cards in market into herds
    for (i = 0; i < n; ++i){
        Card tmpC = M.getGoods(i+1);
        if (tmpC.getCard() == "CAMEL"){ 
            setHand(tmpC);
            L.push_back(i);
        }
    }

    // delete all the CAMEL cards in market
    int m = L.size();
    M.delGoods(L.at(0)+1);
    for (i = 1; i < m; ++i)
        M.delGoods(L.at(i)-i+1);

    // fill up the market from deck
    M.setGoods(D);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, 0x28(%rsp)
movq %rsi, %r14
movq %rdi, 0x30(%rsp)
movq %rsi, %rdi
callq 0x96ae
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
xorl %edx, %edx
testl %eax, %eax
jle 0xb234
movl %eax, %ebp
leaq 0x78(%rsp), %r12
leaq 0x58(%rsp), %r13
leaq 0x38(%rsp), %r15
incl %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x96b2
movq %r13, %rdi
movq %r12, %rsi
callq 0x92ae
movq %r13, %rdi
leaq 0x50ac(%rip), %rsi      # 0x1017e
callq 0x2080
movl %eax, %ebx
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0xb0f5
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21a0
testl %ebx, %ebx
jne 0xb15c
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3f2e
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0xa600
movq %r15, %rdi
callq 0x9292
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0xb14d
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0xb15c
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0xc21e
movq %r12, %rdi
callq 0x9292
movl 0xc(%rsp), %edx
incl %edx
movl %edx, 0xc(%rsp)
cmpl %ebp, %edx
jl 0xb0b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rbx
subq %rax, %rbx
sarq $0x2, %rbx
cmpq %rax, %rcx
je 0xb238
movl (%rax), %esi
incl %esi
movq %r14, %rdi
callq 0x9778
movl $0x1, 0xc(%rsp)
cmpl $0x2, %ebx
jl 0xb1e7
movl $0x1, %eax
movslq %eax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rdx, %rcx
jbe 0xb21d
movl (%rax,%rdx,4), %esi
subl %edx, %esi
incl %esi
movq %r14, %rdi
callq 0x9778
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
cmpl %ebx, %eax
jl 0xb1b1
movq %r14, %rdi
movq 0x28(%rsp), %rsi
callq 0x9798
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb20b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rbx
leaq 0x5131(%rip), %rdi      # 0x10358
movq %rdx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21f0
xorl %ebx, %ebx
jmp 0xb220
xorl %edx, %edx
jmp 0xb220
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x9292
jmp 0xb259
jmp 0xb251
jmp 0xb256
jmp 0xb251
movq %rax, %rbx
jmp 0xb263
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x9292
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb27a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::Game(Deck&, Market&, Human&, Human&)
Game::Game(Deck &dd, Market &mm, Human &pp1, Human &pp2) : deck(dd), market(mm), p1(pp1), p2(pp2) { //construct a game for Human vs. Human
    bonus.shuffle();//initialize all bonus
    setRound(1);//initialize round to 1
    setTurn(1);//initialize turn to 1
    srand(time(NULL));
    /*for demo*/

    currplayer = 1;

    /* comment out this for demonstration
    if (rand() % 100 > 50)
        currplayer = 1;
    else 
        currplayer = 2;
    */
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x4f08
leaq 0x58(%rbx), %r15
movq %r15, %rdi
callq 0x6dd8
movq %r15, %rdi
callq 0x727a
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x80(%rbx)
xorl %edi, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
movl $0x1, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x72fe
jmp 0xc956
movq %rax, %rbx
movq %r14, %rdi
callq 0x53ae
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::RoundTermination()
Game::~Game(){
    deck.clear(); 
    market.clear();
    p1.clear();
    p2.clear();
    tokens.clear();
    bonus.clear();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x5, %rcx
testl %ecx, %ecx
je 0xd323
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
addq $0x38, %rbx
xorl %r13d, %r13d
movl $0x1, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xecbc
movups (%rbx), %xmm0
movups 0xc(%rbx), %xmm1
leaq 0x18(%rsp), %rax
movups %xmm1, 0xc(%rax)
movups %xmm0, (%rax)
movq %r15, %rdi
movl %ebp, %esi
callq 0x5462
movl %eax, %r12d
movq %r15, %rdi
callq 0x53ae
cmpl $0x1, %r12d
adcl $0x0, %r13d
incl %ebp
cmpl $0x7, %ebp
jne 0xd2d8
cmpl $0x3, %r13d
setae %al
jmp 0xd325
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x53ae
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::newRound(int)
void Game::newRound(int winner){ 
    //clear player's basic points, bonus points, total points
    for (int i = 0; i < 3; i++){
        p1.addPoint(i,-1*p1.getPoints(i));
        p2.addPoint(i,-1*p1.getPoints(i));
    }

    setTurn(1);
    setCurrPlayer(winner);
    deck.newDeck();
    deck.shuffle();
    market.newMarket(deck);
    tokens.newAToken();
    bonus.newABonus();
    p1.newPlayer(deck);
    p2.newPlayer(deck);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0xa8bc
negl %eax
movq %r15, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0xa5c2
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r15
movl %r14d, %esi
callq 0xa8bc
negl %eax
movq %r15, %rdi
movl %r14d, %esi
movl %eax, %edx
callq 0xa5c2
incl %r14d
cmpl $0x3, %r14d
jne 0xc9e7
movl $0x1, 0x84(%rbx)
movl %ebp, 0x88(%rbx)
movq (%rbx), %rdi
callq 0x857a
movq (%rbx), %rdi
callq 0x8bb0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
callq 0x951c
leaq 0x20(%rbx), %rdi
callq 0x511e
leaq 0x58(%rbx), %rdi
callq 0x6fec
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0xa38e
movq (%rbx), %rsi
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa38e
nop
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::display(Player&)
void Game::display(Player &p){
    system("clear");
    tokens.printTokens();
    bonus.pBonus();
    market.printMarket();
    p.printPlayer();
    cout << "=====================================================================================Round " << getRound() << " Turn " << getTurn() << "=========================================================================================" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3752(%rip), %rdi      # 0x10aab
callq 0x2140
leaq 0x20(%rbx), %rdi
callq 0x5690
leaq 0x58(%rbx), %rdi
callq 0x75ae
movq 0x8(%rbx), %rdi
callq 0x9846
movq %r14, %rdi
callq 0xb282
movq 0x8c48(%rip), %r14      # 0x15fd0
leaq 0x3722(%rip), %rsi      # 0x10ab1
movl $0x5b, %edx
movq %r14, %rdi
callq 0x21d0
movl 0x80(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %r14
leaq 0x3759(%rip), %rsi      # 0x10b0d
movl $0x6, %edx
movq %rax, %rdi
callq 0x21d0
movl 0x84(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %rbx
leaq 0x373b(%rip), %rsi      # 0x10b14
movl $0x59, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::roundWinner()
int Game::roundWinner(){
    

    // check the total rupees
    if (p1.getPoints(2) > p2.getPoints(2))
        return 1;
    else if (p1.getPoints(2) < p2.getPoints(2))
        return 2;
    else if (p1.getBToken() > p2.getBToken())
        return 1;
    else if (p1.getBToken() < p2.getBToken())
        return 2;
    else if (p1.getGToken() > p2.getGToken())
        return 1;
    else
        return 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl $0x2, %esi
callq 0xa8bc
movl %eax, %ebp
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xa8bc
movl $0x1, %ebx
cmpl %eax, %ebp
jg 0xd745
movq 0x10(%r14), %rdi
movl $0x2, %esi
callq 0xa8bc
movl %eax, %ebp
movq 0x18(%r14), %rdi
movl $0x2, %esi
callq 0xa8bc
cmpl %eax, %ebp
jge 0xd721
movl $0x2, %ebx
jmp 0xd745
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rax
movl 0x5c(%rax), %edx
cmpl %edx, 0x5c(%rcx)
jg 0xd745
movl $0x2, %ebx
jl 0xd745
movl 0x58(%rcx), %ecx
xorl %ebx, %ebx
cmpl 0x58(%rax), %ecx
setle %bl
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/whitefusion[P]Jaipur_cardgame-/Game.cpp
// Function: Game::takeVerify(Market&, int&)
bool Game::takeVerify(Market &m, int &take){
    if (take < 1 || take > 5 || m.getGoods(take).getCard()=="CAMEL")
        return false;
    else 
        return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl (%rdx), %edx
leal -0x6(%rdx), %eax
cmpl $-0x5, %eax
jae 0xe395
xorl %ebx, %ebx
jmp 0xe3ec
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x96b2
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x92ae
leaq 0x1dc8(%rip), %rsi      # 0x1017e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe3e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x28(%rsp), %rdi
callq 0x9292
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9292
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/ruippeixotog[P]algo-lib/knuth-morris-pratt.cpp
// Function: kmp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>&)
void kmp(string str, string pattern, vector<int>& res) {
  res.clear();

  pi[0] = 0;
  for(int i = 1; i < pattern.size(); i++) {
    pi[i] = pi[i - 1];
    while(pi[i] > 0 && pattern[i] != pattern[pi[i]])
      pi[i] = pi[pi[i] - 1];
    if(pattern[i] == pattern[pi[i]]) pi[i]++;
  }

  int k = 0;
  for(int i = 0; i < str.size(); i++) {
    while(k > 0 && str[i] != pattern[k])
      k = pi[k - 1];
    if(str[i] == pattern[k]) k++;
    if(k == pattern.size()) {
      res.push_back(i - k + 1);
      k = pi[k - 1];
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x129d
movq %rax, 0x8(%rbx)
movl $0x0, 0x2e29(%rip)      # 0x40d0
movq 0x8(%r14), %rax
leaq 0x2e1e(%rip), %r13      # 0x40d0
cmpq $0x2, %rax
jb 0x12f9
movq (%r14), %rcx
movl $0x1, %edx
movl %edx, %esi
movslq %esi, %rsi
movslq -0x4(%r13,%rsi,4), %rsi
movl %esi, (%r13,%rdx,4)
testq %rsi, %rsi
jle 0x12e0
movb (%rcx,%rdx), %dil
cmpb (%rcx,%rsi), %dil
jne 0x12c2
jmp 0x12ea
movb (%rcx,%rdx), %dil
cmpb (%rcx,%rsi), %dil
jne 0x12f1
incl %esi
movl %esi, (%r13,%rdx,4)
incq %rdx
cmpq %rax, %rdx
jne 0x12c0
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x1378
xorl %ebp, %ebp
xorl %ecx, %ecx
movq (%r15), %rdx
movb (%rdx,%rbp), %dl
movq (%r14), %rsi
testl %ecx, %ecx
jle 0x1323
movl %ecx, %edi
cmpb (%rsi,%rdi), %dl
je 0x1323
decl %ecx
movl (%r13,%rcx,4), %ecx
jmp 0x130f
movslq %ecx, %rcx
xorl %edi, %edi
cmpb (%rsi,%rcx), %dl
sete %dil
addl %edi, %ecx
movslq %ecx, %r12
cmpq %r12, 0x8(%r14)
jne 0x1370
movl %ebp, %edx
subl %ecx, %edx
incl %edx
movl %edx, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x135a
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x136b
movq %rbx, %rdi
leaq 0x4(%rsp), %rdx
callq 0x1546
movq 0x8(%r15), %rax
movl -0x4(%r13,%r12,4), %ecx
incq %rbp
cmpq %rbp, %rax
ja 0x1306
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ruippeixotog[P]algo-lib/knuth-morris-pratt.cpp
// Function: main
int main() {
  vector<int> res;
  kmp("AABAACAADAABAAABAA", "AABA", res);

  cout << "Expected: 0 9 13" << endl;
  cout << "  Result: ";
  for(int idx : res) cout << idx << " ";
  cout << endl;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc50(%rip), %rsi       # 0x2004
leaq 0xc5b(%rip), %rdx       # 0x2016
leaq 0x40(%rsp), %rdi
callq 0x167a
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc42(%rip), %rsi       # 0x2017
leaq 0xc3f(%rip), %rdx       # 0x201b
leaq 0x20(%rsp), %rdi
callq 0x167a
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x127c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1407
callq 0x10b0
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x1416
callq 0x10b0
movq 0x2bbb(%rip), %rbx      # 0x3fd8
leaq 0xbf8(%rip), %rsi       # 0x201c
movl $0x10, %edx
movq %rbx, %rdi
callq 0x10e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq 0x2b89(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq 0x2b75(%rip), %rbx      # 0x3fd8
leaq 0xbc3(%rip), %rsi       # 0x202d
movl $0xa, %edx
movq %rbx, %rdi
callq 0x10e0
movq (%rsp), %r12
movq 0x8(%rsp), %r13
cmpq %r13, %r12
je 0x14b8
movq 0x2b4c(%rip), %r14      # 0x3fd8
leaq 0xba3(%rip), %r15       # 0x2036
movl (%r12), %esi
movq %r14, %rdi
callq 0x1110
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10e0
addq $0x4, %r12
cmpq %r13, %r12
jne 0x1493
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10c0
movsbl %al, %esi
movq 0x2b02(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14f1
callq 0x10b0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1518
callq 0x10b0
jmp 0x1518
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x1530
callq 0x10b0
jmp 0x1530
jmp 0x152d
jmp 0x152d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x153e
callq 0x10b0
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O3/hdlguy[P]fft_demo/demo.cpp
// Function: window(std::vector<double, std::allocator<double>>*)
void window(vector<double> *vec) 
{
    // Hamming.
    //const double a = 0.54;
    //const double b = 1.0 - a;
    //vector<double>::size_type n = vec->size();
    //for(int i=0; i<n; i++) (*vec)[i] *= a - b*cos(2.0*M_PI*i/(n-1));

    // Hanning
    vector<double>::size_type n = vec->size();
    for(int i=0; i<n; i++) (*vec)[i] *= 0.5*(1.0-cos(2.0*M_PI*i/(n-1)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %r14
subq (%rdi), %r14
je 0x2067
movq %rdi, %rbx
sarq $0x3, %r14
leaq -0x1(%r14), %rax
movq %rax, %xmm0
punpckldq 0x1022(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x102a(%rip), %xmm0     # 0x3030
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, -0x30(%rbp)
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %r15d, %r15d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd 0xfd6(%rip), %xmm0      # 0x3008
divsd -0x30(%rbp), %xmm0
callq 0x1190
movsd 0x106c(%rip), %xmm1     # 0x30b0
subsd %xmm0, %xmm1
mulsd 0x1068(%rip), %xmm1     # 0x30b8
movq (%rbx), %rax
mulsd (%rax,%r15,8), %xmm1
movsd %xmm1, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x2022
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/QZzcoder[P]LiveChat/./SocketManager.h
// Function: Blockqueue<int>::take()
T Blockqueue<T>::take(){
    std::unique_lock<std::mutex> lock(_mutex);
    _cv.wait(lock,[this]{return !this->_queue.empty();});
    T ret(_queue.front());
    _queue.pop_front();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x6cba
movb $0x1, 0x8(%r14)
movq 0x68(%rbx), %rax
cmpq %rax, 0x88(%rbx)
jne 0x6160
leaq 0x28(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x30b0
movq 0x68(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x6148
addq $0x58, %rbx
movl (%rax), %r14d
movq %rbx, %rdi
callq 0x6c4c
leaq -0x28(%rbp), %rdi
callq 0x6ca0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pehublove[P]GPS-neo7n-forBaiduMap/test.cpp
// Function: split(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>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void split(vector<string> &elems, const string& s, const string& delim)
{
	size_t pos = 0;
	size_t len = s.length();
	size_t delim_len = delim.length();
	if (delim_len == 0) return;
	while (pos < len)
	{
		int find_pos = s.find(delim, pos);
		if (find_pos < 0)
		{
			elems.push_back(s.substr(pos, len - pos));
			break;
		}
		elems.push_back(s.substr(pos, find_pos - pos));
		pos = find_pos + delim_len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x58(%rbp)
movq 0x8(%rsi), %rcx
movq 0x8(%rdx), %rax
movq %rax, -0x60(%rbp)
testq %rax, %rax
setne %al
movq %rcx, -0x50(%rbp)
testq %rcx, %rcx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x26b5
movq %rdx, %r12
movq %rsi, %r14
xorl %r13d, %r13d
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %r14, %rdi
movq %r13, %rdx
callq 0x22a0
movq %rax, %rbx
testl %ebx, %ebx
js 0x2677
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movq %rbx, %rcx
subq %r13, %rcx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x21d0
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x2fe0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2668
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
addq -0x60(%rbp), %rbx
movq %rbx, %r13
cmpq -0x50(%rbp), %rbx
jb 0x260a
jmp 0x26b5
movq -0x50(%rbp), %rcx
subq %r13, %rcx
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x21d0
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x2fe0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26b5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26c6
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x26e2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22b0